Manuel Vögele
286 lines
9.0 KiB
JavaScript
286 lines
9.0 KiB
JavaScript
import {availableSpeedProviders, currentSpeedProvider, getDefaultSpeedProvider, updateSpeedProvider} from "./api.js";
|
|
import {SpeedProvider} from "./speed_provider.js"
|
|
|
|
export const settingsKey = "drag-ruler";
|
|
|
|
export const RightClickAction = Object.freeze({
|
|
CREATE_WAYPOINT: 0,
|
|
DELETE_WAYPOINT: 1,
|
|
ABORT_DRAG:2,
|
|
});
|
|
|
|
export function registerSettings() {
|
|
game.settings.register(settingsKey, "dataVersion", {
|
|
scope: "world",
|
|
config: false,
|
|
type: String,
|
|
default: "fresh install"
|
|
})
|
|
|
|
game.settings.register(settingsKey, "clientDataVersion", {
|
|
scope: "client",
|
|
config: false,
|
|
type: String,
|
|
default: "fresh install"
|
|
});
|
|
|
|
game.settings.register(settingsKey, "rightClickAction", {
|
|
name: "drag-ruler.settings.rightClickAction.name",
|
|
hint: "drag-ruler.settings.rightClickAction.hint",
|
|
config: true,
|
|
type: Number,
|
|
default: RightClickAction.DELETE_WAYPOINT,
|
|
choices: {
|
|
0: "drag-ruler.settings.rightClickAction.choices.create",
|
|
1: "drag-ruler.settings.rightClickAction.choices.delete",
|
|
2: "drag-ruler.settings.rightClickAction.choices.cancel",
|
|
},
|
|
});
|
|
|
|
game.settings.register(settingsKey, "autoStartMeasurement", {
|
|
name: "drag-ruler.settings.autoStartMeasurement.name",
|
|
hint: "drag-ruler.settings.autoStartMeasurement.hint",
|
|
scope: "client",
|
|
config: true,
|
|
type: Boolean,
|
|
default: true,
|
|
});
|
|
|
|
game.settings.register(settingsKey, "useGridlessRaster", {
|
|
name: "drag-ruler.settings.useGridlessRaster.name",
|
|
hint: "drag-ruler.settings.useGridlessRaster.hint",
|
|
scope: "client",
|
|
config: true,
|
|
type: Boolean,
|
|
default: true,
|
|
});
|
|
|
|
game.settings.register(settingsKey, "alwaysShowSpeedForPCs", {
|
|
name: "drag-ruler.settings.alwaysShowSpeedForPCs.name",
|
|
hint: "drag-ruler.settings.alwaysShowSpeedForPCs.hint",
|
|
scope: "world",
|
|
config: true,
|
|
type: Boolean,
|
|
default: true,
|
|
})
|
|
|
|
game.settings.register(settingsKey, "showGMRulerToPlayers", {
|
|
name: "drag-ruler.settings.showGMRulerToPlayers.name",
|
|
hint: "drag-ruler.settings.showGMRulerToPlayers.hint",
|
|
scope: "world",
|
|
config: true,
|
|
type: Boolean,
|
|
default: true,
|
|
})
|
|
|
|
game.settings.register(settingsKey, "enableMovementHistory", {
|
|
name: "drag-ruler.settings.enableMovementHistory.name",
|
|
hint: "drag-ruler.settings.enableMovementHistory.hint",
|
|
scope: "world",
|
|
config: true,
|
|
type: Boolean,
|
|
default: true,
|
|
});
|
|
|
|
game.settings.register(settingsKey, "lastTerrainRulerHintTime", {
|
|
config: false,
|
|
type: Number,
|
|
default: 0,
|
|
});
|
|
|
|
game.settings.register(settingsKey, "neverShowTerrainRulerHint", {
|
|
config: false,
|
|
type: Boolean,
|
|
default: false,
|
|
});
|
|
|
|
// This setting will be modified by the api if modules register to it
|
|
game.settings.register(settingsKey, "speedProvider", {
|
|
scope: "world",
|
|
config: false,
|
|
type: String,
|
|
default: getDefaultSpeedProvider(),
|
|
onChange: updateSpeedProvider,
|
|
})
|
|
|
|
game.settings.registerMenu(settingsKey, "speedProviderSettings", {
|
|
name: "drag-ruler.settings.speedProviderSettings.name",
|
|
hint: "drag-ruler.settings.speedProviderSettings.hint",
|
|
label: "drag-ruler.settings.speedProviderSettings.button",
|
|
icon: "fas fa-tachometer-alt",
|
|
type: SpeedProviderSettings,
|
|
restricted: false,
|
|
})
|
|
}
|
|
|
|
class SpeedProviderSettings extends FormApplication {
|
|
static get defaultOptions() {
|
|
return mergeObject(super.defaultOptions, {
|
|
id: "drag-ruler-speed-provider-settings",
|
|
title: game.i18n.localize("drag-ruler.settings.speedProviderSettings.windowTitle"),
|
|
template: "modules/drag-ruler/templates/speed_provider_settings.html",
|
|
width: 600,
|
|
})
|
|
}
|
|
|
|
getData(options={}) {
|
|
const data = {}
|
|
data.isGM = game.user.isGM
|
|
const selectedProvider = currentSpeedProvider.id
|
|
|
|
// Insert all speed providers into the template data
|
|
data.providers = Object.values(availableSpeedProviders).map(speedProvider => {
|
|
const provider = {}
|
|
provider.id = speedProvider.id
|
|
provider.hasSettings = speedProvider instanceof SpeedProvider
|
|
if (provider.hasSettings)
|
|
provider.settings = enumerateProviderSettings(speedProvider)
|
|
let dotPosition = provider.id.indexOf(".")
|
|
if (dotPosition === -1)
|
|
dotPosition = provider.id.length
|
|
const type = provider.id.substring(0, dotPosition)
|
|
const id = provider.id.substring(dotPosition + 1)
|
|
if (type === "native") {
|
|
provider.selectTitle = game.i18n.localize("drag-ruler.settings.speedProviderSettings.speedProvider.choices.native")
|
|
}
|
|
else {
|
|
let name
|
|
if (type === "module") {
|
|
name = game.modules.get(id).data.title
|
|
}
|
|
else {
|
|
name = game.system.data.title
|
|
}
|
|
provider.selectTitle = game.i18n.format(`drag-ruler.settings.speedProviderSettings.speedProvider.choices.${type}`, {name})
|
|
}
|
|
provider.isSelected = provider.id === selectedProvider
|
|
return provider
|
|
})
|
|
data.selectedProviderName = data.providers.find(provider => provider.isSelected).selectTitle
|
|
|
|
data.providerSelection = {
|
|
id: "speedProvider",
|
|
name: game.i18n.localize("drag-ruler.settings.speedProviderSettings.speedProvider.name"),
|
|
hint: game.i18n.localize("drag-ruler.settings.speedProviderSettings.speedProvider.hint"),
|
|
type: String,
|
|
choices: data.providers.reduce((choices, provider) => {
|
|
choices[provider.id] = provider.selectTitle
|
|
return choices
|
|
}, {}),
|
|
value: selectedProvider,
|
|
isCheckbox: false,
|
|
isSelect: true,
|
|
isRange: false,
|
|
}
|
|
return data
|
|
}
|
|
|
|
async _updateObject(event, formData) {
|
|
const selectedSpeedProvider = game.user.isGM ? formData.speedProvider : game.settings.get(settingsKey, "speedProvider")
|
|
for (let [key, value] of Object.entries(formData)) {
|
|
// Check if this is color, convert the value to an integer
|
|
const splitKey = key.split(".", 3)
|
|
if (splitKey[0] !== "native")
|
|
splitKey.shift()
|
|
if (splitKey.length >= 2 && splitKey[1] == "color") {
|
|
value = parseInt(value.substring(1), 16)
|
|
}
|
|
|
|
// Don't change settings for speed providers that aren't currently active
|
|
if (key !== "speedProvider" && !key.startsWith(selectedSpeedProvider))
|
|
continue
|
|
|
|
// Get the key for the current setting
|
|
let setting
|
|
if (key === "speedProvider")
|
|
setting = "speedProvider"
|
|
else
|
|
setting = `speedProviders.${key}`
|
|
|
|
// Get the old setting value
|
|
const oldValue = game.settings.get(settingsKey, setting)
|
|
|
|
// Only update the setting if it has been changed (this leaves the default in place if it hasn't been touched)
|
|
if (value !== oldValue)
|
|
game.settings.set(settingsKey, setting, value)
|
|
}
|
|
|
|
// Activate the configured speed provider
|
|
updateSpeedProvider()
|
|
}
|
|
|
|
activateListeners(html) {
|
|
super.activateListeners(html)
|
|
html.find("select[name=speedProvider]").change(this.onSpeedProviderChange.bind(this))
|
|
}
|
|
|
|
onSpeedProviderChange(event) {
|
|
// Hide all module settings
|
|
document.querySelectorAll(".drag-ruler-provider-settings").forEach(element => element.style.display = "none")
|
|
// Show the settings block for the currently selected module
|
|
document.getElementById(`drag-ruler.provider.${event.currentTarget.value}`).style.display = ""
|
|
|
|
// Recalculate window height
|
|
this.element[0].style.height = null
|
|
this.position.height = undefined
|
|
}
|
|
}
|
|
|
|
function toDomHex(value) {
|
|
const hex = value.toString(16)
|
|
return "#" + "0".repeat(Math.max(0, 6 - hex.length)) + hex
|
|
}
|
|
|
|
function enumerateProviderSettings(provider) {
|
|
const colorSettings = []
|
|
const unreachableColor = {id: "unreachable", name: "drag-ruler.settings.speedProviderSettings.color.unreachable.name"}
|
|
|
|
// Resolve settings for the colors
|
|
for (const color of provider.colors.concat([unreachableColor])) {
|
|
// Localize the name, if avaliable. If no name is available use the id as name
|
|
const colorName = color.name ? game.i18n.localize(color.name) : color.id
|
|
let hint
|
|
if (color === unreachableColor)
|
|
hint = game.i18n.localize("drag-ruler.settings.speedProviderSettings.color.unreachable.hint")
|
|
else
|
|
hint = game.i18n.format("drag-ruler.settings.speedProviderSettings.color.hint", {colorName})
|
|
colorSettings.push({
|
|
id: `${provider.id}.color.${color.id}`,
|
|
name: game.i18n.format("drag-ruler.settings.speedProviderSettings.color.name", {colorName}),
|
|
hint: hint,
|
|
type: Number,
|
|
value: toDomHex(game.settings.get(settingsKey, `speedProviders.${provider.id}.color.${color.id}`)),
|
|
isCheckbox: false,
|
|
isSelect: false,
|
|
isRange: false,
|
|
isColor: true,
|
|
})
|
|
}
|
|
|
|
// Prepare regular settings
|
|
const settings = []
|
|
for (const setting of provider.settings) {
|
|
try {
|
|
if (setting.scope === "world" && !game.user.isGM)
|
|
continue
|
|
const s = duplicate(setting)
|
|
s.id = `${provider.id}.setting.${s.id}`
|
|
s.name = game.i18n.localize(s.name)
|
|
s.hint = game.i18n.localize(s.hint)
|
|
s.value = provider.getSetting(setting.id)
|
|
s.type = setting.type instanceof Function ? setting.type.name : "String"
|
|
s.isCheckbox = setting.type === Boolean
|
|
s.isSelect = s.choices !== undefined
|
|
s.isRange = (setting.type === Number) && s.range
|
|
s.isColor = false
|
|
settings.push(s)
|
|
}
|
|
catch (e) {
|
|
console.warn(`Drag Ruler | The following error occured while rendering setting "${setting.id}" of module/system "${this.id}. It won't be displayed.`)
|
|
console.error(e)
|
|
}
|
|
}
|
|
|
|
return settings.concat(colorSettings)
|
|
}
|