#!/usr/bin/env python3 # -*- coding: utf-8 -*- """Club items: balls, stadia, badges, kits and league logos. Built from the game's OWN tables, dumped read-only into data/tables/ by db_dump.py: fcc_balls 42 rows carddbid 8120194+ cardassetid 37 fcc_stadium 78 rows carddbid 6200000+ cardassetid 36 fcc_badgecards 656 rows carddbid 6000000+ cardassetid 39 fcc_kitcards 1482 rows carddbid 6300000+ cardassetid 35 fcc_leaguelogos 44 rows carddbid 8010000+ cardassetid 40 TWO ID COLUMNS, AND THEY ARE NOT INTERCHANGEABLE. Every fcc_ row carries BOTH carddbid and cardassetid. carddbid is the database key the merge would use; cardassetid is the ART id the card draws from. fut_store._item copies resourceId into cardassetid, which is right for players and wrong for every other family -- that is exactly what produced the green "NOT FOUND" placeholder on consumables (external/ion_fut/artAssets/.../notfound.swf) until it was fixed on 2026-08-05. So this module sets both explicitly and never lets one default to the other. WHAT IS NOT KNOWN YET, AND IS NOT GUESSED HERE ---------------------------------------------- cardtype 9 (the club-item family) has NO arm in the merge FUN_180141660: no table query and no miss-fill. So unlike a player or a coach, a club item's identity does NOT come from the local card DB, and a wrong id cannot announce itself. The cardsubtypeid values that reach cardtype 9 are the eight-value set {30, 31, 145, 146, 147, 148, 149, 150}, and WHICH of those means ball versus stadium versus badge is assigned nowhere in the 149 dumped tables. Rather than guess, SUBTYPE is a per-family constant below with an explicit "unverified" marker, and probe_shelf() serves one item per candidate subtype so the screen itself can say which is which. The counts do not need any of this: a count is just a number, which is why counts come first. THE COUNT IS THE GATE. Proven on consumables the same day: the client does not ask for an item list until club/stats reports a non-zero count for that family. The CLUB tab reads global stat ids 1 (players), 0x1e (balls), 0x28 (kits), 0x14 (stadia), 0x0a (staff) and 0x32 (trophies), so making those non-zero is what makes the client reveal the item route it uses. Nothing here should be believed to work until that route is observed in the log. """ import json import os _DATA = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "data", "tables") CLUBITEM_ID_BASE = 960000000 # distinct from save 1e8, sweep 9e8, consumables 9.4e8 # (table, art id, stat id, stat name, UNVERIFIED cardsubtypeid) FAMILIES = [ ("balls", "fcc_balls.json", 37, 0x1E, "balls", 149), ("stadia", "fcc_stadium.json", 36, 0x14, "stadia", 148), ("badges", "fcc_badgecards.json", 39, 0x2E, "badgeDBid", 145), ("kits", "fcc_kitcards.json", 35, 0x28, "kits", 146), ("leaguelogos", "fcc_leaguelogos.json", 40, 0x2F, "leagueLogos", 150), ] # Every cardsubtypeid known to reach cardtype 9. Used by probe_shelf(). CARDTYPE9_SUBTYPES = (30, 31, 145, 146, 147, 148, 149, 150) # How many of each family the starter club owns. Small on purpose: the point is to # make the counter non-zero so the client asks, not to hand anyone a collection. STARTER_N = {"balls": 6, "stadia": 4, "badges": 8, "kits": 8, "leaguelogos": 4} def _rows(fname): try: with open(os.path.join(_DATA, fname)) as f: return json.load(f).get("rows") or [] except (IOError, ValueError): return [] def _item(item_id, carddbid, cardassetid, subtype, extra=None): """One club item. Deliberately narrow: no rating, no position, no attributes, no nation, no league, no team. A club item has none of those, and sending a field the family does not have is how a wrong shape gets accepted and does nothing.""" it = { "id": item_id, "resourceId": carddbid, "assetId": carddbid, "cardassetid": cardassetid, # THE ART ID, never a copy of resourceId "cardsubtypeid": subtype, "itemType": "club", # UNOBSERVED on the wire; see module docstring "itemState": "free", "owners": 1, "untradeable": False, } if extra: it.update(extra) return it def shelf(next_id=CLUBITEM_ID_BASE): """The starter club-item shelf, {family: [item]}.""" out, nid = {}, next_id for name, table, art, _sid, _sname, subtype in FAMILIES: rows = _rows(table) picked = [] for r in rows[:STARTER_N.get(name, 4)]: cid = r.get("carddbid") if not cid: continue extra = {} for k in ("teamid", "leagueid", "value"): if r.get(k): extra[k] = r[k] picked.append(_item(nid, cid, r.get("cardassetid", art), subtype, extra)) nid += 1 out[name] = picked return out def counts(next_id=CLUBITEM_ID_BASE): """[(stat name, count)] for the club panel.""" s = shelf(next_id) return [(sname, len(s.get(name, []))) for name, _t, _a, _sid, sname, _st in FAMILIES] def probe_shelf(family, next_id=CLUBITEM_ID_BASE): """One item per CANDIDATE cardsubtypeid, same carddbid, for the live oracle. Which of {30,31,145..150} means which family is unknown and unguessable from the dumped tables. Serving all eight and looking at the screen is the cheapest way to find out, and unlike a sweep it is READABLE: the family that draws real artwork names its own subtype. """ entry = next((f for f in FAMILIES if f[0] == family), None) if entry is None: return [] _n, table, art, _sid, _sname, _st = entry rows = _rows(table) if not rows: return [] r = rows[0] return [_item(next_id + i, r.get("carddbid"), r.get("cardassetid", art), st) for i, st in enumerate(CARDTYPE9_SUBTYPES)] if __name__ == "__main__": s = shelf() for name, items in s.items(): print("%-12s %2d item(s)" % (name, len(items))) if items: i = items[0] print(" resourceId=%-9s cardassetid=%-4s subtype=%s" % (i["resourceId"], i["cardassetid"], i["cardsubtypeid"])) print("\ncounts:", counts())