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/UnityTechnologies/open-project-1 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.

GO — Healthy across all four use cases

• 5 active contributors
• Distributed ownership (top contributor 44% of recent commits)
• Apache-2.0 licensed
• CI configured
• Tests present
• ⚠ Stale — last commit 3y ago

_{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 UnityTechnologies/open-project-1 repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/UnityTechnologies/open-project-1.

What it runs against: a local clone of UnityTechnologies/open-project-1 — 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 UnityTechnologies/open-project-1 | Confirms the artifact applies here, not a fork | | 2 | License is still Apache-2.0 | Catches relicense before you depend on it | | 3 | Default branch main exists | Catches branch renames | | 4 | Last commit ≤ 1039 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of UnityTechnologies/open-project-1. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/UnityTechnologies/open-project-1.git
#   cd open-project-1
#
# 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 UnityTechnologies/open-project-1 and re-run."
  exit 2
fi

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

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

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

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 1039 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1009d)"
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/UnityTechnologies/open-project-1"
  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).

Chop Chop is a complete open-source action-adventure game built in Unity (C# 706KB + ShaderLab 64KB) demonstrating best practices for collaborative game development. It showcases a full production pipeline: character combat systems, state machines, audio management, scene architecture with streaming chunks, and shader-based rendering on a destructible island environment. Single monolithic project structure: UOP1_Project/ is the main Unity project directory containing Assets/ with an Addons system. Architecture follows scene-based organization (Docs/WikiImages/Location_SceneHierarchy.png) with runtime anchors for cross-scene references, object pooling (Pool_diagram.png), event systems (EventSystem_diagram.png), state machines (StateMachine_diagram.jpg), and factory patterns (Factory_diagram.png). Core systems stored in Assets/ with plugin architecture via Addons/.

Game developers learning industry patterns (state machines, event systems, object pooling, audio architecture); Unity contributors looking at reference implementations; educators teaching game architecture; open-source collaborators building commercial-quality game systems.

Abandoned but polished: Last commit December 2021 (over 2 years inactive). The README explicitly states 'As of December 2021, Open Projects and Chop Chop are not in development anymore.' However, the codebase is production-grade with comprehensive documentation (Docs/WikiImages contain 40+ architecture diagrams), established contribution guidelines (CONTRIBUTING.md, Conventions document), and CI/CD workflows (.github/workflows/linter.yml). This is a completed reference implementation, not an active project.

Low execution risk, high maintenance risk: The codebase itself is stable and well-documented, but as an unmaintained legacy project, it will accumulate stale dependencies against newer Unity versions (likely LTS-version-locked). No active GitHub Issues backlog visible in provided data, but the project won't accept features—only serves as a learning reference. Risk comes from using this as a template: you'll need to port patterns to current Unity versions manually.

Nothing—project is complete and frozen. Last activity December 2021. The GitHub repo serves as an immutable reference: the Docs/ folder contains the final architectural documentation, and the UOP1_Project/ contains the shipped game. No open PRs, active milestones, or planned features. The /Docs/ReadmeImages/ contains devlog headers (Devlog1_4) suggesting 4 published development posts on the roadmap (open.codecks.io).

Clone the repository and open in Unity: git clone https://github.com/UnityTechnologies/open-project-1.git && cd UOP1_Project && open . -a Unity (on macOS) or use File → Open Project in Unity Hub on Windows/Linux. No npm/pip required—this is a native Unity project using only UnityPackageManager (Assets/ structure). Requires Unity LTS version compatible with 2020 (check .vsconfig for exact version).

Daily commands: Open UOP1_Project/ as a Unity project in Unity Hub (requires 2020 LTS or specified .vsconfig version). Press Play in the Editor to run the game. No separate build command needed for development; use File → Build Settings → Build for shipped builds. The project uses Unity's built-in Input System (InputActions.png in docs) configured via Assets/.

• CONTRIBUTING.md: Defines the collaboration process, code review standards, and communication channels (forums, Discord) for any would-be contributor.
• .github/workflows/linter.yml: CI/CD pipeline enforcing code style; essential to understand before submitting pull requests (project is frozen but documents the intent).
• UOP1_Project/Assets/Addons: Plugin architecture for extending the game; demonstrates how new systems (combat, audio, visuals) integrate without modifying core code.
• Docs/WikiImages/: 40+ annotated architecture diagrams (state machines, event systems, pooling, factory patterns, scene management) that visually explain all major systems.
• .vsconfig: Specifies exact Unity version and C# language features required; critical for avoiding build breakage when cloning.
• UOP1_Project/.editorconfig: Defines coding style (indentation, line length, naming conventions) enforced across the project; must be respected in any modifications.

For new features: Start in Assets/ directory structure (see Location_SceneHierarchy.png and SceneArchitecture_diagram.jpg). For combat/player logic: Examine state machine scripts referenced in TransitionTable_PigChef.png and TransitionTable_PigChef_Actions.png. For audio: AudioManager and AudioCue components documented in AudioCue_Component.png, AudioCue_CompositeSFX.png, AudioCue_RandomSFX.png. For visuals: Shader code in ShaderLab files (64KB total); see ShaderAddons.png for shader system. For world building: Scene chunks and landmass overrides (Landmass_OverridesDropdown.png, SceneChunks.png). Always check Conventions document before submitting changes.

Unity version lock: .vsconfig file specifies an exact LTS version (likely 2020 LTS). Using a newer Unity version may break shader compilation or serialization. Scene chunk streaming: The game uses custom scene management for open-world streaming (SceneChunks.png)—modifying scene structure requires understanding chunk dependencies in SceneArchitecture_diagram.jpg. Audio pooling: SoundEmitters_Pool is a pre-allocated object pool; instantiating audio sources outside this pool breaks memory optimization. No NuGet/package.json: This is pure Unity with UnityPackageManager—no C# NuGet dependencies to install. Addon system coupling: Adding new Addons requires following the plugin architecture pattern shown in Factory_diagram.png; ad-hoc systems won't integrate cleanly.

• Object Pooling — Chop Chop uses pooling for audio emitters (SoundEmitters_Pool.png) to avoid GC pressure in real-time gameplay; understanding this pattern is essential for optimizing your own game systems.
• State Machine — The core architecture (StateMachine_diagram.jpg, TransitionTable_PigChef.png) uses hierarchical state machines for character behavior; this is the industry-standard approach for game logic and you'll see it everywhere.
• Event-Driven Architecture — Chop Chop's EventSystem_diagram.png shows pub-sub messaging for decoupled systems; this pattern scales to complex games by avoiding hard dependencies between audio, input, and gameplay.
• Scene Streaming / Chunk-Based Loading — SceneChunks.png and SceneArchitecture_diagram.jpg show how to load/unload world chunks based on camera position; essential for open-world games to manage memory and maintain frame rate.
• Dependency Injection via Runtime Anchors — RuntimeAnchors_Setup.jpg and RuntimeAnchors_Using.jpg show a custom DI pattern for cross-scene references without hard coupling; cleaner than singletons for loosely-coupled game systems.
• Factory Pattern — Factory_diagram.png demonstrates centralized entity creation; the Addon system uses this to plug in new content (combat, enemies) without modifying core code.
• Shader Authoring (ShaderLab + HLSL) — The 64KB ShaderLab + 14KB HLSL files power the visual style; understanding custom shaders is non-trivial but critical for optimized rendering in shipped games.

• Unity-Technologies/the-house — Another official Unity learning project demonstrating best practices for project structure, though more recent and still actively documented.
• UnityTechnologies/2d-game-kit — Companion open-source project showing 2D game architecture patterns; complements Chop Chop's 3D open-world approach with different technical decisions.
• prime31/CharacterController2D — Reference implementation of character state machines and movement logic; useful for understanding the player control patterns that Chop Chop's state machine builds on.
• Unity-Technologies/NetCode.Samples — Shows modern networking patterns for multiplayer; useful if extending Chop Chop's event-driven architecture to multiplayer (addresses one gap in the archived project).
• aarthificial/CreateWithCode — Community-maintained archive of official Unity learning projects; useful for finding other reference implementations of patterns shown in Chop Chop.

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 comprehensive Wiki documentation for Audio System (AudioCue, AudioManager, SoundEmitters)

The repo contains extensive audio infrastructure (AudioCue_Component.png, AudioManager.png, SoundEmitters_Pool.png) and related code in UOP1_Project/Assets, but there is no corresponding CONTRIBUTING.md section or dedicated Wiki page explaining the audio architecture. New contributors cannot easily understand how to implement audio in the game. This is a high-value PR that bridges the gap between visual diagrams in Docs/WikiImages and actual code usage.

• [ ] Create Docs/AUDIO_SYSTEM.md documenting AudioManager, AudioCue types (RandomSFX, CompositeSFX), and SoundEmitters pool pattern
• [ ] Add code examples showing how to configure and use AudioCue components with reference to Assets code
• [ ] Include setup instructions referencing the BakingSettings.png and AudioConfig.png diagrams
• [ ] Link the new doc from CONTRIBUTING.md under a 'Systems Guide' section

Add Scene Architecture and Event System documentation with code examples

The Docs/WikiImages folder contains EventSystem_diagram.png and SceneArchitecture_diagram.jpg that visualize complex systems, but no accompanying markdown explains how to use RuntimeAnchors (RuntimeAnchors_Setup.jpg, RuntimeAnchors_Using.jpg) or the event system patterns. Contributors cannot easily implement new scenes or events without reverse-engineering the diagrams.

• [ ] Create Docs/SCENE_ARCHITECTURE.md explaining scene chunks, location hierarchy, and entrance/exit patterns with Asset folder references
• [ ] Create Docs/EVENT_SYSTEM.md documenting RuntimeAnchors usage, event flow, and how to wire up new game events
• [ ] Add practical code snippets showing how to register listeners and trigger events
• [ ] Update CONTRIBUTING.md to reference both new guides in a 'Core Systems' section

Document the State Machine and Combat system with AI behavior examples

StateMachine_diagram.jpg and TransitionTable_PigChef.png indicate a sophisticated state machine for NPC behavior, but no documentation explains the transition table concept or how to implement new character behaviors. The Combat.png screenshot suggests combat mechanics exist but are undocumented. New contributors interested in gameplay systems have no clear entry point.

• [ ] Create Docs/STATE_MACHINE_GUIDE.md explaining the transition table pattern used for PigChef and other NPCs
• [ ] Add Docs/COMBAT_SYSTEM.md documenting combat mechanics visible in Combat.png and how to add new combat abilities
• [ ] Include concrete examples of creating a new NPC state machine by referencing TransitionTable_PigChef_Actions.png
• [ ] Add a troubleshooting section referencing common state machine implementation errors

• Port shader system to URP/HDRP: The project uses built-in render pipeline (ShaderLab files). Create documentation or sample shaders showing how to adapt the custom shaders (64KB) to Universal Render Pipeline, which is now Unity's recommended pipeline. File to start: Assets/Shaders/ (implied by 64KB ShaderLab footprint).: medium: Unblocks modern Unity users from learning the architecture.
• Add unit tests for state machine transitions: TransitionTable_PigChef.png and StateMachine_diagram.jpg show the state system works, but no test coverage is evident in file list. Write NUnit tests for state transitions and action execution to validate the pattern.: small: Demonstrates testability of event-driven architecture to learners.
• Document Audio Manager pooling strategy with a walkthrough: AudioCue_Component.png, AudioCue_CompositeSFX.png, and SoundEmitters_Pool.png show the system but lack implementation details. Write a 500-word guide showing how to queue sounds and reuse emitters, with code snippets from Assets/Audio/.: small: Clarifies non-obvious pooling patterns for audio contributions.

The Chop Chop repository demonstrates a reasonable security posture for a Unity game project. Primary concerns are: (1) third-party DLL dependencies without transparent version management, (2) project being unmaintained since December 2021, and (3) lack of visible dependency lock files. The codebase structure shows no obvious injection vulnerabilities, hardcoded secrets, or exposed credentials in the visible file structure. No Docker/infrastructure misconfigurations are evident. However, the bundled binary dependencies and lack of maintenance warrant caution if this codebase is used as a basis for production projects.

• Medium · Third-party DLL Dependency Without Version Pinning — UOP1_Project/Assets/Addons/DOTween/DOTween.dll and DOTweenEditor.dll. The project includes DOTween.dll (a third-party animation library) as a compiled binary without visible version control or integrity verification. Binary dependencies are harder to audit and may contain vulnerabilities. The presence of compiled DLLs (.dll files) in the repository without clear version documentation or checksum verification poses a supply chain risk. Fix: Use NuGet packages or Unity Package Manager instead of bundled DLLs when possible. Document the exact version of DOTween being used. Implement checksum verification for binary dependencies. Consider using Software Bill of Materials (SBOM) for tracking dependencies.
• Low · Missing Security Headers Configuration — Repository root configuration. No evidence of security headers configuration (.htaccess, web.config, or equivalent) for web-based content delivery. While this is a Unity game project, if any web-based distribution is planned, security headers would be missing. Fix: If planning to host any web content, implement security headers like Content-Security-Policy, X-Frame-Options, X-Content-Type-Options, and Strict-Transport-Security.
• Low · No Dependency Lock File Detected — UOP1_Project root. No package-lock.json, yarn.lock, or equivalent lock file is visible in the repository structure for dependency version pinning. This may allow inconsistent dependency versions across different builds. Fix: Implement and commit dependency lock files to ensure reproducible builds. For Unity projects, ensure manifest.json files are properly versioned.
• Low · Project Status - Unmaintained Codebase — README.md. The README explicitly states: 'As of December 2021, Open Projects and Chop Chop are not in development anymore.' An unmaintained project may accumulate security vulnerabilities in dependencies over time without patches being applied. Fix: If this project is used as a learning resource or template, document that it is legacy code. Conduct regular security audits if any components are reused. Consider archiving the repository if not actively maintained.

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.