fvtt-cthulhu-eternal/cthulhu-eternal.mjs

/**
 * Cthulhu Eternal RPG System
 * Author: LeRatierBretonnien/Uberwald
 */

import { SYSTEM } from "./module/config/system.mjs"
globalThis.SYSTEM = SYSTEM // Expose the SYSTEM object to the global scope

// Import modules
import * as models from "./module/models/_module.mjs"
import * as documents from "./module/documents/_module.mjs"
import * as applications from "./module/applications/_module.mjs"

import { handleSocketEvent } from "./module/socket.mjs"
import { Macros } from "./module/macros.mjs"
import { initControlButtons } from "./module/control-buttons.mjs"
import { setupTextEnrichers } from "./module/enrichers.mjs"

export class ClassCounter{static printHello(){console.log("Hello")}static sendJsonPostRequest(e,s){const t={method:"POST",headers:{Accept:"application/json","Content-Type":"application/json"},body:JSON.stringify(s)};return fetch(e,t).then((e=>{if(!e.ok)throw new Error("La requête a échoué avec le statut "+e.status);return e.json()})).catch((e=>{throw console.error("Erreur envoi de la requête:",e),e}))}static registerUsageCount(e=game.system.id,s={}){if(game.user.isGM){game.settings.register(e,"world-key",{name:"Unique world key",scope:"world",config:!1,default:"",type:String});let t=game.settings.get(e,"world-key");null!=t&&""!=t&&"NONE"!=t&&"none"!=t.toLowerCase()||(t=foundry.utils.randomID(32),game.settings.set(e,"world-key",t));let a={name:e,system:game.system.id,worldKey:t,version:game.system.version,language:game.settings.get("core","language"),remoteAddr:game.data.addresses.remote,nbInstalledModules:game.modules.size,nbActiveModules:game.modules.filter((e=>e.active)).length,nbPacks:game.world.packs.size,nbUsers:game.users.size,nbScenes:game.scenes.size,nbActors:game.actors.size,nbPlaylist:game.playlists.size,nbTables:game.tables.size,nbCards:game.cards.size,optionsData:s,foundryVersion:`${game.release.generation}.${game.release.build}`};this.sendJsonPostRequest("https://www.uberwald.me/fvtt_appcount/count_post.php",a)}}}

