# Legacy CS 1.3: validation findings URL: https://www.papamo.dev/docs/cosmetics/legacy-cs13 Windows verification of music, baked stickers and HUD assets, plus Legacy 1.3 matchmaking rules. Verified November 9, 2026 against an isolated Windows 11 VM and a native protocol-45 CS 1.3 server. ## Actual Legacy 1.3 [#actual-legacy-13] Legacy 1.3 runs the real CS 1.3 game. The discontinued CS 1.6 legacy emulation queues are retired. Their manual bunny-hop and weapon rules remain available through the default-off **Legacy Mode** checkbox in CS 1.6 custom games, with a help tooltip. There is one Legacy 1.3 queue. Match Found requires at least two humans. Accepted players enter warmup; all connected non-AFK humans can vote `/startearly`. Automatic start keeps the existing seven-minute threshold halving, with a two-human floor: off-peak 3 → 2, peak 6 → 3 → 2. The separate 1v1 queue is removed. Warmup selects the final size from its active population: | Humans | Match | Bots | Regulation | | --- | --- | --- | --- | | 2 | 1v1 | 0 | MR8 | | 3–4 | 2v2 | 1 / 0 | MR8 | | 5–6 | 3v3 | 1 / 0 | MR12 | | 7–8 | 4v4 | 1 / 0 | MR12 | | 9–10 | 5v5 | 1 / 0 | MR12 | For odd populations, the bot accompanies a highest-MMR human. Parties remain together; if a party cannot fit the current size, warmup waits for more humans. The backend commits the roster, and the game server rejects stale acknowledgements. AFK players do not block the vote. ## Music: measured Windows playback [#music-measured-windows-playback] The test client reported Half-Life 1.0.1.4, protocol 45, hardware build 2006. It used Mesa llvmpipe inside the VM; this was a compatibility test, not a performance benchmark. The authenticated player selected the expected music kit. A disposable controller invoked the existing first-blood and MVP playback functions. VM-only audio captures matched their source WAVs: | Clip | Normalized correlation | | --- | --- | | Quake first blood | 0.997 | | Quake MVP | 0.998 | | Complete 24.059-second custom MVP | 0.99734 | The long clip was mono 16-bit PCM at 22050 Hz and played after a map reload. The test also exercised a bot music pool entry. The custom-game startup failure was caused by treating `BOT_MUSIC_0` as a human authentication token; those identifiers now remain separate. These results verify kit selection and server-delivered WAV playback. They do not cover actual kill/award event triggering in the Windows test, MP3, every audio format, or the complete purchase/equip/download interface. ## Stickers: ordinary precached models [#stickers-ordinary-precached-models] CS 1.3 uses the backend-authorized sticker recipe to bake a GoldSrc v10 first-person model before freezing the match loadout. It uses ordinary engine model loading and precache, without adding a native sticker hook. The baker verifies model and artwork hashes, bounds its worker queue and execution time, and writes an immutable model. Regions obtain its full SHA-256 through the trusted asset manifest. Generated paths stay below the old engine's 64-character path limit. Failed optional bakes retain the ordinary weapon skin. Stock held and dropped models stay native to CS 1.3. Custom skins retain their existing held/dropped companions. Stickers affect first-person appearance; they do not grant ownership to another account. A visibly distinct magenta/cyan test sticker rendered on an AK-47 in the Windows client. CS 1.3 uses indexed palette textures, so its sticker fidelity differs from CS 1.6's high-resolution native overlays. The result does not establish compatibility with every weapon, custom model, graphics driver or resource-table load. ## Broken HUD icons: cause and fix [#broken-hud-icons-cause-and-fix] The initial VM fixture omitted `sprites/hud.txt` and the weapon sprite definitions. The engine displayed incorrect sprite regions for health, ammo and radar. The sprite image hashes matched the native CS 1.3 distribution; adding the matching definition files fixed the HUD after restart. The launcher already preserves these `.txt` resources when preparing its match folder. A regression check now explicitly covers `hud.txt` and `weapon_ak47.txt`. This was incomplete test-fixture data, not a sticker texture failure. Player configuration was not accessed or modified by the tooling. ## Crosshair and Tab scoreboard [#crosshair-and-tab-scoreboard] The stock crosshair is visible on the tested AGC client, and holding Tab opens its native scoreboard. The same incomplete fixture also lacked `titles.txt` and the Valve VGUI text schemes; these resources belong to the original installation and are separate from the HUD sprite definitions. Restoring them fixed the scoreboard labels and column alignment; names, teams, score, deaths and latency rendered correctly. The custom crosshair and scoreboard module has a stricter legacy compatibility gate. It recognizes the inspected WON executable SHA-256 `525c1a32a520bbde8857e8dc3ed1e5bbc8b2ef5620bc6cdbcdbc72c34542bace`. The tested AGC executable is `b5f34ed4726d93a9c3d4b3d3eb60df5680f5ae888710f5461e54a462e1efd487`, so it keeps the stock HUD. Prior Wine rendering tests on the approved WON build do not establish native Windows support for this AGC executable. This release does not broaden that native-module compatibility gate. ![Native CS 1.3 scoreboard after restoring its text resources](/docs/legacy-cs13-scoreboard.png) ## Other fixes in this release [#other-fixes-in-this-release] Custom-room settings no longer depend on the matchmaking WebSocket being connected. Existing map/mode selections remain saveable while the catalog is unavailable. Save operations show pending and completion feedback, and Legacy Mode has an explanatory tooltip. Sessions authenticated through partner login hide the username and password changers in Settings. Ordinary account login remains available as before. ## Verification boundaries [#verification-boundaries] Native server tests cover warmup votes, automatic thresholds, AFK exclusion, stale roster acknowledgements, bot retirement and round limits for 2, 3, 5 and 10 humans. Separate tests cover invalid recipes, corrupt artwork, immutable output hashes, native companion preservation and authenticated bake requests. Windows observations are evidence for the specific host above, not a claim of universal GoldSrc compatibility or anti-cheat approval. # Runtime V/P/W models URL: https://www.papamo.dev/docs/cosmetics/runtime-viewmodels Load local first-person, held and dropped cosmetic models without consuming server precache slots. ## The opportunity [#the-opportunity] GoldSrc's traditional model table has a finite server precache budget, commonly 512 model entries. A managed client can load a cosmetic model through its native model loader and substitute it locally in first-person (`v_`), held/player (`p_`) and dropped/world (`w_`) draw paths without adding that model to the server's precache table. This can let a managed client display a much larger cosmetic collection over time. It does **not** expand the server's model table or remove every GoldSrc resource limit. ## What has been demonstrated? [#what-has-been-demonstrated] Native Linux x86 GoldSrc build 10211 has recorded runtime tests for all three draw paths: | Draw path | Observed result | | --- | --- | | `v_` first-person | Custom knife loaded after map start, switched off/on; server model index remained 191 | | `p_` held/player | Custom knife replaced a bot's held knife, switched off/on; server weapon model index remained 131 | | `w_` dropped/world | Custom dropped Deagle model switched off/on; server model index remained 94 | The P/W tests used debug controls in private sessions. They demonstrate local runtime substitution after map load, not a completed production pipeline for every weapon, host or late-joining player. The recorded Windows test also demonstrated an unprecached first-person knife. Windows P/W, NextClient P/W, dynamic player/item mapping, drop/pickup continuity and map transitions need their own runtime validation. ## Approved delivery flow [#approved-delivery-flow] 1. The backend decides the player's entitlement and required cosmetic recipe. 2. The launcher fetches its approved manifest and immutable assets. 3. Paths are constrained to approved roots and SHA-256 hashes are verified. 4. The native worker prepares the authorized catalog for the session. 5. The server selects a recipe already in that catalog. 6. The native draw path validates session, endpoint, source model and sequence before substituting local presentation. 7. Missing/unknown/expired selections retain the normal model. The server's entity model index stays authoritative. A cosmetic selector never submits results, grants ownership or changes gameplay rules. ## AMXX recipe interface [#amxx-recipe-interface] Download [papamo_cosmetics.inc](/downloads/papamo_cosmetics.inc). ```c #include // In plugin_init: papamo_cosmetics_init(); // Once your platform has authorized/staged this exact recipe: papamo_cosmetics_select(id, verifiedRecipeId); // Return to normal presentation: papamo_cosmetics_select(id, ""); ``` `verifiedRecipeId` is a 32-character lowercase hexadecimal recipe ID, not a model path, skin UUID, signing key or arbitrary hash of your choosing. It must match a recipe already staged by the approved launcher pipeline for this player/session and source weapon. The existing `16CSticker` protocol is used for these verified recipes. Refresh selection every 250ms while applicable; native selection expires after 750ms. `papamo_cosmetics_available(id)` reports recent capability only. Unknown recipes fail closed even if the server sends them. Avoid multiple plugins writing this selector for one player. The `.inc` selector does not create a partner entitlement API or authorize new recipe manifests. A platform needs an approved backend/launcher integration before using its own assets. Source delivery and signing remain separately controlled. ## What still needs server precache? [#what-still-needs-server-precache] The server's own entity models and ordinary stock/web client paths still use models supported and precached by the active map/server. Managed viewers can render local `v_`, `p_` and `w_` replacements when they have the verified assets and correct player/weapon/entity mapping. Every viewer needs that integration to see the same cosmetic; a local replacement does not change the server model table or transmit an appearance to other clients. Keep a stock fallback. The client still has memory, model-format, texture-size and rendering budgets. Load approved content in bounded amounts, reuse cached assets and validate on low-end hardware. # Papamo developer docs URL: https://www.papamo.dev/docs Build server integrations and animated HUDs for classic Counter-Strike. Papamo's integration guides cover **PAPAMOVGUI2**, the animated VGUI2 HUD framework, and the managed cosmetic pipeline used by 1.6 Competitive. Start with the [setup guide](/docs/setup) and [PAPAMOVGUI2](/docs/papamovgui2), then follow the [AMXX quickstart](/docs/papamovgui2/quickstart). For cosmetic delivery, read [runtime V/P/W models](/docs/cosmetics/runtime-viewmodels). ## What is available? [#what-is-available] | Integration | Status | | --- | --- | | VGUI2 scoreboard foundation | Native Linux and isolated Windows client smoke tests are documented | | PAPAMOVGUI2 animated cards, customizable scoreboard and AMXX transport | Implemented in source; coordinated signed release and in-game animation validation pending | | Verified cosmetic recipe selector | Existing native protocol; public AMXX wrapper added in source | | Runtime loading beyond server precache | V/P/W substitution demonstrated on Linux; broader production delivery remains under validation | These guides describe an integration contract. They do not mean the installed production helper already contains the new framework. See [compatibility and releases](/docs/papamovgui2/compatibility). ## Choose an integration [#choose-an-integration] - **AMXX server owners:** use the `.inc` functions to send small display snapshots to compatible managed clients. - **Platform developers:** integrate the approved helper, session authorization and verified asset pipeline before exposing server-controlled HUD components. - **Client developers:** prepare immutable assets on a worker and animate cached geometry through VGUI2. See [architecture](/docs/papamovgui2/architecture). ## Access and distribution [#access-and-distribution] PAPAMOVGUI2 is a Papamo framework built on GoldSrc's VGUI2 interfaces. It is not Valve software. The native helper is maintained privately; these docs do not grant access to its source, authorize redistribution or change existing project licenses. Contact Papamo through the [1.6 Competitive project](https://www.papamo.dev/16competitive) for platform access and distribution terms. ## LLM-friendly exports [#llm-friendly-exports] Use [/llms.txt](/llms.txt) for the page index, [/llms-full.txt](/llms-full.txt) for all documentation, or append `.md` to a page URL. The docs home is [/docs/index.md](/docs/index.md). Every page also offers Markdown copy/view controls. These are public documentation exports; internal features are excluded. # AMXX API reference URL: https://www.papamo.dev/docs/papamovgui2/api Typed .inc interfaces, validated limits and transport behavior. ## Downloads [#downloads] - [papamovgui2.inc](/downloads/papamovgui2.inc): animated card presentation. - [papamovgui2_scoreboard.inc](/downloads/papamovgui2_scoreboard.inc): [custom native scoreboards](/docs/papamovgui2/scoreboard). - [papamo_cosmetics.inc](/downloads/papamo_cosmetics.inc): selection of staged, verified cosmetic recipes. Include files use AMXX stocks and Fakemeta; no additional AMXX binary module is required. They still require the matching native client implementation. The cosmetic selector's prerequisites are described in [runtime viewmodels](/docs/cosmetics/runtime-viewmodels). ## papamovgui2_init [#papamovgui2_init] ```c papamovgui2_init(); ``` Call once from `plugin_init`. Registers the fixed `16CVGUI` user message and the versioned client capability command. ## papamovgui2_available [#papamovgui2_available] ```c bool:papamovgui2_available(id); ``` Returns true for a connected player slot with a matching current connection user ID and a handshake less than four seconds old. The native client renews its handshake about every two seconds while authorized. ## papamovgui2_kill_cards [#papamovgui2_kill_cards] ```c bool:papamovgui2_kill_cards(id, count, bool:ct = false, bool:ffa = false, ace = 0, grenadeMask = 0, seconds = 3); ``` | Argument | Meaning | | --- | --- | | `id` | Connected player slot, 1–32 | | `count` | 0–5 competitive cards or 0–16 FFA cards | | `ct` | Blue card palette; false uses the gold palette | | `ffa` | Enables the larger card stack | | `ace` | 0 for none, otherwise a card position 1–5, no greater than count; competitive only | | `grenadeMask` | Unsigned 16-bit mask; bit 0 describes card 1. Bits above count must be zero | | `seconds` | Snapshot lifetime, 1–10 seconds; defaults to 3 | Returns false for invalid arguments or unavailable clients. True means a snapshot was queued, not that it was painted. Refresh snapshots before their lifetime expires. Repeating an identical snapshot renews visibility without restarting the animation. ## papamovgui2_reset [#papamovgui2_reset] ```c bool:papamovgui2_reset(id); ``` Advances the connection's animation epoch and sends a zero-card snapshot. Use for round/life resets. The 16-bit epoch wraps; it identifies transitions, not global ordering or authority. ## Wire format [#wire-format] `16CVGUI` v1 is exactly ten bytes, in this order: | Offset | Size | Value | | --- | --- | --- | | 0 | 1 | Version: 1 | | 1 | 1 | Component: 1, kill cards | | 2 | 2 | Little-endian epoch | | 4 | 1 | Card count | | 5 | 1 | Flags: bit 0 FFA, bit 1 CT | | 6 | 1 | Ace position | | 7 | 2 | Little-endian grenade mask | | 9 | 1 | Lifetime in seconds | Unknown versions/components/flags, malformed lengths and out-of-range values are rejected. Messages carry no paths, scripts, account tokens or download URLs. Platform matches use their authenticated scoreboard state; partner snapshots are enabled only by the managed partner-session path. # Architecture and animation URL: https://www.papamo.dev/docs/papamovgui2/architecture Worker preparation, cached textures and frame-independent animation. ## Rendering path [#rendering-path] ```text Authenticated platform feed / opted-in assigned partner server | validated state | bounded worker preparation | immutable scene + cached texture atlas | PAPAMOVGUI2 timeline and VGUI2 panel ``` The native implementation lives in the private helper's `papamovgui2` module. Its reusable pieces are monotonic animation progress, cubic easing, interpolation, 2D transforms and a shared VGUI2 panel backend. The scoreboard and kill cards share the backend. ## Animation behavior [#animation-behavior] Card entrances and fan reflow use a 280ms transition. Removals fade over 240ms. Kill glow lasts 900ms, and the ace flourish lasts 1.1 seconds. Rapid updates sample the current pose before retargeting so existing cards do not jump back to their initial positions. Artwork, fonts and text shaping are prepared on a worker. A bounded 1024×1024 RGBA atlas is reused between state changes. Hidden components do not paint. Paint callbacks emit bounded textured geometry without file reads, PNG decoding, text rasterization or per-frame vector allocation. The framework targets low-end CPUs and integrated GPUs. These design choices are not measured FPS guarantees. Compare disabled/enabled gameplay frame times, slowest frames and repeated rapid-kill sequences before shipping a new client build. ## State sources [#state-sources] Platform cards derive from the authenticated scoreboard feed. Existing local `DeathMsg` observations can start provisional cards; the server feed confirms them, and unconfirmed progress expires after 1.5 seconds. A local baseline is established before showing progress, so joining mid-match does not replay old kills. Partner cards use the explicitly enabled `16CVGUI` transport. A short-lived snapshot is scoped to the assigned endpoint and live managed session. A partner cannot replace the platform's authoritative score feed with cosmetic card messages. ## Lifecycle [#lifecycle] CS 1.6 Windows/NextClient module installation is persistent in the new source path. Session exit stops workers and removes session tickets, heartbeats, feed data and temporary credentials. It does not automatically restore original DLLs or delete the installed module. Verified original backups and installation journals remain available for explicit maintenance. Linux's managed preload is process-scoped. Missing ownership, expired data, a disabled setting or a different server hides the component. A persistent module stays inactive outside its authorized session and does not force the ordinary game to restart. No component may read or modify the player's `config.cfg`. Persistence and feature disablement do not establish compatibility with VAC or another anti-cheat. # Compatibility and releases URL: https://www.papamo.dev/docs/papamovgui2/compatibility Know which parts are source-ready and which require a matching release. ## Runtime requirements [#runtime-requirements] PAPAMOVGUI2 currently targets 32-bit GoldSrc CS 1.6 with the required VGUI2 interfaces. The private module has separate Linux and Windows ABI handling. NextClient requires its compatible host bridge, including the fixed command/message allowlists. | Client | Behavior | | --- | --- | | Approved managed Linux CS 1.6 | Native VGUI2 path, subject to the packaged module's capabilities | | Approved managed Windows CS 1.6 | Verified persistent proxy, with the updated module | | Approved managed NextClient | Compatible host and native module must ship together | | Stock client without the helper | No PAPAMOVGUI2 messages sent without opt-in; ordinary UI remains | | Web client | No native VGUI2; use ordinary server-supported features | | CS 1.3 / CS 1.5 | Not covered by the PAPAMOVGUI2 v1 interface | ## Release status [#release-status] The animated component, customizable partner scoreboard and public `.inc` transport are new source work. The existing production helper may lack them. The `papamovgui2_v1` module capability identifies framework support; `papamovgui2_scoreboard_v1` identifies the customizable board receiver; `papamo_persistent_session_v1` identifies the persistent-session lifecycle. Capability markers do not replace signed manifests, exact hash verification or registry approval. A release must coordinate the launcher/session helper, native module, NextClient host where applicable, and server plugin. Do not install an arbitrary DLL from these docs or bypass verification to enable a feature. ## Validation before deployment [#validation-before-deployment] For the November 2026 legacy Windows investigation, see [Legacy GoldClient: HUD and crash diagnosis](/docs/papamovgui2/legacy-goldclient). It records the exact hashes, VGUI ABI differences, white-row blending failure, shutdown crash and verified limits. Use isolated installations and test Linux and Windows, including NextClient where offered: rapid kills, ace/reset/death, stale feeds, expired partner snapshots, resolution changes, reconnects, another endpoint, repeated sessions and normal shutdown. Confirm that unknown local DLL changes are preserved during updates. Measure actual game frame times; a successful build or offline preview does not establish runtime smoothness. Do not run 1.6 Competitive alongside another client-side anti-cheat. Close the managed game and launcher before switching clients. No third-party anti-cheat compatibility is claimed. # PAPAMOVGUI2 URL: https://www.papamo.dev/docs/papamovgui2 A VGUI2 framework for animated Counter-Strike 1.6 HUD components. PAPAMOVGUI2 draws inside the game using `VGUI_ivgui006`, `VGUI_Panel007` and `VGUI_Surface026`. It combines reusable animation primitives, worker-prepared artwork and a bounded native panel backend. Its first animated component is the **kill-spree card fan**: rotating card entrances, animated reflow, fades, glow beams, pulse bars, impact rays and an ace flourish. ![Offline PAPAMOVGUI2 card animation samples in blue and gold palettes](/images/docs/papamovgui2-kill-cards.png) *Offline keyframes emitted by the native renderer test, not an in-game screenshot or performance measurement.* ## Why VGUI2? [#why-vgui2] The old card pipeline rendered Canvas in Electron, encoded PNGs, wrote them to disk, decoded them in the native module and uploaded textures. PAPAMOVGUI2 sends state changes and draws cached textured geometry instead. Assets and text are prepared off the game thread. A monotonic timeline computes movement at the game's own paint cadence. Faster animation does not require faster server messages. This architecture removes the per-animation-frame image-transfer pipeline. Actual FPS and frame-time improvements must be measured in game, especially on low-end integrated graphics. ## Start here [#start-here] 1. Check [compatibility](/docs/papamovgui2/compatibility). 2. Download the [AMXX includes](/docs/papamovgui2/api). 3. Run the [quickstart](/docs/papamovgui2/quickstart) on an isolated test server with an approved managed client. 4. Integrate your own server's confirmed events and state. PAPAMOVGUI2 is display-only. Your server or platform retains responsibility for scores, match rules, ownership and enforcement. ## Customize your scoreboard [#customize-your-scoreboard] Use the [scoreboard interface](/docs/papamovgui2/scoreboard) to define columns, team labels/scores, colors, fonts and per-viewer statistics from your AMXX plugin. The [setup guide](/docs/setup) includes installation, compilation and troubleshooting. ## Enable automatic kill sprees [#enable-automatic-kill-sprees] Follow [Enable kill sprees](/docs/papamovgui2/kill-sprees) for a downloadable gameplay-driven plugin, team/FFA settings, reset rules and deployment checks. # Enable kill sprees URL: https://www.papamo.dev/docs/papamovgui2/kill-sprees Enable automatic kill-spree cards on your own CS 1.6 partner server. Yes—partner servers can send kill-spree cards through `papamovgui2.inc`. Use the example below to count actual server kills instead of the quickstart's `/cards` preview. Your server keeps its own gameplay rules; the native component only displays the result. ## Before you start [#before-you-start] You need CS 1.6, AMX Mod X with **Fakemeta and Ham Sandwich** enabled, and players joining your server through a compatible Papamo managed partner session. Players must enable **in-game enhancements** and **kill cards** in their launcher settings. The approved client bundle must support `papamovgui2_v1`. This is source-ready integration work; the signed client release and in-game animation validation are still pending. An include or plugin cannot enable native cards on an older bundle, a stock client or a browser client. See [compatibility](/docs/papamovgui2/compatibility). Players may install the **web helper** instead of the full desktop app. The web helper prepares the approved native cosmetic/HUD module during the managed launch; they do not install a separate cosmetic helper. Follow [player installation](/docs/setup#players-install-the-web-helper-or-desktop-app). The same signed-release and session requirements apply. Kill sprees work independently of the native custom scoreboard. You do not need to replace your server's scoreboard or enable the 1.6 Competitive match mode. ## Install the example [#install-the-example] 1. Download [papamovgui2.inc](/downloads/papamovgui2.inc) into `cstrike/addons/amxmodx/scripting/include/`. 2. Download [kill_sprees.sma](/downloads/kill_sprees.sma) into `cstrike/addons/amxmodx/scripting/`. 3. Compile from that directory using your server's matching AMXX compiler: ```sh ./amxxpc kill_sprees.sma -iinclude -ocompiled/kill_sprees.amxx ``` On Windows, use `amxxpc.exe` instead of `./amxxpc`. Create `compiled/` first if needed. Copy the output into `cstrike/addons/amxmodx/plugins/` and add this line to `cstrike/addons/amxmodx/configs/plugins.ini`: ```text kill_sprees.amxx ``` Restart the test server or change map, then check `amxx plugins` and `amxx modules`. The [setup guide](/docs/setup) covers installation and managed-session troubleshooting in more detail. ## Choose team or FFA mode [#choose-team-or-ffa-mode] Add these settings to the server's AMXX `configs/amxx.cfg`, or set them in the server console for the current session: ```text papamo_sprees_enabled 1 papamo_sprees_ffa 0 ``` | Setting | Behavior | | --- | --- | | `papamo_sprees_enabled 1` | Enable automatic snapshots; 0 disables and clears them | | `papamo_sprees_ffa 0` | Team mode: ignore teamkills; display up to five cards; clear on death, successful spawn and new round | | `papamo_sprees_ffa 1` | FFA mode: count same-team kills too; display up to sixteen cards; clear on death and successful spawn | `papamo_sprees_ffa` changes the card counter's interpretation only. Configure your actual deathmatch/FFA gameplay separately. Changing either setting clears existing sprees when the next event or one-second refresh observes it. The example counts ordinary `DeathMsg` kills, skips suicides/world kills, and uses grenade artwork for grenade kills. It requires the killer to remain alive; kills credited after the killer dies are not added to a new spree. Counts stop at the visible card limit. The renderer uses CT colors for CT players and the gold palette otherwise. ## Test with a player [#test-with-a-player] Join through the managed partner connection flow, enable the client settings, and allow up to two seconds for the capability handshake. Get a real enemy kill: a card should appear. Get another without dying: the fan should grow. Die or respawn: it should clear. In team mode, also check round resets and that teamkills do not add cards. The plugin renews snapshots once per second with a three-second lifetime. Identical snapshots keep the cards visible without restarting the animation. If renewal stops, the cards expire automatically. No per-frame server traffic is needed. This guide does not claim the test has passed on your installed client. Validate your approved bundle on an isolated server before rollout. ## Integrate your existing game mode [#integrate-your-existing-game-mode] If your mod has custom kill credit, respawn rules or teams, use its authoritative events instead of running a second counter alongside it: ```c // plugin_init: papamovgui2_init(); // Your confirmed round/life reset: papamovgui2_reset(id); // Your confirmed current state, renewed before the TTL expires: if (papamovgui2_available(id)) { papamovgui2_kill_cards(id, count, ctColors, ffaMode, 0, grenadeMask, 3); } ``` Do not run the `/cards` preview or another card writer alongside the live counter. One plugin should own this component for each player. Remove duplicate `papamovgui2_init`/capability handlers when combining examples into one plugin. The example deliberately sends `ace = 0`. Five kills do not prove an ace on arbitrary server modes. Supply an ace position only when your own round rules confirm the required opponents and round context. See the [API limits](/docs/papamovgui2/api). ## Troubleshooting and disabling [#troubleshooting-and-disabling] | Symptom | Check | | --- | --- | | Nothing appears | Plugin loaded, Fakemeta/Ham Sandwich enabled, compatible signed bundle, managed partner session, assigned endpoint, live lease and both client preferences | | Preview works but real kills do not | Install the live example; ensure your mod emits standard death/spawn events or wire its custom events | | Same-team FFA kills do not count | Set `papamo_sprees_ffa 1` and confirm actual server FFA rules | | Cards flicker or reset unexpectedly | Remove competing preview/card writers; check your mod's spawn/round events | | Cards stop at five/sixteen | These are the component's supported team/FFA display limits | Set `papamo_sprees_enabled 0` to clear and stop the example. Remove `kill_sprees.amxx` from `plugins.ini` and restart/change map to uninstall it. Outstanding snapshots expire within three seconds if the plugin is unloaded abruptly. Capability handshakes are presentation hints, not anti-cheat or entitlement checks. Never use them to grant inventory, rank or trusted server permissions. # Legacy GoldClient: HUD and crash diagnosis URL: https://www.papamo.dev/docs/papamovgui2/legacy-goldclient The November 8, 2026 compatibility investigation: exact binaries, failure causes, fixes and regression checks. ## Status and scope [#status-and-scope] On November 8, 2026, an isolated Windows installation with the binary pair below successfully launched, displayed the custom crosshair and scoreboard, and closed/relaunched after the shutdown fix. The tester confirmed the final build worked. This was a local development probe with synthetic scoreboard data, not a production authenticated match. The native fix is committed in private helper revision `21aea8a`. The [launcher compatibility fallback](https://github.com/keenplify/16competitive-client/commit/93e0c156) is a separate change. **A source push is not a signed release.** The production launcher's native allowlist was not expanded by these changes: unsupported legacy installations still use the original-DLL authenticated fallback. That fallback can map supported crosshair preferences to the engine's built-in commands, but does not provide the custom native scoreboard. Shipping the native adapter requires coordinated signed artifacts, explicit installer support and release validation. Do not apply the legacy ABI to every client called GoldClient or TurboClient. The adapter recognizes an exact client/engine pair; an interface name alone is insufficient. ## Binary identity [#binary-identity] SHA-256 of the inspected original files: | File | SHA-256 | | --- | --- | | `cstrike/cl_dlls/client.dll` | `7c9b6e10b0d896d5c99bb0175fff4e8a13834f3e3ae9948e5ccbbf3c1bfdba9d` | | `hw.dll` | `28438ed09e425a29489f034c68ec820ed84fc7c7ead32ae9190be376d2ef419c` | | `hl.exe` | `08ae290d025e3e3000f5264dce450e78d25ba1d931ff10f3e7992addbf44791a` | | Matching `GameUI.dll` | `a208f0f3544d3f6574ed501f65a5b6c914d9cd046a7406a067bb6eea0a73a761` | | Matching `vgui2.dll` | `ff40c30638286bea1d3a8f3315fa4df060df8a503b57d7df9d9973b2960f0636` | The supplied `steam_api.dll` exports a data/interface pointer named `TurboClient`. This is evidence of an interface name, not proof of a public repository or distribution ancestry. No updater URL or authoritative TurboClient repository was established in this investigation. ## Symptoms and causes [#symptoms-and-causes] | Symptom | Established cause | Fix or diagnostic action | | --- | --- | --- | | Assets finish preparing, but no game process starts | The original launcher report rejected the native installation with `NATIVE_INSTALL_UNSUPPORTED`; automatic launch and reconnect both reached that rejection | Distinguish preparation rejection from a process crash. Preserve the authenticated original-DLL fallback | | Missing `SteamMatchmakingSearch` entry point | A newer GameUI was mixed with the legacy installation | Use matching UI dependencies; do not transplant arbitrary DLLs | | Optional server browser fails | The newer test-copy browser requested `VEngineCvar006`; the supplied engine exposed `VEngineCvar005` | Keep mixed-version browser resources out of the isolated test. This is separate from direct match connection | | Proxy disappears or behavior changes between runs | The game updater replaced the test proxy | Pass `-noupdate` on the identified launch path and compare hashes before and after every run | | Native initialization fails | Legacy `Initialize` takes three arguments instead of the SDK's two | Dispatch the exact verified legacy pair through its three-argument ABI; preserve the modern two-argument path | | Crosshair works but Tab shows the stock board | NetAPI reported `connected = 0` while a map was running; a later failure was a surface size query returning `0 x 0` | Apply only the exact-pair connection-status workaround, retaining endpoint checks; use the correct surface method table | | Board activation crashes inside drawing | Legacy textured-polygon method takes a third boolean and performs `RET 12` | Use the three-argument call for this engine; the SDK two-argument call corrupts the stack | | Player's highlighted row looks solid white and the name is unreadable | Textured-polygon drawing disables blending; the following filled-rectangle operation assumes blending is enabled | Draw legacy solid fills through the alpha-blended polygon path using a reserved white atlas texel | | Closing/restarting the game crashes | Cleanup dereferences a cached VGUI interface after its owning library is no longer loaded | Re-query existing interface instances before cleanup; never call stale interfaces | The earlier launch report was from launcher `2026.1107.8`, before the authenticated fallback. It does not establish that the current auto-launch trigger is broken. ## ABI details worth preserving [#abi-details-worth-preserving] The original client's `Initialize` at RVA `0x30df0` accepts `(engine_functions, interface_object, version)`. It dereferences argument two, checks argument three against version 7 and copies 154 engine-function pointers. Four legacy connection callbacks follow the ordinary 44-entry callback table. The proxy preserves the caller's argument frame and only reads a third argument for the verified legacy family. This engine advertises `VGUI_Surface026`, but its `BaseUISurface` vtable at virtual address `0x101a26f0` contains an extra method at slot 29. Slots before it remain unchanged: | Operation | Standard Windows slot | Inspected legacy slot | | --- | --- | --- | | CreateNewTextureID | 31 | 32 | | GetScreenSize | 32 | 33 | | ReleasePanel | 74 | 75 | | DrawTexturedPolygon | 88 | 89 | The wrong size-query slot called texture creation instead, leaving width and height at zero. Correcting the slot yielded the expected `800 x 600`; it did not resolve the separate polygon calling-convention mismatch. The engine polygon implementation at virtual address `0x10097da0` accepts `(vertices, count, blend_mode)`. The adapter uses `false` for ordinary source-alpha blending. The function disables blending at `0x10097e96`; the filled-rectangle implementation at `0x10097b10` does not enable it. This explains why changing the row's color alone would not fix the white highlight. These addresses describe the inspected engine image, not universal addresses or permission to patch engine instructions. The adapter uses interface calls. Linux, modern Windows clients and WON retain their separate ABI paths. ## Next time: diagnosis checklist [#next-time-diagnosis-checklist] 1. Start with launcher logs: did asset preparation fail, did native installation reject the client, or did a game process actually start? Record the exact launcher/helper versions and failure stage. Redact credentials before sharing logs. 2. Preserve originals and reproduce in a separate test directory. Never read, copy, back up or modify the player's `config.cfg`; use launcher-owned startup files and process arguments. 3. Hash the original engine/client, UI dependencies and installed proxy before and after launch. Confirm the process loaded the expected original DLL beside the proxy. A self-updater can invalidate every conclusion from an earlier run. 4. Check the session lease, feed freshness and assigned endpoint before investigating drawing. Do not force an authorization gate open. In this local test the engine reported endpoint `loopback`, not the string `127.0.0.1:27025`. 5. Inspect interface availability, panel creation and screen dimensions. `VGUI_Surface026` appearing in strings does not prove its ABI matches the SDK. 6. For a crash, preserve the dump **and the exact loaded DLL/PDB before rebuilding**. Match the PDB identity to that DLL; subtract the dump's loaded module base when resolving an RVA. A newly built PDB can misleadingly map an old crash to a different function. 7. In Ghidra, check both call sites and callees: argument order, stack cleanup, vtable slots and callback-table length. Decompiled signatures are hypotheses until checked against instructions. 8. Test rendering and lifecycle separately: open/close Tab, inspect row transparency, change crosshair settings, close normally, then relaunch. A board that renders once does not prove shutdown is safe. ### Development probe diagnostics [#development-probe-diagnostics] Debug builds with `PAPAMO_SKIN_PROBE_TRACE=1` and a valid explicit probe manifest write a bounded `hud-probe-state.txt` snapshot once per second from the owned input worker. Game draw callbacks only update counters; they do not write the file. This is local probe instrumentation, not automatic uploaded telemetry. - `net`: raw connected value in the high 16 bits and remote address kind in the low 16 bits, before normalization. The local legacy test reported `00000001`. - `board`: bit 0 authorized, bit 1 VGUI ready, bit 2 visible, bit 3 score-key ownership. A ready, held-open board can report `f`; a closed ready board can report `3`. - `panel`: stage 1 GUI discovery, 2 panel interface, 3 surface interface, 4 interfaces found, 5 panel allocation attempted, 6 texture creation attempted, 7 creation completed. - `size`: width in the high 32 bits, height in the low 32 bits. `0000032000000258` means `800 x 600`. These values narrow a failure; they never replace authorization or prove visual correctness. Compare the last snapshot's time with the crash time, because it can be stale. ## Verification and remaining limits [#verification-and-remaining-limits] The final source checks passed: 158 helper/module tests with two ignored, 124 session-helper tests with three ignored, 23 launcher compatibility/recovery tests, the launcher main-process TypeScript check and targeted lint. The Windows x86 module built successfully. Runtime verification covered the supplied pair in the isolated local game, visible custom HUD, and a close/relaunch with no new dump; the tester then confirmed it worked. Linux runtime behavior, authenticated live-match activation, modern-client runtime regressions, repeated map changes and long-session stability were not established by this test. Before a production release, validate those paths and coordinate the signed bundle, installer allowlist and any capability handshake. Do not broaden anti-cheat exemptions, bypass signature checks or infer support for other legacy hashes. The updater was observed replacing the proxy, but its service endpoint remains unknown. The test installation included newer baseline resources, so its observed update channel is not reliable proof of the supplied installation's original channel. # AMXX quickstart URL: https://www.papamo.dev/docs/papamovgui2/quickstart Display an animated kill-card preview from a server plugin. ## Requirements [#requirements] Use Counter-Strike 1.6, AMX Mod X with Fakemeta, and a compatible Papamo managed session. The game must run the approved PAPAMOVGUI2-capable native bundle. A stock client, a browser client or a client that has not opted in will not display these cards. Partner card messages require an assigned-server managed session, enabled in-game enhancements and enabled kill cards. They do not activate the 1.6 Competitive scoreboard on your server. ## Install the include [#install-the-include] Download [papamovgui2.inc](/downloads/papamovgui2.inc) and place it in your compiler's `scripting/include/` directory. The partner server package also includes it. ## Compile a preview plugin [#compile-a-preview-plugin] This deliberately displays a **three-card preview**, not a real kill count. It does not update game statistics. ```c #include #include public plugin_init() { register_plugin("PAPAMOVGUI2 preview", "1.0", "Your platform"); papamovgui2_init(); register_clcmd("say /cards", "preview_cards"); } public preview_cards(id) { if (!papamovgui2_available(id)) { client_print(id, print_chat, "This preview needs a compatible managed client."); return PLUGIN_HANDLED; } // id, count, CT colors, FFA, ace position, grenade bitmask, lifetime papamovgui2_kill_cards(id, 3, true, false, 0, 4, 3); return PLUGIN_HANDLED; } ``` After connecting through the managed launcher, allow up to two seconds for the capability handshake. Type `/cards` in chat. The third card uses grenade artwork; the other two use skulls. The snapshot expires after three seconds. ## Connect actual gameplay events [#connect-actual-gameplay-events] Maintain your own confirmed per-life or per-round count. Call `papamovgui2_reset(id)` when your rules start a new life/round. Call `papamovgui2_kill_cards` when its presentation changes, and refresh it before its lifetime expires if it should remain visible. One plugin should own the card component for a player. Competing writers replace the same component. ## Understand availability [#understand-availability] `papamovgui2_available` indicates a recent capability handshake for the current connection user ID. It is **not** an anti-cheat verdict or a delivery acknowledgement. Clients can falsify handshakes. Never use it for ranks, entitlements or trust decisions. ## Enable automatic kill sprees [#enable-automatic-kill-sprees] Follow [Enable kill sprees](/docs/papamovgui2/kill-sprees) for a downloadable gameplay-driven plugin, team/FFA settings, reset rules and deployment checks. # Customize the scoreboard URL: https://www.papamo.dev/docs/papamovgui2/scoreboard Define native columns, fonts, colors and viewer-specific statistics from AMXX. ## What can a server modify? [#what-can-a-server-modify] Partner servers can define a native table through [papamovgui2_scoreboard.inc](/downloads/papamovgui2_scoreboard.inc): title, footer, team names and scores, player rows, up to eight statistic columns, column widths/alignment, six RGBA colors, row height, font size and bold text. The renderer uses its bundled font and fixed table structure. It does not execute server scripts, load arbitrary fonts or accept model/file paths. This interface is new source work requiring `papamovgui2_scoreboard_v1` and a matching NextClient host where applicable. It is not enabled by a card-only capability. Complete the [setup guide](/docs/setup) first. The platform's authenticated 1.6 Competitive match scoreboard cannot be replaced through partner messages. ## Example and lifecycle [#example-and-lifecycle] Download the complete [native_scoreboard.sma example](/downloads/native_scoreboard.sma). It sends kills, deaths and ping once per second to each opted-in viewer. ```c #include // plugin_init: papamovgui2_board_init(); // One update for one connected viewer: if (papamovgui2_board_available(viewer)) { papamovgui2_board_begin(viewer, revision); // revision: 0..65535 papamovgui2_board_title(viewer, "Your server"); papamovgui2_board_column(viewer, 0, "Kills", 100); papamovgui2_board_column(viewer, 1, "Money", 120); papamovgui2_board_team(viewer, 2, ctScore, "Counter-Terrorists"); papamovgui2_board_team(viewer, 1, tScore, "Terrorists"); papamovgui2_board_player(viewer, player, team, alive, playerName); papamovgui2_board_stat(viewer, player, 0, killsText); papamovgui2_board_stat(viewer, player, 1, moneyText, PapamoBoardTeam); papamovgui2_board_footer(viewer, "Your platform"); papamovgui2_board_commit(viewer, 3); } ``` `begin` starts a full replacement. Add every column and player you want in that snapshot. Omitted rows and cells disappear on the next successful commit; there is no inherited private data. Build a new revision for each update, wrapping at 65535. Revision identifies a transaction, not authoritative ordering. Finish within two seconds. The client accepts at most 512 operations per transaction and ten commits per second. Use event-driven updates plus TTL renewal rather than sending full rosters at that maximum. The previous committed board stays visible while a valid replacement is built. Invalid native operations abort the replacement and preserve the previous board until its original expiry. A committed board appears on Tab. Its TTL is 1–10 seconds; renew it before expiry. Expired snapshots, missing session ownership, another endpoint or unavailable VGUI2 return control to the normal scoreboard. `papamovgui2_board_reset(viewer)` clears it immediately. All functions returning true mean queued, not acknowledged or painted. ## Style [#style] ```c new colors[6][4] = { {24, 24, 18, 240}, // background {189, 163, 93, 255}, // border {243, 240, 231, 255},// text {212, 179, 107, 255},// accent {168, 200, 232, 255},// CT {223, 187, 128, 255} // T }; papamovgui2_board_style(viewer, colors, 24, 15, false); ``` Call style between begin and commit. Values are red/green/blue/alpha, each 0–255. Row height is 18–32 and font size 12–20 in logical layout units. The table fits the viewport; these are not guaranteed physical screen pixels. Square borders and the name column remain part of the renderer's structure. ## Privacy scopes [#privacy-scopes] | Scope | Server dispatch behavior | | --- | --- | | `PapamoBoardPublic` | Send value to this viewer | | `PapamoBoardSelf` | Send only when viewer and subject slots match | | `PapamoBoardTeam` | Send only when viewer and subject are connected members of the same T/CT team | Disallowed cells are sent as empty strings. Private values never travel to unauthorized viewers for client-side hiding. Spectators do not receive team-scoped cells. For custom teams or spectator permissions, apply your own authorization before calling with Public; never pass a secret to an unauthorized viewer. One transaction targets one viewer, not a broadcast audience. ## Limits and API [#limits-and-api] | Function | Contract | | --- | --- | | `papamovgui2_board_init()` | Initialize once in `plugin_init` | | `papamovgui2_board_available(viewer)` | Current connection user ID and capability handshake younger than four seconds | | `papamovgui2_board_begin(viewer, revision)` | Full replacement; revision 0–65535 | | `papamovgui2_board_title(viewer, title)` | Nonempty, at most 128 UTF-8 bytes / 64 characters | | `papamovgui2_board_style(viewer, colors, rowHeight=24, fontSize=15, bold=false)` | Six RGBA colors and bundled font controls | | `papamovgui2_board_column(viewer, column, label, width=100, right=true)` | Indices 0–7, contiguous from 0; widths 40–220, total at most 750; nonempty label at most 96 bytes / 24 characters | | `papamovgui2_board_team(viewer, team, score, label="")` | T=1, CT=2; score 0–65535; label at most 96 bytes / 32 characters | | `papamovgui2_board_player(viewer, player, team, alive, name)` | Slot 1–32; team 0–3; nonempty name at most 96 bytes / 32 characters | | `papamovgui2_board_stat(viewer, player, column, value, scope=PapamoBoardPublic)` | Add player and column first; value at most 96 bytes / 32 characters | | `papamovgui2_board_footer(viewer, text)` | At most 160 bytes / 96 characters | | `papamovgui2_board_commit(viewer, seconds=3)` | At least one column; TTL 1–10 seconds | | `papamovgui2_board_reset(viewer)` | Hide board and abort pending replacement | Native strings must be valid UTF-8 without control characters. The renderer clips text to its column width. Sanitise incoming player names before building snapshots if your server allows control codes or legacy non-UTF-8 encodings. A changed player name/team clears old cell values in the receiver. ## Transport and rendering [#transport-and-rendering] The dedicated capability command is `papamovgui2_board 1`. `16CBoard` messages are variable length, at most 190 bytes. Their header is version 1, operation byte and little-endian 16-bit transaction revision. The include handles packing. Stock clients and card-only clients receive no board packets unless they advertise the separate capability. Capability is display-only and can be falsified by clients. The owned input worker builds text and cached geometry only when committed layout data changes. Tab visibility does not require Electron screenshots or repeated atlas transfers. The native panel rechecks the live lease, endpoint, immutable prepared content and absolute snapshot expiry before delayed painting. In-game performance and platform coverage still require release validation. # Setup guide URL: https://www.papamo.dev/docs/setup Set up a CS 1.6 server plugin, managed client and platform integration. ## Choose your role [#choose-your-role] **Server owners** compile an AMXX plugin using the public includes. **Platform developers** additionally need an approved Papamo helper/session integration. Installing an include alone does not install the native renderer on players' computers. The new cards and customizable scoreboard are implemented in source. A coordinated signed client release and in-game validation are still pending. Follow this guide with an approved compatible test bundle; the currently installed production helper may not yet support it. See [compatibility](/docs/papamovgui2/compatibility). ## Players: install the web helper or desktop app [#players-install-the-web-helper-or-desktop-app] Players can use either option. They do **not** need to install the full desktop app when using the **web helper**. | Option | Download | How players join | | --- | --- | --- | | Web helper · Windows x64 | [Download web helper](https://github.com/keenplify/16competitive-client/releases/latest/download/competitive16-web-helper.exe) | Use the browser interface and its managed partner-server launch flow | | Web helper · Linux x64 | [Download web helper](https://github.com/keenplify/16competitive-client/releases/latest/download/competitive16-web-helper-linux) | Use the browser's Linux helper setup instructions, then launch the managed partner server | | Web helper · Linux ARM64 | [Download web helper](https://github.com/keenplify/16competitive-client/releases/latest/download/competitive16-web-helper-linux-arm64) | Requires a supported game/runtime setup; helper availability alone does not establish native CS 1.6 HUD compatibility on ARM64 | | Full desktop app · Windows | [Download app](/16competitive/download/windows) | Select the game installation and launch the partner server from the app | | Full desktop app · Linux | [Download app](/16competitive#linux-downloads) | Choose your architecture, select the game installation and launch from the app | **The web helper is the browser companion, not a standalone cosmetic-helper download.** During an authorized managed setup/launch it obtains and verifies the approved native bundle and installs/configures its cosmetic/HUD module for a supported CS 1.6 installation. Players should not manually copy a cosmetic DLL/module or run a separate cosmetic installer. Verified existing files may be reused. ### Web-helper setup [#web-helper-setup] 1. Open the [web app](https://16competitive.papamo.dev/web) or your supported partner launch page and sign in. 2. On Windows, download and open the web helper once to install/register the browser URL handler. On Linux, use the setup instructions generated by the web app for your architecture. Setup is per-user and does not require administrator rights. 3. Return to the browser and run its helper check. Allow the browser to open the installed helper when prompted. 4. Select your existing CS 1.6 installation in the helper-backed browser settings. Enable **in-game enhancements**, and enable **kill cards** for kill sprees. 5. Join through the managed partner-server launch action. The web helper prepares the verified native module and any required signed background runtime/assets for that flow, then launches the installed game under its assigned session. The full desktop launcher UI is optional in this flow. The web helper remains a local installed program and may download a signed background runtime; it is not browser-only gameplay. The native game and its supported installation are still required. Installing the web helper does not install Counter-Strike itself. Opening CS directly and manually connecting does not create an authorized managed HUD session. Likewise, playing a browser-rendered game without the local native CS/helper session does not provide PAPAMOVGUI2. ### Release compatibility still applies [#release-compatibility-still-applies] Automatic native-module installation uses the approved packaged release. It does not make unreleased PAPAMOVGUI2 features available in an older bundle. Cards need `papamovgui2_v1`; customizable native tables additionally need `papamovgui2_scoreboard_v1`, with the matching host bridge where required. Do not bypass signature, hash or installation-compatibility checks to force support. ## 1. Prepare a test server [#1-prepare-a-test-server] Use CS 1.6 with AMX Mod X and the Fakemeta module enabled. Start on a separate test instance and retain your normal plugin package for rollback. Use the AMXX compiler matching your server version. Download the interfaces you need into `cstrike/addons/amxmodx/scripting/include/`: - [papamovgui2.inc](/downloads/papamovgui2.inc) for animated cards. - [papamovgui2_scoreboard.inc](/downloads/papamovgui2_scoreboard.inc) for a server-owned native scoreboard. - [papamo_cosmetics.inc](/downloads/papamo_cosmetics.inc) for recipes already authorized and staged by the managed asset pipeline. These are Pawn include files containing stocks. No new AMXX binary module is required beyond their existing Fakemeta dependency. Include only the interfaces your plugin uses, and initialize each once in `plugin_init`. ## 2. Compile and install a plugin [#2-compile-and-install-a-plugin] For cards, copy the [AMXX quickstart](/docs/papamovgui2/quickstart) into a `.sma` file. For scoreboards, download [native_scoreboard.sma](/downloads/native_scoreboard.sma) into the server's `scripting/` directory. From that directory, compile the scoreboard example on Linux: ```sh ./amxxpc native_scoreboard.sma -iinclude -ocompiled/native_scoreboard.amxx ``` On Windows: ```powershell .\amxxpc.exe native_scoreboard.sma -iinclude -ocompiled/native_scoreboard.amxx ``` Create `compiled/` first if your compiler package does not provide it. Copy the compiled `.amxx` file to `cstrike/addons/amxmodx/plugins/`, then add its filename on a separate line in `cstrike/addons/amxmodx/configs/plugins.ini`: ```text native_scoreboard.amxx ``` Restart the test server or change map. Check `amxx plugins` and `amxx modules` in the server console. Resolve compile errors, missing modules or plugin load errors before testing the client. Use one plugin as the owner of each viewer's card/scoreboard component. ## 3. Connect a compatible managed client [#3-connect-a-compatible-managed-client] Launch the approved CS 1.6 installation through the managed partner-server connection flow. Enable in-game enhancements. Enable kill cards if testing cards; the native scoreboard works independently of the kill-card setting. The helper must authorize this exact server endpoint under a live session. Connecting an ordinary client directly does not establish that authorization. Do not create session marker files manually or replace verified native binaries. Allow up to two seconds for the capability handshake. The card preview responds to `/cards`; the scoreboard example refreshes once per second and appears while Tab is held. Stock clients keep their ordinary scoreboard. A handshake means display capability, not trusted identity or proof that a frame was painted. ## 4. Customize and connect real data [#4-customize-and-connect-real-data] Change the example's column labels, widths, colors, title, team scores and values through the [scoreboard interface](/docs/papamovgui2/scoreboard). Translate server-supplied text for your players. Feed it confirmed server data; retain ownership, rankings and match results on your authoritative backend. Build a full snapshot for each viewer and commit it. Filter private values on the server before dispatch. Send changes and renew snapshots before their TTL expires; a one-second refresh with a three-second TTL is a reasonable starting point for the example. Animation runs locally and needs no per-frame server updates. For cosmetics, complete the [verified V/P/W asset pipeline](/docs/cosmetics/runtime-viewmodels) first. A model path or skin ID is not a valid recipe ID. ## Platform integration checklist [#platform-integration-checklist] Public `.inc` files provide the server presentation interface. They do not provide a self-service helper redistribution SDK, partner entitlement API or signing service. Arrange approved platform access with Papamo before distributing native components. Your integration must provide: 1. A compatible signed native module and host bridge, verified against the approved manifest and registry. 2. An owned managed session with a fresh ticket, live launcher lease and assigned server endpoint. 3. Explicit enhancement preferences and the managed partner-HUD authorization path. 4. Verified immutable assets and bounded local catalogs before selecting cosmetic recipes. 5. Session shutdown that revokes temporary ownership, credentials and workers. Current Windows/NextClient CS 1.6 installations retain their managed module; routine shutdown does not restore DLLs. Keep the helper, launcher, host bridge and server contracts versioned together. The authenticated 1.6 Competitive match scoreboard remains separate from partner customization. ## Troubleshooting [#troubleshooting] | Symptom | Check | | --- | --- | | Include not found | Compiler `include/` directory and `-iinclude` argument | | Plugin fails to load | Matching AMXX compiler/server version and enabled Fakemeta | | Availability remains false | Compatible bundle, managed partner flow, endpoint, live lease and enhancement setting | | Cards absent | Kill-card preference, snapshot count/TTL and current component owner | | Stock scoreboard still appears | Separate board capability, complete transaction, at least one contiguous column and valid TTL | | Old board disappears | Renew before TTL; finish transactions within two seconds; inspect rejected fields | | Cosmetic selection ignored | Approved staged recipe, source weapon mapping and 750ms selection expiry | To disable the example, remove its plugin entry and restart/change map. Expired board snapshots fall back to stock presentation. Keep existing asset verification and session gates enabled throughout testing. ## Read with an LLM [#read-with-an-llm] Use the [documentation index](/llms.txt) to find pages or [all documentation as text](/llms-full.txt) for one complete input. Each page has **Copy Markdown** and view controls. For this guide, use [/docs/setup.md](/docs/setup.md). These exports follow the [official Fumadocs LLM integration](https://www.fumadocs.dev/docs/integrations/llms).