BlueGit

projects-timfalken-com meteors

Files

meteors / test / minis-flights-playwright.py

minis-flights-playwright.py

minis-flights-playwright.py 18.3 KiB Download Raw
1#!/usr/bin/env python3
2"""Layout and flight-arc visuals for t1125 (wide / narrow / mobile)."""
3from __future__ import annotations
4
5import socket
6import subprocess
7import sys
8import time
9from pathlib import Path
10
11from playwright.sync_api import sync_playwright
12
13ROOT = Path("/workspace/meteors")
14OUT = Path("/workspace/meteors-shots")
15OUT.mkdir(parents=True, exist_ok=True)
16CHROME = "/usr/bin/google-chrome"
17CHROME_ARGS = [
18 "--use-gl=angle",
19 "--use-angle=swiftshader",
20 "--no-sandbox",
21 "--disable-dev-shm-usage",
22 "--disable-gpu-sandbox",
23]
24FAILURES = []
25
26
27def free_port():
28 s = socket.socket()
29 s.bind(("127.0.0.1", 0))
30 port = s.getsockname()[1]
31 s.close()
32 return port
33
34
35def check(cond, msg):
36 if not cond:
37 FAILURES.append(msg)
38 print("FAIL", msg)
39 else:
40 print("OK ", msg)
41 return cond
42
43
44def shot(page, name):
45 path = OUT / name
46 page.screenshot(path=str(path), full_page=False)
47 print(f"wrote {path} ({path.stat().st_size} bytes)")
48 return path
49
50
51def start_http(port):
52 proc = subprocess.Popen(
53 ["python3", "-m", "http.server", str(port), "--bind", "127.0.0.1",
54 "--directory", str(ROOT / "build")],
55 stdout=subprocess.DEVNULL,
56 stderr=subprocess.DEVNULL,
57 )
58 time.sleep(0.35)
59 if proc.poll() is not None:
60 raise RuntimeError("http.server failed to start")
61 return proc
62
63
64def open_offline(page, url, round_n=1):
65 page.goto(url, wait_until="domcontentloaded", timeout=15000)
66 page.wait_for_timeout(400)
67 page.locator("#btn-offline").click()
68 page.wait_for_selector("#planet-select:not([hidden])", timeout=8000)
69 page.locator("#btn-planet-go").click()
70 page.wait_for_function(
71 "() => app && app.mode === 'playing' && app.offline && app.battle && app.core",
72 timeout=10000,
73 )
74 if round_n != 1:
75 page.evaluate(
76 """(round) => {
77 teardownPlay();
78 startPlay({ planet: app.planet, offline: true, round: round });
79 }""",
80 round_n,
81 )
82 page.wait_for_function(
83 "() => app && app.mode === 'playing' && app.battle && app.miniLayout",
84 timeout=8000,
85 )
86 page.wait_for_timeout(250)
87
88
89LAYOUT_INFO = """() => {
90 const plan = app.miniLayout || {};
91 const fieldEl = app.scene && app.scene.canvas;
92 const fr = fieldEl ? fieldEl.getBoundingClientRect() : null;
93 const minis = [...document.querySelectorAll('#minis .mini')].map((el) => {
94 const r = el.getBoundingClientRect();
95 const c = el.querySelector('canvas');
96 const cr = c ? c.getBoundingClientRect() : r;
97 return {
98 id: el.getAttribute('data-player'),
99 left: r.left, right: r.right, top: r.top, bottom: r.bottom,
100 cx: cr.left + cr.width / 2,
101 cy: cr.top + cr.height / 2
102 };
103 });
104 return {
105 mode: plan.mode,
106 sidesClass: document.getElementById('minis').classList.contains('sides'),
107 n: plan.n,
108 field: fr ? { left: fr.left, right: fr.right, top: fr.top, bottom: fr.bottom,
109 x: app.fieldX, y: app.fieldY, w: app.fieldW, h: app.fieldH } : null,
110 positions: plan.positions || [],
111 minis,
112 tile: app.tile,
113 vw: window.innerWidth,
114 vh: window.innerHeight
115 };
116}"""
117
118
119
120INJECT_FLIGHTS = """(age) => {
121 if (age == null) age = 0.55;
122 const plan = app.miniLayout;
123 const field = app.scene.canvas.getBoundingClientRect();
124 function anchor(id, inner) {
125 const el = document.querySelector('#minis .mini[data-player="' + id + '"] canvas');
126 if (!el) return { x: 80, y: 80 };
127 const r = el.getBoundingClientRect();
128 if (plan && plan.mode === 'sides') {
129 return { x: r.left + r.width / 2, y: r.top + 4 };
130 }
131 return { x: r.left + r.width / 2, y: inner ? r.bottom : r.top };
132 }
133 const bots = (app.battle.bots || []).map(b => b.id);
134 const a = bots[0] || 'bot-1';
135 const b = bots[1] || bots[0] || 'bot-2';
136 const landCol = 3;
137 const pStart = {
138 x: field.left + ((4 + 0.5) / 10) * field.width,
139 y: field.top + 4
140 };
141 if (typeof Online.clearFlights === 'function') Online.clearFlights();
142 const flights = [
143 { id: 'vis-p2e', client_id: 'vis-p2e', from_id: 'player', target_id: a, miss: false, color: 0, flight_duration: 1.2, age: age, land_col: landCol },
144 { id: 'vis-e2p', client_id: 'vis-e2p', from_id: a, target_id: 'player', miss: false, color: 1, flight_duration: 1.2, age: age, land_col: landCol },
145 { id: 'vis-e2e', client_id: 'vis-e2e', from_id: a, target_id: b, miss: false, color: 2, flight_duration: 1.2, age: age, land_col: 7 },
146 { id: 'vis-emiss', client_id: 'vis-emiss', from_id: b, target_id: null, miss: true, color: 3, flight_duration: 1.2, age: Math.min(age, 0.45) }
147 ];
148 const aOut = anchor(a, true);
149 const bOut = anchor(b, true);
150 const locals = {
151 'vis-p2e': { from_id: 'player', color: 0, startX: pStart.x, startY: pStart.y, col: 4, land_col: landCol },
152 'vis-e2p': { from_id: a, color: 1, startX: aOut.x, startY: aOut.y, land_col: landCol },
153 'vis-e2e': { from_id: a, color: 2, startX: aOut.x, startY: aOut.y, land_col: 7 },
154 'vis-emiss': { from_id: b, color: 3, startX: bOut.x, startY: bOut.y }
155 };
156 Online.spawnFlights(flights, locals);
157 Online.tickFlights();
158 const front = [...document.querySelectorAll('#flights .flight')].map(el => ({
159 src: el.getAttribute('src') || el.src,
160 transform: el.style.transform,
161 parent: 'front'
162 }));
163 const back = [...document.querySelectorAll('#flights-back .flight')].map(el => ({
164 src: el.getAttribute('src') || el.src,
165 transform: el.style.transform,
166 parent: 'back'
167 }));
168 const kinds = (Online._flights || []).map(f => {
169 const raw = Math.min(0.999, Math.max(0, (performance.now() - f.t0) / f.duration));
170 const u = Online.easeInOutCubic(raw);
171 let pt;
172 if (f.waypoints && f.waypoints.length > 2)
173 { pt = Online.pointOnPath(f.waypoints, u); }
174 else if (f.kind === 'enemy-to-player' || f.kind === 'player-to-enemy')
175 { pt = Online.aroundFieldPoint(f.start, f.end, u, f.field, (f.height || 80) * 0.45); }
176 else
177 { pt = Online.arcPoint(f.start, f.end, u, f.height || 80); }
178 const samples = [];
179 if (f.kind === 'enemy-to-player' || f.kind === 'player-to-enemy')
180 {
181 for (let i = 0; i <= 16; i++)
182 {
183 const su = i / 16;
184 let sp;
185 if (f.waypoints && f.waypoints.length > 2)
186 { sp = Online.pointOnPath(f.waypoints, su); }
187 else
188 { sp = Online.aroundFieldPoint(f.start, f.end, su, f.field, (f.height || 80) * 0.45); }
189 samples.push({
190 u: su, x: sp.x, y: sp.y,
191 inside: Online.pointInFieldInterior(sp.x, sp.y, f.field)
192 });
193 }
194 }
195 return {
196 kind: f.kind, miss: f.miss,
197 startScale: f.startScale, endScale: f.endScale,
198 parent: (f.el && f.el.parentElement && f.el.parentElement.id) || '',
199 src: (f.el && (f.el.getAttribute('src') || f.el.src)) || '',
200 color: f.color,
201 landCol: f.landCol,
202 end: f.end,
203 pos: pt,
204 samples: samples,
205 insideNow: f.field ? Online.pointInFieldInterior(pt.x, pt.y, f.field) : false
206 };
207 });
208 const expectedEndX = field.left + ((landCol + 0.5) / 10) * field.width;
209 return {
210 front: front.length,
211 back: back.length,
212 kinds,
213 expectedEndX,
214 field: { left: field.left, right: field.right, top: field.top, bottom: field.bottom },
215 pad: field.top,
216 hudH: app.hudH,
217 mode: plan.mode
218 };
219}"""
220
221
222
223EDGE = 16
224
225
226def assert_sides(info, tag, expect_rows=False, expect_one_row=False, n=None):
227 check(info["mode"] == "sides", f"{tag}: mode is sides (got {info['mode']})")
228 check(info["sidesClass"], f"{tag}: #minis has .sides")
229 field = info["field"]
230 minis = info["minis"]
231 positions = info.get("positions") or []
232 vw = info.get("vw") or 0
233 check(len(minis) >= 1, f"{tag}: at least one mini ({len(minis)})")
234 if n is not None:
235 check(len(minis) == n, f"{tag}: expected {n} minis, got {len(minis)}")
236 if field:
237 check(field["top"] >= 56 + 70 or field.get("y", 0) >= 56 + 70
238 or (info.get("vh") or 900) < 600 and field["top"] >= 56 + 80,
239 f"{tag}: wide layout has top padding (field.top={field['top']:.1f}, y={field.get('y')})")
240 if not field or not minis:
241 return
242
243 # Bottom-aligned with the field (row 0).
244 row0 = []
245 for i, m in enumerate(minis):
246 pos = positions[i] if i < len(positions) else {}
247 if pos.get("row", 0) == 0:
248 row0.append(m)
249 check(abs(m["bottom"] - field["bottom"]) <= 10,
250 f"{tag}: mini {i} ({m['id']}) is bottom-aligned "
251 f"(bottom={m['bottom']:.1f} field.bottom={field['bottom']:.1f})")
252 check(m["top"] >= 40,
253 f"{tag}: mini {i} stays under the HUD (top={m['top']:.1f})")
254 # Every mini sits entirely to the left or right of the field.
255 left_of = m["right"] <= field["left"] + 2
256 right_of = m["left"] >= field["right"] - 2
257 check(left_of or right_of,
258 f"{tag}: mini {i} is beside the field, not above it")
259
260 # Alternating sides, outer-edge anchored, filling inward (t1133).
261 if len(minis) >= 1:
262 check(minis[0]["left"] <= EDGE + 6,
263 f"{tag}: bot 1 is at the left outer edge (left={minis[0]['left']:.1f})")
264 if len(minis) >= 2:
265 check(minis[1]["right"] >= vw - EDGE - 6,
266 f"{tag}: bot 2 is at the right outer edge (right={minis[1]['right']:.1f} vw={vw})")
267 if len(minis) >= 3:
268 check(minis[2]["left"] > minis[0]["left"] + 20,
269 f"{tag}: bot 3 is inward of bot 1, toward the field "
270 f"({minis[0]['left']:.1f} → {minis[2]['left']:.1f})")
271 # Same row when they fit (3 bots on a wide-enough side).
272 if positions and positions[0].get("row") == 0 and positions[2].get("row") == 0:
273 check(abs(minis[2]["bottom"] - minis[0]["bottom"]) <= 6,
274 f"{tag}: bot 3 shares the bottom row with bot 1")
275 if len(minis) >= 4:
276 check(minis[3]["right"] < minis[1]["right"] - 20,
277 f"{tag}: bot 4 is inward of bot 2, toward the field")
278
279 if expect_one_row:
280 rows = [p.get("row", 0) for p in positions] if positions else []
281 check(rows and all(r == 0 for r in rows),
282 f"{tag}: all minis sit in a single row (rows={rows})")
283 if expect_rows:
284 rows = [p.get("row", 0) for p in positions] if positions else []
285 check(any(r >= 1 for r in rows),
286 f"{tag}: wraps to a second row (rows={rows})")
287 # Wrapped minis start again at the outer edges and sit above row 0.
288 lefts = [(i, minis[i], positions[i]) for i in range(len(minis))
289 if i < len(positions) and positions[i].get("side") == "left"]
290 r0 = [t for t in lefts if t[2].get("row") == 0 and t[2].get("fromOuter") == 0]
291 r1 = [t for t in lefts if t[2].get("row") == 1 and t[2].get("fromOuter") == 0]
292 if r0 and r1:
293 check(abs(r1[0][1]["left"] - r0[0][1]["left"]) <= 4,
294 f"{tag}: wrapped left mini is again at the outer edge")
295 check(r1[0][1]["bottom"] <= r0[0][1]["top"] + 8,
296 f"{tag}: wrapped row sits above the first")
297
298
299def assert_top(info, tag):
300 check(info["mode"] == "top", f"{tag}: mode is top (got {info['mode']})")
301 check(not info["sidesClass"], f"{tag}: #minis is not .sides")
302 field = info["field"]
303 minis = info["minis"]
304 check(len(minis) >= 1, f"{tag}: at least one mini")
305 if not field or not minis:
306 return
307 for i, m in enumerate(minis):
308 check(m["bottom"] <= field["top"] + 12,
309 f"{tag}: mini {i} sits above the field "
310 f"(bottom={m['bottom']:.1f} field.top={field['top']:.1f})")
311
312
313def assert_flights(info, tag, expect_behind=True, expect_around=True):
314 check(info["front"] >= 3, f"{tag}: front flights present ({info['front']})")
315 kinds = {k["kind"]: k for k in info["kinds"]}
316 check("player-to-enemy" in kinds, f"{tag}: player-to-enemy")
317 check("enemy-to-player" in kinds, f"{tag}: enemy-to-player")
318 check("enemy-miss" in kinds, f"{tag}: enemy-miss")
319 if "player-to-enemy" in kinds:
320 k = kinds["player-to-enemy"]
321 check(k["startScale"] > k["endScale"],
322 f"{tag}: player-to-enemy shrinks ({k['startScale']:.2f}→{k['endScale']:.2f})")
323 check("gray" in (k.get("src") or "").lower() or k.get("color") == -1,
324 f"{tag}: player-to-enemy is grey (src={k.get('src')} color={k.get('color')})")
325 if expect_around:
326 inside = [s for s in (k.get("samples") or []) if s.get("inside")]
327 check(len(inside) == 0,
328 f"{tag}: player-to-enemy path stays outside the field "
329 f"({len(inside)} interior samples {inside[:3]})")
330 if "enemy-to-player" in kinds:
331 k = kinds["enemy-to-player"]
332 check(k["endScale"] > k["startScale"],
333 f"{tag}: enemy-to-player grows ({k['startScale']:.2f}→{k['endScale']:.2f})")
334 check(k.get("landCol") == 3,
335 f"{tag}: enemy-to-player landCol is 3 (got {k.get('landCol')})")
336 if k.get("end") and info.get("expectedEndX"):
337 check(abs(k["end"]["x"] - info["expectedEndX"]) < 3,
338 f"{tag}: arc ends at column 3 "
339 f"(end.x={k['end']['x']:.1f} expected={info['expectedEndX']:.1f})")
340 check("gray" in (k.get("src") or "").lower() or k.get("color") == -1,
341 f"{tag}: enemy-to-player is grey (src={k.get('src')} color={k.get('color')})")
342 if expect_around and k.get("samples"):
343 inside = [s for s in k["samples"] if s.get("inside")]
344 check(len(inside) == 0,
345 f"{tag}: enemy-to-player path stays outside the field "
346 f"({len(inside)} interior samples {inside[:3]})")
347 check(not k.get("insideNow"),
348 f"{tag}: enemy-to-player mid-arc is not over the field interior")
349 if "enemy-to-enemy" in kinds:
350 k = kinds["enemy-to-enemy"]
351 check(abs(k["startScale"] - k["endScale"]) < 0.05,
352 f"{tag}: enemy-to-enemy stays small ({k['startScale']:.2f})")
353 check(k["parent"] == "flights-back",
354 f"{tag}: enemy-to-enemy is in #flights-back (got {k['parent']})")
355 if expect_behind:
356 check(info["back"] >= 1, f"{tag}: at least one behind-field flight")
357 check("gray" in (k.get("src") or "").lower() or k.get("color") == -1,
358 f"{tag}: enemy-to-enemy is grey (src={k.get('src')} color={k.get('color')})")
359 if "enemy-miss" in kinds:
360 k = kinds["enemy-miss"]
361 check(k["startScale"] < 0.7,
362 f"{tag}: enemy-miss starts small ({k['startScale']:.2f})")
363 check(k["parent"] == "flights",
364 f"{tag}: enemy-miss is in #flights (got {k['parent']})")
365 check(k.get("color") != -1,
366 f"{tag}: enemy-miss keeps the sender colour (color={k.get('color')})")
367
368
369def run_viewport(browser, url, name, width, height, is_mobile, round_n, expect_mode,
370 expect_one_row=False, expect_rows=False, n_minis=None):
371 context = browser.new_context(
372 viewport={"width": width, "height": height},
373 device_scale_factor=1,
374 is_mobile=is_mobile,
375 has_touch=is_mobile,
376 )
377 page = context.new_page()
378 open_offline(page, url, round_n=round_n)
379 page.wait_for_timeout(300)
380 info = page.evaluate(LAYOUT_INFO)
381 field = info.get("field") or {}
382 print(f"--- {name} layout:", {k: info[k] for k in ('mode', 'n', 'tile', 'vw', 'vh', 'sidesClass')},
383 "fieldY", field.get("y"), "field.top", field.get("top"),
384 "positions", info.get("positions"))
385 if expect_mode == "sides":
386 assert_sides(info, name, expect_rows=expect_rows, expect_one_row=expect_one_row,
387 n=n_minis)
388 else:
389 assert_top(info, name)
390 shot(page, f"t1127-{name}-layout.png")
391
392 flights = page.evaluate(INJECT_FLIGHTS, 0.55)
393 print(f"--- {name} flights:", {k: flights[k] for k in ('front', 'back', 'expectedEndX', 'hudH', 'mode') if k in flights})
394 for knd in flights["kinds"]:
395 print(f" {knd['kind']}: color={knd.get('color')} landCol={knd.get('landCol')} "
396 f"src={knd.get('src')} insideNow={knd.get('insideNow')} "
397 f"end={knd.get('end')} pos={knd.get('pos')}")
398 assert_flights(flights, name)
399 shot(page, f"t1127-{name}-midarc.png")
400
401 if name in ("1024x532-3bots", "1920x1080-8bots", "desktop-wide"):
402 for age, label in ((0.25, "early"), (0.85, "late")):
403 page.evaluate(INJECT_FLIGHTS, age)
404 shot(page, f"t1127-{name}-midarc-{label}.png")
405 context.close()
406
407
408def main():
409 port = free_port()
410 http = start_http(port)
411 url = f"http://127.0.0.1:{port}/"
412 try:
413 with sync_playwright() as p:
414 browser = p.chromium.launch(
415 executable_path=CHROME,
416 args=CHROME_ARGS,
417 headless=True,
418 )
419 # Tim's short wide window, 3 bots (ronde 3)
420 run_viewport(browser, url, "1024x532-3bots", 1024, 532, False, 3, "sides",
421 expect_one_row=True, n_minis=3)
422 # 8 bots: wrap on 1280, one row on 1400 and 1920
423 run_viewport(browser, url, "1280x900-8bots", 1280, 900, False, 25, "sides",
424 expect_rows=True, n_minis=8)
425 run_viewport(browser, url, "1400x900-8bots", 1400, 900, False, 25, "sides",
426 expect_one_row=True, n_minis=8)
427 run_viewport(browser, url, "1920x1080-8bots", 1920, 1080, False, 25, "sides",
428 expect_one_row=True, n_minis=8)
429 browser.close()
430 finally:
431 http.terminate()
432 try:
433 http.wait(timeout=3)
434 except subprocess.TimeoutExpired:
435 http.kill()
436
437 if FAILURES:
438 print(f"\n{len(FAILURES)} failure(s):")
439 for f in FAILURES:
440 print(" -", f)
441 return 1
442 print("\nall minis/flights checks passed")
443 return 0
444
445
446if __name__ == "__main__":
447 sys.exit(main())