SRETSS/TSSBOT
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add tss map images and update scoreboard again (#1331)

Browse Source
This commit is contained in:
NotSoToothless
2026-06-17 18:40:19 -07:00
committed by GitHub
parent c5b74de367
commit 53e3db9159
2 changed files with 72 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
BOT/scoreboard.py
+48 -12
View File
@@ -90,23 +90,44 @@ def _load_map_cached(path_str: str, blur_radius: int):
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.sqrt(xs ** 2 + ys ** 2) / np.sqrt(2)
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 (spaces→_, .jpg), like SRE."""
clean = re.sub(r"^\s*\[[^]]+\]\s*", "", map_name).replace(" ", "_")
target = f"{clean}.jpg"
"""Match a TSS mission_name against SHARED/MAPS.
Tries the ``TSS_<Map>.png`` variant first, then falls back to the plain
``<Map>.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
match = next((fn for fn in candidates if fn.lower() == target.lower()), None)
return str(MAPS_DIR / match) if match else 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
# ---------------------------------------------------------------------------
@@ -129,7 +150,10 @@ def _create_scoreboard_sync(model: dict[str, Any], output_path: str, bar_color:
background = _load_map_cached(map_image_path, 2).copy()
else:
log.warning("[TSS-SB] No map image for %r; using flat background", map_name)
background = Image.new("RGBA", (1920, 1080), (25, 28, 32, 255))
# 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
@@ -271,7 +295,7 @@ def _create_scoreboard_sync(model: dict[str, Any], output_path: str, bar_color:
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)
_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
@@ -280,7 +304,7 @@ def _create_scoreboard_sync(model: dict[str, Any], output_path: str, bar_color:
# 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)
veh_y, vname_y, veh_icon, small, flipped=True)
# stat values, vertically centered on the identity line
stats = [
@@ -342,6 +366,9 @@ def _draw_segments(draw, x, y, segs, font):
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
@@ -365,14 +392,23 @@ def _vehicle_pairs_width(draw, units, size, font):
return max(0, w - _VEH_PAIR_GAP)
def _draw_vehicle_pairs(overlay, draw, units, x, veh_y, vname_y, size, font):
"""Draw each vehicle as an icon immediately followed by its translated name."""
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)
x += draw.textbbox((0, 0), u["name"], font=font)[2] + _VEH_PAIR_GAP
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
BOT/transform.py
+24 -3
View File
@@ -52,21 +52,41 @@ def _translator(lang_column: str):
return _t
def _build_units(units: list[dict[str, Any]], translate) -> list[dict[str, Any]]:
"""Normalize a player's lineup: icon key (internal), translated name, used flag."""
def _build_units(units: list[dict[str, Any]], translate, dead: set[str] | None = None) -> list[dict[str, Any]]:
"""Normalize a player's lineup: icon key (internal), translated name, used/dead flags.
Prefer an explicit per-unit ``dead``/``died`` flag if Spectra provides one; otherwise
fall back to the ``dead`` set cross-referenced from ``events.kills`` (see ``_dead_units_by_uid``).
"""
dead = dead or set()
out: list[dict[str, Any]] = []
for u in units or []:
internal = str(u.get("unit") or "").strip()
if not internal:
continue
flag = u.get("dead", u.get("died"))
is_dead = bool(flag) if flag is not None else internal in dead
out.append({
"internal": internal,
"name": translate(internal) or u.get("unit_normalized") or internal,
"used": bool(u.get("used")),
"dead": is_dead,
})
return out
def _dead_units_by_uid(game: dict[str, Any]) -> dict[str, set[str]]:
"""Map uid -> set of internal unit names that died (were destroyed in a kill event)."""
out: dict[str, set[str]] = {}
kills = ((game.get("events") or {}).get("kills")) or []
for k in kills:
uid = str(k.get("offended_uid") or "")
unit = str(k.get("offended_unit") or "").strip()
if uid and unit:
out.setdefault(uid, set()).add(unit)
return out
def _pvp_index(tss: dict[str, Any]) -> dict[str, dict[str, Any]]:
"""Map uid -> {pvp_ratio, role} from the tss per-team roster blocks."""
idx: dict[str, dict[str, Any]] = {}
@@ -96,6 +116,7 @@ def build_scoreboard_model(game: dict[str, Any], lang_column: str = "<English>")
translate = _translator(lang_column)
pvp = _pvp_index(tss)
dead_units = _dead_units_by_uid(game)
teams: dict[str, dict[str, Any]] = {}
for slot in ("1", "2"):
@@ -130,7 +151,7 @@ def build_scoreboard_model(game: dict[str, Any], lang_column: str = "<English>")
"score": int(p.get("score") or 0),
"pvp_ratio": info.get("pvp_ratio"),
"role": info.get("role"),
"units": _build_units(p.get("units") or [], translate),
"units": _build_units(p.get("units") or [], translate, dead_units.get(str(uid))),
})
if not teams["1"]["players"] or not teams["2"]["players"]: