BlueGit

projects-timfalken-com allianties

Files

allianties / src / rules.js

rules.js

rules.js 7.6 KiB Download Raw
1'use strict';
2
3/**
4 * Client-side mirror of the Allianties rule helpers.
5 * Used for legal-move previews, the cease-fire clock, countdowns, and tests.
6 * The server (Engine.php) is authoritative for every action.
7 */
8var Rules = {
9 TZ: 'Europe/Amsterdam',
10 STARTING_LIVES: 3,
11 STARTING_RANGE: 2,
12 STARTING_AP: 1,
13 MIN_PLAYERS: 2,
14 MAX_PLAYERS: 16,
15 MIN_GRID: 6,
16 MIN_ARENA: 3,
17 DEFAULT_SHRINK_DAYS: 7,
18 COLORS: [
19 '#e74c3c', '#3498db', '#2ecc71', '#f1c40f',
20 '#9b59b6', '#e67e22', '#1abc9c', '#e91e63',
21 '#00bcd4', '#8bc34a', '#ff5722', '#3f51b5',
22 '#795548', '#607d8b', '#cddc39', '#ff9800'
23 ]
24};
25
26Rules.defaultRules = function ()
27{
28 return {
29 jury: true,
30 shrinking_arena: false,
31 shrink_interval_days: this.DEFAULT_SHRINK_DAYS,
32 ceasefire: false,
33 ceasefire_ranges: [],
34 ap_loot: false,
35 ap_time: '00:00',
36 vis_shots: 'public',
37 vis_gifts: 'public',
38 vis_ap: 'public',
39 vis_range: 'public',
40 vis_lives: 'public'
41 };
42};
43
44Rules.gridSize = function (n)
45{
46 if (n < 1) { n = 1; }
47 return Math.max(this.MIN_GRID, Math.ceil(Math.sqrt(n * 6)));
48};
49
50Rules.maxInset = function (size)
51{
52 return Math.max(0, Math.floor((size - this.MIN_ARENA) / 2));
53};
54
55Rules.chebyshev = function (x1, y1, x2, y2)
56{
57 return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2));
58};
59
60Rules.inBounds = function (size, x, y)
61{
62 return x >= 0 && y >= 0 && x < size && y < size;
63};
64
65Rules.isPassable = function (size, inset, x, y)
66{
67 return this.inBounds(size, x, y)
68 && x >= inset && y >= inset && x < size - inset && y < size - inset;
69};
70
71Rules.parseHm = function (v)
72{
73 if (typeof v !== 'string') { return null; }
74 var m = /^(\d{1,2}):(\d{2})$/.exec(v.trim());
75 if (!m) { return null; }
76 var h = parseInt(m[1], 10), min = parseInt(m[2], 10);
77 if (h > 23 || min > 59) { return null; }
78 return (h < 10 ? '0' : '') + h + ':' + (min < 10 ? '0' : '') + min;
79};
80
81Rules.hmToMinutes = function (hm)
82{
83 var p = hm.split(':');
84 return parseInt(p[0], 10) * 60 + parseInt(p[1], 10);
85};
86
87Rules.minutesToHm = function (mins)
88{
89 mins = ((mins % 1440) + 1440) % 1440;
90 var h = Math.floor(mins / 60), m = mins % 60;
91 return (h < 10 ? '0' : '') + h + ':' + (m < 10 ? '0' : '') + m;
92};
93
94Rules.normalizeRanges = function (raw)
95{
96 if (!Array.isArray(raw)) { return []; }
97 var out = [], seen = {};
98 for (var i = 0; i < raw.length; i++)
99 {
100 var r = raw[i];
101 if (!r) { continue; }
102 var start = this.parseHm(r.start || r[0]);
103 var end = this.parseHm(r.end || r[1]);
104 if (!start || !end || start === end) { continue; }
105 var key = start + '-' + end;
106 if (seen[key]) { continue; }
107 seen[key] = true;
108 out.push({ start: start, end: end });
109 }
110 out.sort(function (a, b) { return a.start < b.start ? -1 : a.start > b.start ? 1 : 0; });
111 return out.slice(0, 12);
112};
113
114/** Unix timestamp of ymd 00:00 in Europe/Amsterdam. */
115Rules.amsterdamMidnight = function (ymd)
116{
117 var parts = ymd.split('-').map(Number);
118 var Y = parts[0], M = parts[1], D = parts[2];
119 // First guess: UTC midnight minus one hour (CET).
120 var utc = Date.UTC(Y, M - 1, D, 0, 0, 0) - 3600 * 1000;
121 for (var i = 0; i < 5; i++)
122 {
123 var p = this._amsterdamParts(utc);
124 var got = Date.UTC(+p.year, +p.month - 1, +p.day, +p.hour, +p.minute, +(p.second || 0));
125 var want = Date.UTC(Y, M - 1, D, 0, 0, 0);
126 utc += (want - got);
127 }
128 return Math.floor(utc / 1000);
129};
130
131Rules._amsterdamParts = function (unixMs)
132{
133 var fmt = new Intl.DateTimeFormat('en-US', {
134 timeZone: 'Europe/Amsterdam',
135 year: 'numeric', month: '2-digit', day: '2-digit',
136 hour: '2-digit', minute: '2-digit', second: '2-digit',
137 hourCycle: 'h23'
138 });
139 var p = {};
140 fmt.formatToParts(new Date(unixMs)).forEach(function (x)
141 {
142 if (x.type !== 'literal') { p[x.type] = x.value; }
143 });
144 return p;
145};
146
147Rules.amsterdamYmd = function (unix)
148{
149 var p = this._amsterdamParts(unix * 1000);
150 return p.year + '-' + p.month + '-' + p.day;
151};
152
153/**
154 * Wall-clock HH:MM on a civil date in Europe/Amsterdam, as unix seconds.
155 * Matches PHP DateTime::modify("+N minutes") from midnight: civil minutes
156 * walk through DST (spring-forward shortens, fall-back lengthens).
157 * Non-existent times (e.g. 02:30 on a spring-forward day) land after the gap.
158 */
159Rules.amsterdamWallclock = function (ymd, hm)
160{
161 var t = this.amsterdamMidnight(ymd);
162 var target = this.hmToMinutes(hm);
163 if (target === 0)
164 { return t; }
165 for (var i = 0; i < 8; i++)
166 {
167 var p = this._amsterdamParts(t * 1000);
168 var day = p.year + '-' + p.month + '-' + p.day;
169 var got = (+p.hour) * 60 + (+p.minute);
170 if (day !== ymd)
171 {
172 // Overflowed into another civil day (should be rare for HH:MM).
173 var sign = day > ymd ? 1 : -1;
174 got += sign * 1440;
175 }
176 var remaining = target - got;
177 if (remaining === 0)
178 { return t; }
179 // If we oscillate around a spring-forward gap, take the later side.
180 t += remaining * 60;
181 }
182 return t;
183};
184
185Rules.addDaysYmd = function (ymd, days)
186{
187 // Add calendar days via Amsterdam midnight + 26h, then read the ymd and
188 // correct — safer: midnight + days*24h may skip/double; use Date in UTC
189 // of the civil date then shift.
190 var p = ymd.split('-').map(Number);
191 var d = new Date(Date.UTC(p[0], p[1] - 1, p[2] + days));
192 var mm = d.getUTCMonth() + 1, dd = d.getUTCDate();
193 return d.getUTCFullYear() + '-' + (mm < 10 ? '0' : '') + mm + '-' + (dd < 10 ? '0' : '') + dd;
194};
195
196Rules.ceasefireIntervals = function (ranges, now)
197{
198 ranges = this.normalizeRanges(ranges);
199 if (!ranges.length) { return []; }
200 var anchor = this.amsterdamYmd(now);
201 var intervals = [];
202 for (var d = -1; d <= 3; d++)
203 {
204 var ymd = this.addDaysYmd(anchor, d);
205 var next = this.addDaysYmd(anchor, d + 1);
206 for (var i = 0; i < ranges.length; i++)
207 {
208 var r = ranges[i];
209 var startM = this.hmToMinutes(r.start);
210 var endM = this.hmToMinutes(r.end);
211 var startTs = this.amsterdamWallclock(ymd, r.start);
212 var endTs = endM > startM
213 ? this.amsterdamWallclock(ymd, r.end)
214 : this.amsterdamWallclock(next, r.end);
215 if (endTs > startTs) { intervals.push([startTs, endTs]); }
216 }
217 }
218 intervals.sort(function (a, b) { return a[0] - b[0] || a[1] - b[1]; });
219 var merged = [];
220 for (var j = 0; j < intervals.length; j++)
221 {
222 var iv = intervals[j];
223 if (!merged.length || iv[0] > merged[merged.length - 1][1])
224 { merged.push(iv.slice()); }
225 else
226 { merged[merged.length - 1][1] = Math.max(merged[merged.length - 1][1], iv[1]); }
227 }
228 return merged;
229};
230
231Rules.ceasefireInfo = function (rules, now)
232{
233 if (!rules || !rules.ceasefire) { return null; }
234 var ranges = this.normalizeRanges(rules.ceasefire_ranges);
235 if (!ranges.length) { return null; }
236 var intervals = this.ceasefireIntervals(ranges, now);
237 var active = false, until = null;
238 for (var i = 0; i < intervals.length; i++)
239 {
240 var iv = intervals[i];
241 if (now >= iv[0] && now < iv[1])
242 {
243 active = true;
244 until = iv[1];
245 break;
246 }
247 if (iv[0] > now && (until === null || iv[0] < until))
248 { until = iv[0]; }
249 }
250 return {
251 enabled: true,
252 active: active,
253 until: until,
254 seconds: until !== null ? Math.max(0, until - now) : 0,
255 ranges: ranges
256 };
257};
258
259Rules.formatHms = function (seconds)
260{
261 seconds = Math.max(0, Math.floor(seconds));
262 var h = Math.floor(seconds / 3600);
263 var m = Math.floor((seconds % 3600) / 60);
264 var s = seconds % 60;
265 function pad (n) { return n < 10 ? '0' + n : String(n); }
266 return pad(h) + ':' + pad(m) + ':' + pad(s);
267};
268
269if (typeof module !== 'undefined' && module.exports)
270{ module.exports = Rules; }
271else if (typeof globalThis !== 'undefined')
272{ globalThis.Rules = Rules; }
273
274/**
275 * Map a 0–1 position along the timeline track to a spend index 0..n
276 * (0 = before the first spend, n = after the last / live). Nearest event.
277 */
278Rules.timelineIndex = function (t, n)
279{
280 n = n | 0;
281 if (n <= 0) { return 0; }
282 t = Math.max(0, Math.min(1, Number(t) || 0));
283 return Math.round(t * n);
284};