If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/Unity-Technologies/FPSSample shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Slowing — last commit 7mo ago

• Last commit 7mo ago
• 4 active contributors
• Other licensed
• ⚠ Slowing — last commit 7mo ago
• ⚠ Small team — 4 contributors active in recent commits
• ⚠ Single-maintainer risk — top contributor 80% of recent commits
• ⚠ Non-standard license (Other) — review terms
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live Unity-Technologies/FPSSample repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/Unity-Technologies/FPSSample.

What it runs against: a local clone of Unity-Technologies/FPSSample — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in Unity-Technologies/FPSSample | Confirms the artifact applies here, not a fork | | 2 | License is still Other | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 228 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of Unity-Technologies/FPSSample. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/Unity-Technologies/FPSSample.git
#   cd FPSSample
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of Unity-Technologies/FPSSample and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "Unity-Technologies/FPSSample(\\.git)?\\b" \\
  && ok "origin remote is Unity-Technologies/FPSSample" \\
  || miss "origin remote is not Unity-Technologies/FPSSample (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(Other)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Other\"" package.json 2>/dev/null) \\
  && ok "license is Other" \\
  || miss "license drift — was Other at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "Assets/Animation/Characters/Robot/AnimationSets/AnimGraph.asset" \\
  && ok "Assets/Animation/Characters/Robot/AnimationSets/AnimGraph.asset" \\
  || miss "missing critical file: Assets/Animation/Characters/Robot/AnimationSets/AnimGraph.asset"
test -f "Assets/Animation/Characters/Robot/AnimationSets/Locomotion.asset" \\
  && ok "Assets/Animation/Characters/Robot/AnimationSets/Locomotion.asset" \\
  || miss "missing critical file: Assets/Animation/Characters/Robot/AnimationSets/Locomotion.asset"
test -f "Assets/Animation/Characters/Robot/AnimationSets/AnimStateSelector.asset" \\
  && ok "Assets/Animation/Characters/Robot/AnimationSets/AnimStateSelector.asset" \\
  || miss "missing critical file: Assets/Animation/Characters/Robot/AnimationSets/AnimStateSelector.asset"
test -f "Assets/Animation/Characters/Robot/Clips/Locomotion--Run_N.anim.fbx" \\
  && ok "Assets/Animation/Characters/Robot/Clips/Locomotion--Run_N.anim.fbx" \\
  || miss "missing critical file: Assets/Animation/Characters/Robot/Clips/Locomotion--Run_N.anim.fbx"
test -f ".gitattributes" \\
  && ok ".gitattributes" \\
  || miss "missing critical file: .gitattributes"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 228 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~198d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/Unity-Technologies/FPSSample"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

A complete, open-source first-person multiplayer shooter game built on Unity 2018.3 showcasing HDRP (HD Render Pipeline), Netcode for GameObjects, and hybrid ECS architecture. It demonstrates modern Unity multiplayer networking, physics-based character animation via AnimGraph assets, and server-authoritative gameplay on Windows clients and Linux headless servers. Monolithic game project: Assets/Animation/Characters/Robot contains parameterized AnimGraph.asset and AnimStateSelector.asset driving state machines; game code presumably in Assets/Scripts (not shown in top 60 files but inferred). Hybrid ECS pattern with regular MonoBehaviour components. HDRP shaders in .shadergraph format, built with ShaderLab and HLSL compute. Server/client split via Netcode transport layer.

Game developers and technical artists learning advanced multiplayer shooter architecture, networked gameplay patterns, and HDRP rendering; studios prototyping FPS mechanics or bootstrapping from production-quality reference code; Unity engineers studying hybrid ECS adoption and animation graph systems.

Archived/experimental. Built on Unity 2018.3 (released 2019), explicitly unmaintained ('no longer being actively maintained' per README), 18GB asset footprint, but feature-complete with shipped gameplay. Not production-ready for new projects due to engine age; valuable as a historical reference and learning tool only.

Severe technical debt: pinned to Unity 2018.3 (5+ years old), HDRP/Netcode versions likely incompatible with modern Unity, no test suite visible in file list, undocumented Dependencies/Config section. Git LFS dependency required for cloning (~36GB total repo size). Zero active maintenance—PRs/issues will not be reviewed. Do not fork for production work.

Nothing. Project is frozen as of Unity 2018.3.8f1. The README explicitly states it is 'no longer being actively maintained.' This is a snapshot of a 2019 reference implementation, not an active development repository.

