"""TSS scoreboard renderer. Generates the match-result image posted by autologging. Mirrors SREBOT's visual language (blurred map background, vignette, two team columns, stat icons) but is TSS-native: team names instead of squadron tags, the full per-player vehicle lineup (unused dimmed) instead of a single vehicle, and per-player pvp_ratio instead of squadron points. Input is the flat model from ``transform.build_scoreboard_model`` — this module never touches the raw feed. """ from __future__ import annotations import asyncio import logging import re from datetime import datetime, timezone from functools import lru_cache from pathlib import Path from typing import Any, Optional import numpy as np from PIL import Image, ImageDraw, ImageFont from PIL.Image import Resampling from . import SHARED_DIR from .wl import get_tss_standings log = logging.getLogger("tssbot.scoreboard") MAPS_DIR = SHARED_DIR / "MAPS" ICON_BASE_DIR = SHARED_DIR / "ICONS" VEHICLE_ICON_DIR = ICON_BASE_DIR / "VEHICLES" TEXT_FONT_PATH = SHARED_DIR / "FONTS" / "arial_unicode_ms.otf" # Colors WIN_FILL = (60, 255, 60, 255) LOSS_FILL = (255, 60, 60, 255) DRAW_FILL = (255, 255, 0, 255) NEUTRAL_FILL = (255, 255, 255, 255) GREY_FILL = (200, 200, 200, 255) NAME_FILL = (250, 227, 200, 255) DIM_FILL = (150, 150, 150, 255) # --------------------------------------------------------------------------- # Asset caching (mirrors SREBOT) # --------------------------------------------------------------------------- _FONTS: dict[str, ImageFont.FreeTypeFont] = {} def load_fonts(base_width: int) -> dict[str, ImageFont.FreeTypeFont]: global _FONTS if _FONTS: return _FONTS _FONTS = { "title": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.04)), "team": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.03)), "sub": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.019)), "body": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.020)), "stat": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.022)), "info": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.016)), "small": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.013)), "veh": ImageFont.truetype(str(TEXT_FONT_PATH), int(base_width * 0.016)), } return _FONTS @lru_cache(maxsize=256) def _load_icon_cached(path_str: str, size: tuple, alpha: int): img = Image.open(path_str).convert("RGBA") if size: img = img.resize(size, Resampling.LANCZOS) if alpha < 255: a = img.getchannel("A").point(lambda v: int(v * alpha / 255)) img.putalpha(a) return img def load_icon(path: Path, size: Optional[tuple] = None, alpha: int = 255) -> Image.Image: return _load_icon_cached(str(path), tuple(size) if size else None, alpha) @lru_cache(maxsize=24) def _load_map_cached(path_str: str, blur_radius: int): from PIL import ImageFilter img = Image.open(path_str).convert("RGBA") return img.filter(ImageFilter.GaussianBlur(blur_radius)) def _make_vignette(width: int, height: int, base_alpha=140, max_alpha=175, power=4) -> Image.Image: """Radial alpha mask that darkens toward the edges (matches SREBOT's vignette). Each axis is normalized independently so the mid-edges — not just the corners — reach ``max_alpha``, giving the whole frame a subtle edge vignette. """ ys = np.linspace(-1, 1, height)[:, None] xs = np.linspace(-1, 1, width)[None, :] dist = np.clip(np.sqrt(xs ** 2 + ys ** 2), 0, 1) band = base_alpha + (max_alpha - base_alpha) * (dist ** power) return Image.fromarray(np.clip(band, 0, 255).astype(np.uint8), mode="L") def _resolve_map_image(map_name: str) -> Optional[str]: """Match a TSS mission_name against SHARED/MAPS. Tries the ``TSS_.png`` variant first, then falls back to the plain ``.jpg``. WT lobby names often arrive as e.g. "Gladiators 1x1 - Kursk" (or 2x2, 3x3, …); the "Gladiators" word and any "NxN" token are stripped so they all collapse down to the real map name ("Kursk"). """ # Drop any leading "[...]" tag. clean = re.sub(r"^\s*\[[^]]+\]\s*", "", map_name) # Strip WT "Gladiators"/"NxN" lobby noise, keeping only the real map name. clean = re.sub(r"(?i)\bgladiators\b", "", clean) clean = re.sub(r"\b\d+\s*[xX]\s*\d+\b", "", clean) # Drop leftover separators (leading/trailing dashes, spaces), then spaces→_. clean = clean.strip(" -").replace(" ", "_") try: candidates = {f.name for f in MAPS_DIR.iterdir() if f.is_file()} except FileNotFoundError: return None for target in (f"TSS_{clean}.png", f"{clean}.jpg"): match = next((fn for fn in candidates if fn.lower() == target.lower()), None) if match: return str(MAPS_DIR / match) return None # --------------------------------------------------------------------------- # Render # --------------------------------------------------------------------------- def _bar_fill(bar_color: str) -> tuple: return {"win": WIN_FILL, "loss": LOSS_FILL, "draw": DRAW_FILL}.get(bar_color, NEUTRAL_FILL) def _strip_platform(name: str) -> str: return name.replace("@live", "").replace("@psn", "").strip() def _create_scoreboard_sync(model: dict[str, Any], output_path: str, bar_color: str) -> None: map_name = model.get("map", "") map_image_path = _resolve_map_image(map_name) if map_image_path: background = _load_map_cached(map_image_path, 2).copy() else: log.warning("[TSS-SB] No map image for %r; using flat background", map_name) # Match the map image resolution (2560x1440) so the fixed 0.5 downscale yields # the same 1280x720 output — otherwise no-bg renders come out smaller and look # blown-up (fonts scale with bg_w) when a viewer upscales them to a common width. background = Image.new("RGBA", (2560, 1440), (25, 28, 32, 255)) bg_w, bg_h = background.size band = _make_vignette(bg_w, bg_h) overlay = Image.new("RGBA", (bg_w, bg_h), (0, 0, 0, 0)) black = Image.new("RGBA", (bg_w, bg_h), (0, 0, 0, 255)) overlay = Image.composite(black, overlay, band) draw = ImageDraw.Draw(overlay) fonts = load_fonts(bg_w) BODY = int(bg_w * 0.020) STAT = int(bg_w * 0.022) # ── Top-right metadata: timestamp + session id padding = 15 ts_epoch = int(model.get("utc_timestamp") or 0) ts_text = datetime.fromtimestamp(ts_epoch, tz=timezone.utc).strftime("%H:%M:%S - %Y-%m-%d UTC") sid_text = model.get("session_id", "") for i, txt in enumerate((ts_text, sid_text)): bbox = draw.textbbox((0, 0), txt, font=fonts["info"]) x = bg_w - (bbox[2] - bbox[0]) - padding - 10 y = padding + 10 + i * ((bbox[3] - bbox[1]) + 20) draw.text((x, y), txt, font=fonts["info"], fill=GREY_FILL) # ── Top-center titles: map name, then tournament · mode y = 50 title = map_name or "Unknown Map" tb = draw.textbbox((0, 0), title, font=fonts["title"]) draw.text(((bg_w - (tb[2] - tb[0])) // 2, y), title, font=fonts["title"], fill=NEUTRAL_FILL) # Gap off the title's full glyph box (not just measured height) so the subtitle # clears descenders instead of clipping into the map name. y += int(bg_w * 0.04) + 28 sub_parts = [p for p in (model.get("tournament_name"), model.get("mission_mode")) if p] if sub_parts: sub = " · ".join(sub_parts) sb = draw.textbbox((0, 0), sub, font=fonts["sub"]) draw.text(((bg_w - (sb[2] - sb[0])) // 2, y), sub, font=fonts["sub"], fill=GREY_FILL) y += (sb[3] - sb[1]) + 10 y_start = y + 150 # ── Layout: two team columns + separator x_start = 55 col_width = (bg_w - x_start * 2) // 2 sep_x = x_start + col_width draw.line([(sep_x, y_start - 60), (sep_x, bg_h - 50)], fill=_bar_fill(bar_color), width=5) teams = model.get("teams", []) is_draw = model.get("is_draw", False) winner = model.get("winner") def draw_team(idx: int, team: dict, start_x: int, section_width: int): flipped = idx == 1 # second team mirrored to the right players = sorted(team.get("players", []), key=lambda p: int(p.get("score") or 0), reverse=True) team_name = team.get("team_name", "Team") if is_draw: header_fill = DRAW_FILL elif winner is not None and team_name == winner: header_fill = WIN_FILL else: header_fill = LOSS_FILL header_y = y_start - 90 nb = draw.textbbox((0, 0), team_name, font=fonts["team"]) name_w = nb[2] - nb[0] name_x = start_x if not flipped else start_x + section_width - name_w draw.text((name_x, header_y), team_name, font=fonts["team"], fill=header_fill) # W/L slot — per-tournament record under the team name. Coloured exactly like # SREBOT: green W · grey dash · red L · grey dash · win-rate% on a red→green # gradient. Placed below the team name's full glyph box (descender-inclusive) # so names with p/g/y descenders don't clip into the record line. standings = get_tss_standings(team.get("team_id"), model.get("tournament_id")) if standings: wl_segs = _winloss_segments(standings) seg_w = _segments_width(draw, wl_segs, fonts["sub"]) wl_x = start_x if not flipped else start_x + section_width - seg_w # Sit halfway between the original (descender-clipping) baseline and a # full descender-clear drop — enough to clear p/g/y, no more. name_full_h = fonts["team"].getbbox("ApgjyQ")[3] wl_y = header_y + ((nb[3] - nb[1] + 18) + (name_full_h + 10)) // 2 _draw_segments(draw, wl_x, wl_y, wl_segs, fonts["sub"]) # Stat columns (rating now lives inline next to the player name). col_labels = ["Air", "Ground", "Assists", "Deaths", "Caps"] icon_map = { "Air": ICON_BASE_DIR / "fighter_icon.png", "Ground": ICON_BASE_DIR / "tank_icon.png", "Assists": ICON_BASE_DIR / "assists_icon.png", "Deaths": ICON_BASE_DIR / "deaths_icon.png", "Caps": ICON_BASE_DIR / "cap_icon.png", } # Column CENTERS — a tight stat block packed against the center separator # (like SRE). Center-anchoring keeps 1- and 4-digit values aligned. Team 2 # mirrors across its own center axis so the board is symmetric. n_cols = len(col_labels) gutter = section_width * 0.035 # small gap off the center separator stat_area = section_width * 0.30 # tight column block right_edge = start_x + section_width - gutter step = stat_area / n_cols centers = [right_edge - stat_area + step * (i + 0.5) for i in range(n_cols)] if flipped: axis = start_x + section_width / 2.0 centers = [2 * axis - c for c in centers] col_center = {lab: int(c) for lab, c in zip(col_labels, centers)} ICON_SIZE = int(STAT * 1.1) head_icon_y = header_y + 72 for label in col_labels: cx = col_center[label] ico = icon_map.get(label) if ico: try: img = load_icon(ico, (ICON_SIZE, ICON_SIZE)) overlay.paste(img, (int(cx - ICON_SIZE // 2), int(head_icon_y)), img) except Exception: pass # Player rows. Layout per row: # top line — player name + inline (rating) at the column edge; stats # lower line — vehicle icons next to their translated names body = fonts["body"] small = fonts["veh"] name_h = body.getbbox("Ag")[3] small_h = small.getbbox("Ag")[3] veh_icon = int(BODY * 1.6) y_off = header_y + ICON_SIZE + 95 for p in players: name = _strip_platform(p.get("fake_nick") or p.get("nick") or "") units = [u for u in p.get("units", []) if u.get("used")] row_h = name_h + 12 + veh_icon + 12 line_y = y_off # player-name line (at the column edge) id_mid = line_y + name_h // 2 veh_y = line_y + name_h + 12 # vehicle line (icons + names together) vname_y = veh_y + (veh_icon - small_h) // 2 name_w = draw.textbbox((0, 0), name, font=body)[2] rating_segs = _rating_segments(p.get("pvp_ratio")) rating_w = _segments_width(draw, rating_segs, body) if not flipped: # name + rating at the left edge draw.text((start_x, line_y), name, font=body, fill=NAME_FILL) _draw_segments(draw, start_x + name_w + 12, line_y, rating_segs, body) # below: each icon directly next to its own vehicle name _draw_vehicle_pairs(overlay, draw, units, start_x, veh_y, vname_y, veh_icon, small, flipped=False) else: # name + rating at the right edge (rating to the left of the name) name_x = start_x + section_width - name_w draw.text((name_x, line_y), name, font=body, fill=NAME_FILL) _draw_segments(draw, name_x - 12 - rating_w, line_y, rating_segs, body) # below: icon+name pairs, the whole group right-aligned to the edge total = _vehicle_pairs_width(draw, units, veh_icon, small) _draw_vehicle_pairs(overlay, draw, units, start_x + section_width - total, veh_y, vname_y, veh_icon, small, flipped=True) # stat values, vertically centered on the identity line stats = [ ("Air", p.get("air_kills", 0)), ("Ground", p.get("ground_kills", 0)), ("Assists", p.get("assists", 0)), ("Deaths", p.get("deaths", 0)), ("Caps", p.get("captures", 0)), ] for label, val in stats: num = int(val) fill = NEUTRAL_FILL if label in ("Air", "Ground") and num > 0: fill = WIN_FILL elif label == "Deaths" and num > 0: fill = (255, 20, 20, 255) elif label == "Caps" and num > 0: fill = DRAW_FILL elif label == "Assists" and num > 0: fill = (230, 150, 90, 255) draw.text((col_center[label], id_mid), str(num), font=fonts["stat"], fill=fill, anchor="mm") y_off += row_h + 14 draw_team(0, teams[0], x_start + 10, col_width) draw_team(1, teams[1], x_start + col_width, col_width) # ── Composite + downsample final = Image.alpha_composite(background, overlay) scale = 0.5 final = final.resize((int(bg_w * scale), int(bg_h * scale)), resample=Resampling.LANCZOS).convert("RGB") final.save(output_path, format="PNG", compress_level=1) RATING_FILL = (170, 200, 255, 255) # W/L record colours — matched exactly to SREBOT's scoreboard. WL_WIN_FILL = (0, 255, 0, 255) WL_LOSS_FILL = (255, 60, 60, 255) WL_DASH_FILL = (200, 200, 200, 255) def _winrate_gradient(win_rate: float) -> tuple: """Red→yellow→green gradient for a win-rate percentage (SREBOT's get_gradient_color). 0% = red (255,0,0), 50% = yellow (255,255,0), 100% = green (0,255,0). """ win_rate = max(0.0, min(100.0, win_rate)) if win_rate <= 50: return (255, int(255 * (win_rate / 50)), 0, 255) return (int(255 * (1 - (win_rate - 50) / 50)), 255, 0, 255) def _winloss_segments(standings: dict[str, int]) -> list[tuple[str, tuple]]: """Colored ``3W - 2L - 60%`` segments for the per-tournament record line. Win count + 'W' green, ' - ' grey, loss count + 'L' red, ' - ' grey, then the win-rate% on the red→green gradient — mirroring SREBOT's _draw_winloss. """ wins = int(standings.get("wins") or 0) losses = int(standings.get("losses") or 0) total = wins + losses pct = (wins / total) * 100 if total else 0.0 return [ (f"{wins}W", WL_WIN_FILL), (" - ", WL_DASH_FILL), (f"{losses}L", WL_LOSS_FILL), (" - ", WL_DASH_FILL), (f"{pct:.0f}%", _winrate_gradient(pct)), ] def _rating_segments(rating): """Build colored (text, fill) segments for the inline ``(1468)`` rating.""" rating_str = f"{int(round(rating))}" if isinstance(rating, (int, float)) else "—" return [(f"({rating_str})", RATING_FILL)] def _segments_width(draw, segs, font): return sum(draw.textbbox((0, 0), s, font=font)[2] for s, _ in segs) def _draw_segments(draw, x, y, segs, font): for s, c in segs: draw.text((x, y), s, font=font, fill=c) x += draw.textbbox((0, 0), s, font=font)[2] return x _DEAD_LINE_COLOR = (220, 30, 30, 235) def _paste_vehicle(overlay, unit, xy, size): """Paste a vehicle icon (unused ones dimmed), falling back to not_found.""" alpha = 255 if unit["used"] else 90 for path in (VEHICLE_ICON_DIR / f"{unit['internal'].lower()}.png", ICON_BASE_DIR / "not_found.png"): try: img = load_icon(path, (size, size), alpha=alpha) overlay.paste(img, (int(xy[0]), int(xy[1])), img) return except Exception: continue _VEH_PAIR_GAP = 22 def _vehicle_pairs_width(draw, units, size, font): """Total pixel width of the icon+name pairs (for right-aligning team 2).""" w = 0 for u in units: w += size + 4 + draw.textbbox((0, 0), u["name"], font=font)[2] + _VEH_PAIR_GAP return max(0, w - _VEH_PAIR_GAP) def _draw_vehicle_pairs(overlay, draw, units, x, veh_y, vname_y, size, font, flipped=False): """Draw each vehicle as an icon immediately followed by its translated name. Destroyed vehicles get a red diagonal line struck through their name: top-left to bottom-right for the left team, mirrored (top-right to bottom-left) for the right. """ x = int(x) for u in units: _paste_vehicle(overlay, u, (x, veh_y), size) x += size + 4 draw.text((x, vname_y), u["name"], font=font, fill=NEUTRAL_FILL) bbox = draw.textbbox((x, vname_y), u["name"], font=font) if u.get("dead"): x0, y0, x1, y1 = bbox line = (x0, y1, x1, y0) if flipped else (x0, y0, x1, y1) draw.line(line, fill=_DEAD_LINE_COLOR, width=max(2, font.size // 9)) x = bbox[2] + _VEH_PAIR_GAP return x async def create_scoreboard(model: dict[str, Any], output_path: str, bar_color: str = "") -> None: """Render the TSS scoreboard for a game model and write it to ``output_path``.""" await asyncio.to_thread(_create_scoreboard_sync, model, output_path, bar_color)