| 1 | /** Skull marker: bounty + decaying kill counter. Magenta-tint color curve. */ |
| 2 | |
| 3 | export const SKULL_KILL_BONUS = 500; |
| 4 | export const SKULL_DECAY_PER_SECOND = 1; |
| 5 | |
| 6 | /** |
| 7 | * Default skull value at pure black. White→black below this; red lerp (and |
| 8 | * town-guard hostility) start strictly above it. |
| 9 | * Overridable via world setting `skullBlackMax`. |
| 10 | */ |
| 11 | export const SKULL_BLACK_MAX_DEFAULT = 500; |
| 12 | /** |
| 13 | * Default skull value at pure red. Black→red between black max and this; |
| 14 | * beyond it, tint leans toward dark red. |
| 15 | * Overridable via world setting `skullRedMax`. |
| 16 | */ |
| 17 | export const SKULL_RED_MAX_DEFAULT = 500_000; |
| 18 | |
| 19 | /** @deprecated Use {@link SKULL_BLACK_MAX_DEFAULT}. */ |
| 20 | export const SKULL_RED_LERP_START = SKULL_BLACK_MAX_DEFAULT; |
| 21 | /** @deprecated Use {@link SKULL_RED_MAX_DEFAULT}. */ |
| 22 | export const SKULL_PURE_RED_VALUE = SKULL_RED_MAX_DEFAULT; |
| 23 | /** @deprecated Dark-red clamp is derived as 2× red max. */ |
| 24 | export const SKULL_DARK_RED_VALUE = SKULL_RED_MAX_DEFAULT * 2; |
| 25 | |
| 26 | /** |
| 27 | * @param {number} bountyCopper |
| 28 | * @param {number} killCounter |
| 29 | */ |
| 30 | export function skullValue (bountyCopper, killCounter) |
| 31 | { |
| 32 | return Math.max(0, Math.floor(Number(bountyCopper) || 0) + Math.floor(Number(killCounter) || 0)); |
| 33 | } |
| 34 | |
| 35 | /** |
| 36 | * Resolve tint / guard thresholds from world settings (falls back to defaults). |
| 37 | * @param {{ skullBlackMax?: number, skullRedMax?: number } | null | undefined} settings |
| 38 | */ |
| 39 | export function resolveSkullThresholds (settings = null) |
| 40 | { |
| 41 | const blackMax = Math.max( |
| 42 | 1, |
| 43 | Math.floor(Number(settings?.skullBlackMax) || SKULL_BLACK_MAX_DEFAULT) |
| 44 | ); |
| 45 | let redMax = Math.max( |
| 46 | 1, |
| 47 | Math.floor(Number(settings?.skullRedMax) || SKULL_RED_MAX_DEFAULT) |
| 48 | ); |
| 49 | if (redMax <= blackMax) |
| 50 | { redMax = blackMax + 1; } |
| 51 | return { |
| 52 | blackMax, |
| 53 | redMax, |
| 54 | darkRedMax: redMax * 2 |
| 55 | }; |
| 56 | } |
| 57 | |
| 58 | /** |
| 59 | * True once the skull tint starts lerping from black toward red |
| 60 | * (skull value strictly above black max). |
| 61 | * @param {number} value |
| 62 | * @param {{ skullBlackMax?: number, skullRedMax?: number } | null | undefined} [settings] |
| 63 | */ |
| 64 | export function skullAttractsTownGuards (value, settings = null) |
| 65 | { |
| 66 | const { blackMax } = resolveSkullThresholds(settings); |
| 67 | return Math.max(0, Math.floor(Number(value) || 0)) > blackMax; |
| 68 | } |
| 69 | |
| 70 | /** |
| 71 | * Decay kill counter by elapsed wall time (1 point / second). |
| 72 | * @returns {{ killCounter: number, consumedMs: number }} |
| 73 | */ |
| 74 | export function decayKillCounter (killCounter, elapsedMs) |
| 75 | { |
| 76 | const current = Math.max(0, Number(killCounter) || 0); |
| 77 | if (current <= 0 || !(elapsedMs > 0)) |
| 78 | { return { killCounter: current, consumedMs: 0 }; } |
| 79 | const decay = Math.min(current, Math.floor(elapsedMs / 1000) * SKULL_DECAY_PER_SECOND); |
| 80 | return { |
| 81 | killCounter: current - decay, |
| 82 | consumedMs: decay * 1000 |
| 83 | }; |
| 84 | } |
| 85 | |
| 86 | function lerp (a, b, t) |
| 87 | { |
| 88 | return a + (b - a) * t; |
| 89 | } |
| 90 | |
| 91 | /** |
| 92 | * Magenta-tint target color for a skull value (0 = invisible / unused). |
| 93 | * 1…blackMax → white→black; …→ pure red at redMax; then → dark red (128,0,0). |
| 94 | * @param {number} value |
| 95 | * @param {{ skullBlackMax?: number, skullRedMax?: number } | null | undefined} [settings] |
| 96 | * @returns {{ r: number, g: number, b: number } | null} 0–1 channels, or null if invisible |
| 97 | */ |
| 98 | export function skullTintColor (value, settings = null) |
| 99 | { |
| 100 | const v = Math.max(0, Math.floor(Number(value) || 0)); |
| 101 | if (v <= 0) |
| 102 | { return null; } |
| 103 | const { blackMax, redMax, darkRedMax } = resolveSkullThresholds(settings); |
| 104 | if (v <= blackMax) |
| 105 | { |
| 106 | const t = v / blackMax; |
| 107 | const c = lerp(1, 0, t); |
| 108 | return Object.freeze({ r: c, g: c, b: c }); |
| 109 | } |
| 110 | if (v <= redMax) |
| 111 | { |
| 112 | // Black (0,0,0) → pure red (1,0,0). |
| 113 | const t = (v - blackMax) / (redMax - blackMax); |
| 114 | return Object.freeze({ |
| 115 | r: lerp(0, 1, t), |
| 116 | g: 0, |
| 117 | b: 0 |
| 118 | }); |
| 119 | } |
| 120 | const t = Math.min(1, (v - redMax) / (darkRedMax - redMax)); |
| 121 | const dark = 128 / 255; |
| 122 | return Object.freeze({ |
| 123 | r: lerp(1, dark, t), |
| 124 | g: 0, |
| 125 | b: 0 |
| 126 | }); |
| 127 | } |