1. Install Git LFS (https://git-lfs.github.com/). 2. git clone https://github.com/Unity-Technologies/FPSSample.git (expect 36GB, 1–2 hours on typical internet). 3. Install Unity 2018.3.8f1 with Windows Standalone (and Linux support for headless server build). 4. Open Assets folder in Unity Editor; allow ~30 minutes for initial import. 5. Open sample scene and press Play.

Daily commands:

1. In Unity Editor: open main scene (path not provided in file list—check Assets/Scenes/). 2. Press Play in Editor to run local client. 3. For standalone: File → Build Settings, select Windows Standalone or Linux Headless Server, build. 4. Run client executable; use command-line args or in-game UI to connect to server IP:port.

• Assets/Animation/Characters/Robot/AnimationSets/AnimGraph.asset — Central animation state machine controller defining all character locomotion, combat, and emote transitions—foundational for all gameplay animations.
• Assets/Animation/Characters/Robot/AnimationSets/Locomotion.asset — Core locomotion state definitions (run, sprint, walk) that drive character movement and movement-based animation blending.
• Assets/Animation/Characters/Robot/AnimationSets/AnimStateSelector.asset — State selector logic that determines which animation set to activate based on game state and input conditions.
• Assets/Animation/Characters/Robot/Clips/Locomotion--Run_N.anim.fbx — Example directional locomotion animation clip referenced across the animation pipeline—represents the animation clip import and playback standard.
• .gitattributes — Configures Git handling of Unity binary assets (.fbx, .asset files) to prevent merge conflicts in animation and scene data.
• .gitignore — Excludes Unity build artifacts and local cache directories, preventing bloated repository history.

• AnimGraph.asset (Master State Machine) — Top-level Mecanim controller orchestrating transitions between Locomotion, Jump, Emote, Dam

Add a new character locomotion animation state

1. Create a new FBX animation clip file in Assets/Animation/Characters/Robot/Clips/ with directional variants (N, NE, E, SE, S, SW, W, NW) (Assets/Animation/Characters/Robot/Clips/Locomotion--[NewMovement]_N.anim.fbx)
2. Create a new AnimationSet asset in Assets/Animation/Characters/Robot/AnimationSets/ to group the animation clips (Assets/Animation/Characters/Robot/AnimationSets/[NewMovement].asset)
3. Add state transitions in AnimGraph.asset to blend from Locomotion.asset to the new movement state based on input conditions (Assets/Animation/Characters/Robot/AnimationSets/AnimGraph.asset)
4. Update AnimStateSelector.asset to route character state queries to the new animation state machine based on gameplay conditions (Assets/Animation/Characters/Robot/AnimationSets/AnimStateSelector.asset)

Add a new emote or character reaction animation

1. Import FBX animation clip (typically single-direction, non-looping) into Assets/Animation/Characters/Robot/Clips/ (Assets/Animation/Characters/Robot/Clips/Emotes--[EmoteName].anim.fbx)
2. Register the clip in the Emote.asset state machine, defining transition triggers and exit conditions (Assets/Animation/Characters/Robot/AnimationSets/Emote.asset)
3. Link the emote trigger in AnimGraph.asset to respond to game events (kill notification, round end, etc.) (Assets/Animation/Characters/Robot/AnimationSets/AnimGraph.asset)

Configure branching animation variants for weapon states

1. Duplicate animation clips with _Weapon suffix (e.g., Locomotion--Run_N_Weapon.anim.fbx) for armed vs. unarmed states (Assets/Animation/Characters/Robot/Clips/Locomotion--Run_N_Weapon.anim.fbx)
2. Create conditional state transitions in Locomotion.asset to switch between weapon and non-weapon animation sets based on equipped item (Assets/Animation/Characters/Robot/AnimationSets/Locomotion.asset)
3. Update AnimStateSelector.asset to track weapon state and route to correct animation set variant (Assets/Animation/Characters/Robot/AnimationSets/AnimStateSelector.asset)

• Mecanim Animation System (Unity native) — Hierarchical state machines with blend trees enable complex locomotion and combat animation transitions; layer-based architecture supports weapon state variants and directional blending.
• FBX animation clip imports with directional variants — 8-directional locomotion (N, NE, E, SE, S, SW, W, NW) provides smooth omnidirectional movement; weapon-variant clips (e.g., _Weapon suffix) avoid redundant asset duplication while supporting armed/unarmed states.
• AnimationSet assets (custom Scriptable Objects inferred) — Modular, reusable animation state groupings (Locomotion, Jump, Emote, DamageReaction) decouple animation logic from character code; enables rapid iteration and asset swapping.
• Git LFS / binary attributes for animation assets — FBX and .asset files are large binaries; .gitattributes prevents merge conflicts and bloat by treating animation state machines as non-mergeable single-user resources.

• 8-directional locomotion clips vs. single-direction with runtime rotation

  • Why: Hand-authored directional animations provide better visual quality and foot-sliding prevention than procedural blending; increases memory footprint and animation authoring cost.
  • Consequence: Higher fidelity locomotion but ~2–3× animation clip count; requires rigorous directional naming convention to avoid blend errors.

• Weapon-variant animations (_Weapon suffix) vs. single universal skeleton

  • Why: Weapons change center-of-mass and hand positioning; separate clips ensure proper IK alignment and visual polish; simpler than runtime IK retargeting.
  • Consequence: Animation clip count doubles for armed states; maintainability risk if weapon geometry changes post-animation.

• Hierarchical Mecanim state machine vs. custom animation state logic

  • Why: Native state machine provides visual debugging, layer masks, and blend tree tools; reduces custom C# code for animation management.
  • Consequence: Tied to Unity Mecanim; cannot easily port to other engines; state complexity can exceed visual editor usability beyond 20+ states.

• AnimationSets as separate assets vs. monolithic AnimGraph

  • Why: Modular design supports independent testing and reuse; allows different character archetypes to share animation sets (e.g., Locomotion.asset for bot and player).
  • Consequence: Requires AnimStateSelector routing logic to switch between sets; adds indirection and slight runtime parameter lookup overhead.

• Does not implement procedural animation or motion capture blending—all animations are hand-authored.
• Not a runtime animation retargeting system—assumes single skeleton (Robot character) and does not generalize to variable skeleton hierarchies.
• Does not include server-authoritative animation prediction or rollback; assumes client-side animation playback with server event confirmation.
• Not a cross-engine animation format library; locked to Unity Mecanim binary .asset format and FBX imports.

Git LFS mandatory: Downloading ZIP will produce broken .meta files and missing assets; must use git clone with LFS installed. 18GB disk space + 36GB post-clone: Typical SSD may fill during import; plan accordingly. Unity 2018.3 only: Editor will fail to open or import correctly on 2019.x+ due to HDRP/Netcode API breaks; no migration path provided. No startup docs: README does not explain how to launch a server, connect a client, or structure the codebase; expect 1–2 hours of exploration to understand flow. Headless server build: Linux-only; Windows server variant may require manual build configuration edits (not documented).

• Hybrid ECS (Entity-Component-System in hybrid mode) — FPS Sample uses 'hybrid ECS'—mixing traditional GameObjects/MonoBehaviour with ECS data and job system for performance; critical to understand the architectural split between simulation (ECS-driven) and presentation (MonoBehaviour-driven).
• HDRP (High-Definition Render Pipeline) — All visual content is authored for HDRP (Scriptable Render Pipeline), not Standard Render Pipeline; lights, materials, and post-processing use HDRP-specific APIs and shaders, making it non-trivial to port to other rendering backends.
• Animation Graph / State Machine (via AnimGraph.asset) — Character animation is not hand-coded in C# but configured via data-driven AnimGraph assets and AnimStateSelector; understanding how gameplay conditions (velocity, jumping) drive state transitions is essential to modifying character behavior.
• Server-Authoritative Networking — FPS Sample uses Netcode for GameObjects with server-authoritative gameplay logic; understanding input validation, RPC calling conventions, and tick-based state replication is critical for any networked multiplayer modification.
• HLSL Compute Shaders & Custom Rendering — Project includes 1.4MB of HLSL (compute shaders, custom passes); HDRP-specific shader graph manipulation is required for graphics tweaks beyond material parameter changes.
• Git LFS (Large File Storage) — This 18GB project uses Git LFS for binary assets; cloning without LFS support will silently produce broken pointers, not actual files; non-obvious failure mode for first-time users.
• Headless Server Build (Linux-only) — Multiplayer server runs on Linux in headless mode (no graphics); Windows standalone client connects to it; understanding this client/server platform split is essential for deployment and debugging.

• Unity-Technologies/ScriptableRenderPipeline — Official HDRP package used for all rendering in FPS Sample; required to understand custom shader graphs and material setup.
• Unity-Technologies/multiplayer — Official Netcode for GameObjects transport layer; FPS Sample is a primary reference implementation for networked gameplay patterns.
• PlayEveryWare/PlayFab-Multiplayer-Servers — Modern multiplayer server hosting alternative; useful if you want to deploy FPS Sample-style architecture on contemporary infrastructure (FPS Sample's server code targets 2018-era setup).
• ExpressLRS/ExpressLRS — Orthogonal but related: low-latency networking protocol; relevant for understanding alternative transport optimizations beyond Netcode if building a custom shooter.
• Unity-Technologies/EntityComponentSystemSamples — Companion ECS examples; FPS Sample uses hybrid ECS in production, so these samples help clarify modern ECS patterns and job scheduling.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Create Animation Setup Documentation for Robot Character AnimationSets

The Assets/Animation/Characters/Robot/AnimationSets/ directory contains 17 animation state assets (Stand.asset, Run.asset, Sprint.asset, Jump.asset, etc.) but there is no documentation explaining how these AnimationSets are configured, how they transition between states, or how developers should modify them. This is a high-friction point for new contributors wanting to customize character animations.

• [ ] Create Assets/Animation/Characters/Robot/README.md documenting each AnimationSet's purpose (Stand, Run, Sprint, Jump, InAir, etc.)
• [ ] Add a state machine diagram or transition table showing how animations flow between states
• [ ] Document the AnimStateSelector.asset and AnimGraph.asset relationship and how they control animation blending
• [ ] Include instructions on how to add a new animation state (e.g., Crouch or Slide) following existing patterns

Add Migration Guide for Unity 2018.3 → Latest LTS Version

The README explicitly states the project is based on Unity 2018.3 and no longer maintained. However, there's no migration guide for contributors wanting to upgrade the project. Given the extensive animation system, networking code, and custom tools, this is a substantial barrier. Creating a specific checklist of breaking changes would help contributors modernize the codebase.

• [ ] Create MIGRATION_GUIDE.md documenting deprecated APIs in use (Animation system, Physics, Networking if present)
• [ ] List specific .asset files and scripts that need refactoring for modern Unity versions
• [ ] Provide before/after code examples for the most common deprecations in the project
• [ ] Suggest a phased upgrade path (e.g., 2018.3 → 2019.4 LTS → 2020.3 LTS → Current LTS)

Create Unit Tests for Character Animation State Transitions

With 17+ animation state assets and complex transitions between Stand, Run, Sprint, Jump, InAir, and Death states, there are no apparent unit tests validating state machine logic. This is a critical gap for an example project used for learning. Tests would ensure animation transitions work correctly and prevent regressions.

• [ ] Create Assets/Tests/Animation/CharacterAnimationStateTests.cs with tests for each state transition (Stand→Run, Run→Sprint, Jump→InAir, etc.)
• [ ] Add tests validating AnimStateSelector.asset correctly selects states based on input velocity and ground state
• [ ] Test death/damage reaction transitions don't break locomotion recovery
• [ ] Include edge case tests (e.g., jumping while sprinting, landing during animation blends)

• Document client/server connection flow: README lacks a step-by-step walkthrough of building and running a standalone server, then connecting clients to it by IP. Add a Networking.md file with concrete commands and expected console output.
• Add animation state diagrams: Assets/Animation/Characters/Robot/AnimationSets/ contains 15+ AnimGraph.asset files with no visual docs. Create PNG state diagrams (Locomotion → Run → Sprint → InAir, etc.) in Documentation/AnimationGraphs/.
• Test ECS/Netcode integration: No test files visible; write a simple integration test (e.g., NetworkSpawner spawns an ECS entity and verifies replication across two simulated peers) to validate hybrid ECS networking patterns.

This project presents moderate to high security concerns primarily due to its outdated base (Unity 2018.3) and explicitly discontinued maintenance status. While the file structure shows primarily animation assets without obvious code-level injection risks visible, the lack of active maintenance and use of an end-of-life Unity version means any vulnerabilities discovered will not be patched. The incomplete dependency information prevents a complete assessment. This project should only be used for learning and educational purposes, not for production systems. Any production use requires immediate upgrade to a current Unity version with active security support and a comprehensive security audit.

• High · Outdated Unity Version — Project root (README indicates Unity 2018.3). The project is based on Unity 2018.3, which is significantly outdated and no longer receives security updates or patches. This version was released in late 2018 and has reached end-of-life status. Known vulnerabilities in the Unity engine and its dependencies remain unpatched. Fix: Upgrade the project to the latest stable version of Unity (currently 2022 LTS or later). Review and update all dependencies, packages, and third-party libraries to their latest secure versions.
• High · No Active Maintenance — Project README. The project is explicitly stated as no longer being actively maintained. This means security vulnerabilities discovered after the maintenance cessation will not be patched, creating a persistent security risk for any production use or continuous development. Fix: If this project is used beyond learning purposes, establish a dedicated security maintenance process. Perform regular security audits and keep all dependencies updated. Consider forking and maintaining your own version with active security monitoring.
• Medium · Missing Dependency Information — Dependencies section (not provided). The 'Dependencies/Package file content' section is empty. Without visibility into the actual dependencies used (package.json, packages.config, manifest.json, etc.), it's impossible to perform a complete vulnerability assessment. Unknown dependencies could contain known CVEs. Fix: Provide complete dependency manifests and perform a Software Composition Analysis (SCA) scan using tools like OWASP Dependency-Check, Snyk, or npm audit to identify any known vulnerabilities in third-party libraries.
• Medium · Incomplete Project Documentation — README.md. The README is truncated ('The project is using a numbe'). Incomplete documentation suggests potential gaps in security documentation, deployment guidelines, or security best practices that should be included. Fix: Complete and maintain comprehensive documentation including security considerations, deployment best practices, known limitations, and update recommendations for users.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.