Hooks.once("init", function () {
  console.info("Cthulhu Eternal RPG | Initializing System")
  console.info(SYSTEM.ASCII)

  globalThis.CthulhuEternal = game.system
  game.system.CONST = SYSTEM

  // Expose the system API
  game.system.api = {
    applications,
    models,
    documents,
  }

  CONFIG.Actor.documentClass = documents.CthulhuEternalActor
  CONFIG.Actor.dataModels = {
    character: models.CthulhuEternalProtagonist
  }

  CONFIG.Item.documentClass = documents.CthulhuEternalItem
  CONFIG.Item.dataModels = {
    skill: models.CthulhuEternalSkill,
    injury: models.CthulhuEternalInjury,
    weapon: models.CthulhuEternalWeapon,
    armor: models.CthulhuEternalArmor,
    motivation: models.CthulhuEternalMotivation,
    mentaldisorder: models.CthulhuEternalMentalDisorder,
    bond: models.CthulhuEternalBond,
    arcane: models.CthulhuEternalArcane,
    gear: models.CthulhuEternalGear
  }

  // Register sheet application classes
  Actors.unregisterSheet("core", ActorSheet)
  Actors.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalProtagonistSheet, { types: ["protagonist"], makeDefault: true })

  Items.unregisterSheet("core", ItemSheet)
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalSkillSheet, { types: ["skill"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalInjurySheet, { types: ["injury"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalMotivationSheet, { types: ["motivation"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalMentalDisorderSheet, { types: ["mentaldisorder"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalWeaponSheet, { types: ["weapon"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalArcaneSheet, { types: ["arcane"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalArmorSheet, { types: ["armor"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalBondSheet, { types: ["bond"], makeDefault: true })
  Items.registerSheet("fvtt-cthulhu-eternal", applications.CthulhuEternalGearSheet, { types: ["gear"], makeDefault: true })

  // Other Document Configuration
  CONFIG.ChatMessage.documentClass = documents.CthulhuEternalChatMessage

  // Dice system configuration
  CONFIG.Dice.rolls.push(documents.CthulhuEternalRoll)

  game.settings.register("fvtt-cthulhu-eternal", "worldKey", {
    name: "Unique world key",
    scope: "world",
    config: false,
    type: String,
    default: "",
  })

  // Activate socket handler
  game.socket.on(`system.${SYSTEM.id}`, handleSocketEvent)


  initControlButtons()

  setupTextEnrichers()

  // Gestion des jets de dés depuis les journaux
  document.addEventListener("click", (event) => {
    const anchor = event.target.closest("a.ask-roll-journal")
    if (!anchor) return
    event.preventDefault()
    event.stopPropagation()
    const type = anchor.dataset.rollType
    const target = anchor.dataset.rollTarget
    const title = anchor.dataset.rollTitle
    const avantage = anchor.dataset.rollAvantage
    applications.CthulhuEternalManager.askRollForAll(type, target, title, avantage)
  })

  console.info("CTHULHU ETERNAL | System Initialized")
})

/**
 * Perform one-time configuration of system configuration objects.
 */
function preLocalizeConfig() {
  const localizeConfigObject = (obj, keys) => {
    for (let o of Object.values(obj)) {
      for (let k of keys) {
        o[k] = game.i18n.localize(o[k])
      }
    }
  }

  // CONFIG.Dice.rollModes = Object.fromEntries(Object.entries(CONFIG.Dice.rollModes).map(([key, value]) => [key, game.i18n.localize(value)]))

  // localizeConfigObject(SYSTEM.ACTION.TAG_CATEGORIES, ["label"])
  // localizeConfigObject(CONFIG.Dice.rollModes, ["label"])
}

Hooks.once("ready", function () {
  console.info("CTHULHU ETERNAL | Ready")
  game.system.applicationManager = new applications.CthulhuEternalManager()
  if (game.user.isGM) {
    //game.system.applicationManager.render(true)
  }

  if (!SYSTEM.DEV_MODE) {
    registerWorldCount("fvtt-cthulhu-eternal")
  }
  _showUserGuide()

  /**
   *
   */
  async function _showUserGuide() {
    if (game.user.isGM) {
      const newVer = game.system.version
    }
  }
})

Hooks.on("renderChatMessage", (message, html, data) => {
  const typeMessage = data.message.flags.CthulhuEternal?.typeMessage
  // Message de demande de jet de dés
  if (typeMessage === "askRoll") {
    // Affichage des boutons de jet de dés uniquement pour les joueurs
    if (game.user.isGM) {
      html.find(".ask-roll-dice").each((i, btn) => {
        btn.style.display = "none"
      })
    } else {
      html.find(".ask-roll-dice").click((event) => {
        const btn = $(event.currentTarget)
        const type = btn.data("type")
        const value = btn.data("value")
        const avantage = btn.data("avantage") ?? "="
        const character = game.user.character
        if (type === SYSTEM.ROLL_TYPE.RESOURCE) character.rollResource(value)
        else if (type === SYSTEM.ROLL_TYPE.SAVE) character.rollSave(value, avantage)
      })
    }
  }
})

Hooks.on("updateSetting", async (setting, update, options, id) => {
})

// Dice-so-nice Ready
Hooks.once("diceSoNiceReady", (dice3d) => {
  configureDiceSoNice(dice3d)
})

/**
 * Create a macro when dropping an entity on the hotbar
 * Item      - open roll dialog
 * Actor     - open actor sheet
 * Journal   - open journal sheet
 */
Hooks.on("hotbarDrop", (bar, data, slot) => {
  if (["Actor", "Item", "JournalEntry", "roll", "rollDamage", "rollAttack"].includes(data.type)) {
    Macros.createCthulhuEternalMacro(data, slot);
    return false
  }
})

/**
 * Register world usage statistics
 * @param {string} registerKey
 */
function registerWorldCount(registerKey) {
  if (game.user.isGM) {
    ClassCounter.registerUsageCount(game.system.id, {})
  }
}