john/Backyard-CTF
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(core): implement playable CTF prototype with 6 core scripts

Browse Source 
Implements the minimal playable core for the teaser prototype:
- Game.cs: Bootstrap, scene setup, scoring, round reset, win condition
- Unit.cs: Movement, route following, tagging, respawn
- RouteDrawer.cs: Click-drag route input with LineRenderer preview
- Flag.cs: Pickup, drop, return mechanics
- Visibility.cs: Fog of war via SpriteRenderer visibility
- SimpleAI.cs: Enemy AI that chases player flag

All game objects created programmatically (no Editor setup required).
Uses RuntimeInitializeOnLoadMethod for automatic bootstrap.

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
John Lamb
2026-02-01 21:03:11 -06:00
parent b1b3e4d0b3
commit 95b37a1606
8 changed files with 1405 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
Backyard CTF/Assets/Scripts/Flag.cs Normal file
View File

@@ -0,0 +1,97 @@
using System.Collections;
using UnityEngine;
public class Flag : MonoBehaviour
{
public Unit.Team team;
public Transform homePosition;
public Unit carriedBy;
float dropTimer;
bool isDropped;
Coroutine returnCoroutine;
void Update()
{
if (carriedBy != null)
{
// Follow carrier
transform.position = carriedBy.transform.position + new Vector3(0.3f, 0.3f, 0);
}
}
public void Pickup(Unit unit)
{
if (carriedBy != null) return;
// Cancel return timer if picking up dropped flag
if (returnCoroutine != null)
{
StopCoroutine(returnCoroutine);
returnCoroutine = null;
}
carriedBy = unit;
unit.hasFlag = true;
isDropped = false;
Debug.Log($"{unit.team} picked up {team} flag!");
}
public void Drop()
{
if (carriedBy == null) return;
carriedBy.hasFlag = false;
carriedBy = null;
isDropped = true;
Debug.Log($"{team} flag dropped!");
// Start return timer
returnCoroutine = StartCoroutine(ReturnAfterDelay());
}
IEnumerator ReturnAfterDelay()
{
yield return new WaitForSeconds(Game.FlagReturnDelay);
if (isDropped && carriedBy == null)
{
ReturnHome();
}
}
public void ReturnHome()
{
if (returnCoroutine != null)
{
StopCoroutine(returnCoroutine);
returnCoroutine = null;
}
if (carriedBy != null)
{
carriedBy.hasFlag = false;
carriedBy = null;
}
transform.position = homePosition.position;
isDropped = false;
Debug.Log($"{team} flag returned home!");
}
void OnTriggerEnter2D(Collider2D other)
{
// If flag is dropped and a friendly unit touches it, return it home immediately
if (isDropped && carriedBy == null)
{
var unit = other.GetComponent<Unit>();
if (unit != null && unit.team == team && !unit.isTaggedOut)
{
ReturnHome();
}
}
}
}

388
Backyard CTF/Assets/Scripts/Game.cs Normal file
View File

@@ -0,0 +1,388 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TMPro;
public class Game : MonoBehaviour
{
// Auto-bootstrap when game starts - no Editor setup needed
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
static void Bootstrap()
{
if (Instance != null) return;
var gameGO = new GameObject("Game");
gameGO.AddComponent<Game>();
}
// Constants - tune later
public const float UnitSpeed = 5f;
public const float VisionRadius = 4f;
public const float TagRadius = 0.75f;
public const float RespawnDelay = 3f;
public const float FlagReturnDelay = 5f;
public const int WinScore = 3;
// Map dimensions
const float MapWidth = 40f;
const float MapHeight = 30f;
// References set during setup
public static Game Instance { get; private set; }
public List<Unit> playerUnits = new();
public List<Unit> enemyUnits = new();
public Transform playerBase;
public Transform enemyBase;
public Flag playerFlag;
public Flag enemyFlag;
int playerScore;
int enemyScore;
bool gameOver;
TextMeshProUGUI scoreText;
TextMeshProUGUI gameOverText;
void Awake()
{
Instance = this;
}
void Start()
{
SetupCamera();
CreateGround();
CreateObstacles();
CreateBases();
CreateFlags();
SpawnUnits();
CreateUI();
SetupSystems();
}
void SetupCamera()
{
var cam = Camera.main;
if (cam != null)
{
cam.orthographic = true;
cam.orthographicSize = MapHeight / 2f + 2f;
cam.transform.position = new Vector3(0, 0, -10);
}
}
void CreateGround()
{
var ground = CreateSprite("Ground", new Color(0.2f, 0.4f, 0.2f), MapWidth, MapHeight);
ground.transform.position = Vector3.zero;
var sr = ground.GetComponent<SpriteRenderer>();
sr.sortingOrder = -10;
}
void CreateObstacles()
{
// Houses as obstacles - asymmetric backyard layout
Vector2[] housePositions = {
new(-12f, 8f),
new(-8f, -5f),
new(0f, 3f),
new(5f, -8f),
new(10f, 6f),
new(14f, -3f),
};
Vector2[] houseSizes = {
new(4f, 3f),
new(3f, 4f),
new(5f, 2.5f),
new(3f, 3f),
new(4f, 4f),
new(3.5f, 3f),
};
for (int i = 0; i < housePositions.Length; i++)
{
var house = CreateSprite($"House_{i}", new Color(0.4f, 0.4f, 0.4f), houseSizes[i].x, houseSizes[i].y);
house.transform.position = new Vector3(housePositions[i].x, housePositions[i].y, 0);
var collider = house.AddComponent<BoxCollider2D>();
// Size is (1,1) in local space - scale handles actual size
collider.size = Vector2.one;
var sr = house.GetComponent<SpriteRenderer>();
sr.sortingOrder = -5;
}
}
void CreateBases()
{
// Player base - bottom left
var playerBaseGO = CreateSprite("PlayerBase", new Color(0.2f, 0.3f, 0.8f, 0.5f), 6f, 6f);
playerBaseGO.transform.position = new Vector3(-MapWidth / 2f + 5f, -MapHeight / 2f + 5f, 0);
playerBase = playerBaseGO.transform;
var sr1 = playerBaseGO.GetComponent<SpriteRenderer>();
sr1.sortingOrder = -8;
var playerBaseTrigger = playerBaseGO.AddComponent<BoxCollider2D>();
playerBaseTrigger.isTrigger = true;
playerBaseTrigger.size = Vector2.one; // Local space - scale handles actual size
var playerBaseZone = playerBaseGO.AddComponent<BaseZone>();
playerBaseZone.team = Unit.Team.Player;
// Enemy base - top right
var enemyBaseGO = CreateSprite("EnemyBase", new Color(0.8f, 0.2f, 0.2f, 0.5f), 6f, 6f);
enemyBaseGO.transform.position = new Vector3(MapWidth / 2f - 5f, MapHeight / 2f - 5f, 0);
enemyBase = enemyBaseGO.transform;
var sr2 = enemyBaseGO.GetComponent<SpriteRenderer>();
sr2.sortingOrder = -8;
var enemyBaseTrigger = enemyBaseGO.AddComponent<BoxCollider2D>();
enemyBaseTrigger.isTrigger = true;
enemyBaseTrigger.size = Vector2.one; // Local space - scale handles actual size
var enemyBaseZone = enemyBaseGO.AddComponent<BaseZone>();
enemyBaseZone.team = Unit.Team.Enemy;
}
void CreateFlags()
{
// Player flag at player base
var playerFlagGO = CreateSprite("PlayerFlag", new Color(0.3f, 0.5f, 1f), 1f, 1.5f);
playerFlagGO.transform.position = playerBase.position;
playerFlag = playerFlagGO.AddComponent<Flag>();
playerFlag.team = Unit.Team.Player;
playerFlag.homePosition = playerBase;
var flagCollider1 = playerFlagGO.AddComponent<CircleCollider2D>();
flagCollider1.isTrigger = true;
flagCollider1.radius = 0.75f;
var rb1 = playerFlagGO.AddComponent<Rigidbody2D>();
rb1.bodyType = RigidbodyType2D.Kinematic;
var sr1 = playerFlagGO.GetComponent<SpriteRenderer>();
sr1.sortingOrder = 5;
// Enemy flag at enemy base
var enemyFlagGO = CreateSprite("EnemyFlag", new Color(1f, 0.3f, 0.3f), 1f, 1.5f);
enemyFlagGO.transform.position = enemyBase.position;
enemyFlag = enemyFlagGO.AddComponent<Flag>();
enemyFlag.team = Unit.Team.Enemy;
enemyFlag.homePosition = enemyBase;
var flagCollider2 = enemyFlagGO.AddComponent<CircleCollider2D>();
flagCollider2.isTrigger = true;
flagCollider2.radius = 0.75f;
var rb2 = enemyFlagGO.AddComponent<Rigidbody2D>();
rb2.bodyType = RigidbodyType2D.Kinematic;
var sr2 = enemyFlagGO.GetComponent<SpriteRenderer>();
sr2.sortingOrder = 5;
}
void SpawnUnits()
{
// Spawn 5 player units near player base
for (int i = 0; i < 5; i++)
{
var offset = new Vector3((i - 2) * 1.5f, -2f, 0);
var unit = CreateUnit($"PlayerUnit_{i}", Unit.Team.Player, playerBase.position + offset);
playerUnits.Add(unit);
}
// Spawn 5 enemy units near enemy base
for (int i = 0; i < 5; i++)
{
var offset = new Vector3((i - 2) * 1.5f, 2f, 0);
var unit = CreateUnit($"EnemyUnit_{i}", Unit.Team.Enemy, enemyBase.position + offset);
enemyUnits.Add(unit);
}
}
Unit CreateUnit(string name, Unit.Team team, Vector3 position)
{
Color color = team == Unit.Team.Player ? new Color(0.3f, 0.5f, 1f) : new Color(1f, 0.3f, 0.3f);
var unitGO = CreateSprite(name, color, 1f, 1f);
unitGO.transform.position = position;
var unit = unitGO.AddComponent<Unit>();
unit.team = team;
var collider = unitGO.AddComponent<CircleCollider2D>();
collider.isTrigger = true;
collider.radius = 0.5f;
var rb = unitGO.AddComponent<Rigidbody2D>();
rb.bodyType = RigidbodyType2D.Kinematic;
var sr = unitGO.GetComponent<SpriteRenderer>();
sr.sortingOrder = 10;
return unit;
}
void CreateUI()
{
// Create Canvas
var canvasGO = new GameObject("Canvas");
var canvas = canvasGO.AddComponent<Canvas>();
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
canvasGO.AddComponent<UnityEngine.UI.CanvasScaler>();
canvasGO.AddComponent<UnityEngine.UI.GraphicRaycaster>();
// Score text
var scoreGO = new GameObject("ScoreText");
scoreGO.transform.SetParent(canvasGO.transform, false);
scoreText = scoreGO.AddComponent<TextMeshProUGUI>();
scoreText.text = "0 - 0";
scoreText.fontSize = 48;
scoreText.alignment = TextAlignmentOptions.Center;
scoreText.color = Color.white;
var scoreRect = scoreGO.GetComponent<RectTransform>();
scoreRect.anchorMin = new Vector2(0.5f, 1f);
scoreRect.anchorMax = new Vector2(0.5f, 1f);
scoreRect.pivot = new Vector2(0.5f, 1f);
scoreRect.anchoredPosition = new Vector2(0, -20);
scoreRect.sizeDelta = new Vector2(200, 60);
// Game over text (hidden initially)
var gameOverGO = new GameObject("GameOverText");
gameOverGO.transform.SetParent(canvasGO.transform, false);
gameOverText = gameOverGO.AddComponent<TextMeshProUGUI>();
gameOverText.text = "";
gameOverText.fontSize = 72;
gameOverText.alignment = TextAlignmentOptions.Center;
gameOverText.color = Color.white;
gameOverText.gameObject.SetActive(false);
var gameOverRect = gameOverGO.GetComponent<RectTransform>();
gameOverRect.anchorMin = new Vector2(0.5f, 0.5f);
gameOverRect.anchorMax = new Vector2(0.5f, 0.5f);
gameOverRect.pivot = new Vector2(0.5f, 0.5f);
gameOverRect.anchoredPosition = Vector2.zero;
gameOverRect.sizeDelta = new Vector2(400, 100);
}
void SetupSystems()
{
// Add RouteDrawer
gameObject.AddComponent<RouteDrawer>();
// Add Visibility system
var visibility = gameObject.AddComponent<Visibility>();
visibility.playerUnits = playerUnits.ToArray();
visibility.enemyUnits = enemyUnits.ToArray();
visibility.enemyFlag = enemyFlag;
// Add SimpleAI
var ai = gameObject.AddComponent<SimpleAI>();
ai.aiUnits = enemyUnits.ToArray();
ai.playerFlag = playerFlag;
ai.aiBase = enemyBase;
}
public void Score(Unit.Team team)
{
if (gameOver) return;
if (team == Unit.Team.Player)
playerScore++;
else
enemyScore++;
UpdateScoreUI();
Debug.Log($"Score: {playerScore} - {enemyScore}");
if (playerScore >= WinScore)
EndGame(true);
else if (enemyScore >= WinScore)
EndGame(false);
else
ResetRound();
}
void UpdateScoreUI()
{
if (scoreText != null)
scoreText.text = $"{playerScore} - {enemyScore}";
}
void ResetRound()
{
// Return flags to home
playerFlag.ReturnHome();
enemyFlag.ReturnHome();
// Respawn all units at bases
for (int i = 0; i < playerUnits.Count; i++)
{
var offset = new Vector3((i - 2) * 1.5f, -2f, 0);
playerUnits[i].ForceRespawn(playerBase.position + offset);
}
for (int i = 0; i < enemyUnits.Count; i++)
{
var offset = new Vector3((i - 2) * 1.5f, 2f, 0);
enemyUnits[i].ForceRespawn(enemyBase.position + offset);
}
}
void EndGame(bool playerWon)
{
gameOver = true;
if (gameOverText != null)
{
gameOverText.text = playerWon ? "YOU WIN!" : "YOU LOSE!";
gameOverText.color = playerWon ? Color.green : Color.red;
gameOverText.gameObject.SetActive(true);
}
Debug.Log(playerWon ? "Player wins!" : "Enemy wins!");
}
public Transform GetBase(Unit.Team team)
{
return team == Unit.Team.Player ? playerBase : enemyBase;
}
public Flag GetFlag(Unit.Team team)
{
return team == Unit.Team.Player ? playerFlag : enemyFlag;
}
// Helper to create a colored sprite
GameObject CreateSprite(string name, Color color, float width, float height)
{
var go = new GameObject(name);
var sr = go.AddComponent<SpriteRenderer>();
sr.sprite = CreateRectSprite();
sr.color = color;
go.transform.localScale = new Vector3(width, height, 1);
return go;
}
// Create a simple white 1x1 sprite
static Sprite cachedSprite;
static Sprite CreateRectSprite()
{
if (cachedSprite != null) return cachedSprite;
var tex = new Texture2D(1, 1);
tex.SetPixel(0, 0, Color.white);
tex.Apply();
cachedSprite = Sprite.Create(tex, new Rect(0, 0, 1, 1), new Vector2(0.5f, 0.5f), 1);
return cachedSprite;
}
}
// Simple component to identify base zones
public class BaseZone : MonoBehaviour
{
public Unit.Team team;
}

147
Backyard CTF/Assets/Scripts/RouteDrawer.cs Normal file
View File

@@ -0,0 +1,147 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.InputSystem;
public class RouteDrawer : MonoBehaviour
{
Unit selectedUnit;
List<Vector2> currentRoute = new();
LineRenderer lineRenderer;
bool isDrawing;
const float MinPointDistance = 0.5f;
void Start()
{
CreateLineRenderer();
}
void CreateLineRenderer()
{
var lineGO = new GameObject("RouteLine");
lineRenderer = lineGO.AddComponent<LineRenderer>();
lineRenderer.startWidth = 0.15f;
lineRenderer.endWidth = 0.15f;
lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
lineRenderer.startColor = new Color(1f, 1f, 1f, 0.5f);
lineRenderer.endColor = new Color(1f, 1f, 1f, 0.5f);
lineRenderer.sortingOrder = 20;
lineRenderer.positionCount = 0;
}
void Update()
{
var mouse = Mouse.current;
var touch = Touchscreen.current;
// Handle mouse input
if (mouse != null)
{
HandlePointerInput(
mouse.leftButton.wasPressedThisFrame,
mouse.leftButton.wasReleasedThisFrame,
mouse.leftButton.isPressed,
mouse.position.ReadValue()
);
}
// Handle touch input
else if (touch != null && touch.primaryTouch.press.isPressed)
{
var primaryTouch = touch.primaryTouch;
HandlePointerInput(
primaryTouch.press.wasPressedThisFrame,
primaryTouch.press.wasReleasedThisFrame,
primaryTouch.press.isPressed,
primaryTouch.position.ReadValue()
);
}
}
void HandlePointerInput(bool pressed, bool released, bool held, Vector2 screenPos)
{
Vector2 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
if (pressed)
{
OnPointerDown(worldPos);
}
else if (released)
{
OnPointerUp();
}
else if (held && isDrawing)
{
OnPointerDrag(worldPos);
}
}
void OnPointerDown(Vector2 worldPos)
{
// Check if we clicked on a player unit
var hit = Physics2D.OverlapPoint(worldPos);
if (hit != null)
{
var unit = hit.GetComponent<Unit>();
if (unit != null && unit.team == Unit.Team.Player && !unit.isTaggedOut)
{
selectedUnit = unit;
isDrawing = true;
currentRoute.Clear();
currentRoute.Add(worldPos);
UpdateLineRenderer();
}
}
}
void OnPointerDrag(Vector2 worldPos)
{
if (!isDrawing || selectedUnit == null) return;
// Only add point if far enough from last point
if (currentRoute.Count > 0)
{
float dist = Vector2.Distance(currentRoute[currentRoute.Count - 1], worldPos);
if (dist >= MinPointDistance)
{
currentRoute.Add(worldPos);
UpdateLineRenderer();
}
}
}
void OnPointerUp()
{
if (isDrawing && selectedUnit != null && currentRoute.Count > 0)
{
// Remove the first point (unit's current position) and apply route
if (currentRoute.Count > 1)
{
currentRoute.RemoveAt(0);
}
selectedUnit.SetRoute(currentRoute);
}
// Clear drawing state
isDrawing = false;
selectedUnit = null;
currentRoute.Clear();
ClearLineRenderer();
}
void UpdateLineRenderer()
{
if (lineRenderer == null) return;
lineRenderer.positionCount = currentRoute.Count;
for (int i = 0; i < currentRoute.Count; i++)
{
lineRenderer.SetPosition(i, new Vector3(currentRoute[i].x, currentRoute[i].y, 0));
}
}
void ClearLineRenderer()
{
if (lineRenderer == null) return;
lineRenderer.positionCount = 0;
}
}

70
Backyard CTF/Assets/Scripts/SimpleAI.cs Normal file
View File

@@ -0,0 +1,70 @@
using System.Collections.Generic;
using UnityEngine;
public class SimpleAI : MonoBehaviour
{
public Unit[] aiUnits;
public Flag playerFlag;
public Transform aiBase;
float decisionTimer;
const float DecisionInterval = 0.5f;
const float RandomOffset = 1.5f;
void Update()
{
decisionTimer -= Time.deltaTime;
if (decisionTimer <= 0)
{
MakeDecisions();
decisionTimer = DecisionInterval;
}
}
void MakeDecisions()
{
if (playerFlag == null || aiBase == null) return;
for (int i = 0; i < aiUnits.Length; i++)
{
var unit = aiUnits[i];
if (unit == null || unit.isTaggedOut) continue;
Vector2 target;
if (unit.hasFlag)
{
// Has flag - return to base
target = aiBase.position;
}
else if (playerFlag.carriedBy != null && playerFlag.carriedBy.team == Unit.Team.Enemy)
{
// Friendly unit has flag - escort or find something else to do
// For now, just patrol near own base
target = (Vector2)aiBase.position + Random.insideUnitCircle * 5f;
}
else if (playerFlag.carriedBy != null)
{
// Player has our flag - chase the carrier
target = playerFlag.carriedBy.transform.position;
}
else
{
// Flag is at home or dropped - go for it
target = playerFlag.transform.position;
}
// Add slight randomness to prevent all units clumping
Vector2 randomOffset = Random.insideUnitCircle * RandomOffset;
// Offset based on unit index for some spread
float angle = (i / (float)aiUnits.Length) * Mathf.PI * 2f;
Vector2 spreadOffset = new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * 1f;
Vector2 finalTarget = target + randomOffset * 0.5f + spreadOffset;
// Simple route: straight line to target
unit.SetRoute(new List<Vector2> { finalTarget });
}
}
}

231
Backyard CTF/Assets/Scripts/Unit.cs Normal file
View File

@@ -0,0 +1,231 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Unit : MonoBehaviour
{
public enum Team { Player, Enemy }
public Team team;
public bool isTaggedOut;
public bool hasFlag;
List<Vector2> route = new();
int routeIndex;
bool isMoving;
SpriteRenderer spriteRenderer;
CircleCollider2D circleCollider;
void Awake()
{
spriteRenderer = GetComponent<SpriteRenderer>();
circleCollider = GetComponent<CircleCollider2D>();
}
void Update()
{
if (isTaggedOut || !isMoving || route.Count == 0) return;
FollowRoute();
}
void FollowRoute()
{
if (routeIndex >= route.Count)
{
isMoving = false;
return;
}
Vector2 target = route[routeIndex];
Vector2 current = transform.position;
Vector2 direction = (target - current).normalized;
float distance = Vector2.Distance(current, target);
// Check for obstacles ahead
if (IsObstacleAhead(direction))
{
isMoving = false;
return;
}
float moveDistance = Game.UnitSpeed * Time.deltaTime;
if (moveDistance >= distance)
{
// Reached waypoint
transform.position = new Vector3(target.x, target.y, 0);
routeIndex++;
if (routeIndex >= route.Count)
{
isMoving = false;
}
}
else
{
// Move toward waypoint
Vector2 newPos = current + direction * moveDistance;
transform.position = new Vector3(newPos.x, newPos.y, 0);
}
}
bool IsObstacleAhead(Vector2 direction)
{
// Raycast to check for obstacles (non-trigger colliders)
var hits = Physics2D.RaycastAll(transform.position, direction, 0.6f);
foreach (var hit in hits)
{
if (hit.collider != null && hit.collider.gameObject != gameObject && !hit.collider.isTrigger)
{
return true;
}
}
return false;
}
public void SetRoute(List<Vector2> waypoints)
{
if (isTaggedOut) return;
route = new List<Vector2>(waypoints);
routeIndex = 0;
isMoving = route.Count > 0;
}
public void ClearRoute()
{
route.Clear();
routeIndex = 0;
isMoving = false;
}
void OnTriggerEnter2D(Collider2D other)
{
if (isTaggedOut) return;
// Check for enemy unit collision (tagging)
var otherUnit = other.GetComponent<Unit>();
if (otherUnit != null && otherUnit.team != team && !otherUnit.isTaggedOut)
{
HandleTagCollision(otherUnit);
return;
}
// Check for flag pickup
var flag = other.GetComponent<Flag>();
if (flag != null && flag.team != team && flag.carriedBy == null)
{
flag.Pickup(this);
return;
}
// Check for scoring (reaching own base with enemy flag)
var baseZone = other.GetComponent<BaseZone>();
if (baseZone != null && baseZone.team == team && hasFlag)
{
// Get the flag we're carrying
var carriedFlag = team == Team.Player ? Game.Instance.enemyFlag : Game.Instance.playerFlag;
if (carriedFlag != null && carriedFlag.carriedBy == this)
{
carriedFlag.Drop();
Game.Instance.Score(team);
}
}
}
void HandleTagCollision(Unit other)
{
// Determine who gets tagged: farther from their own base loses
Transform myBase = Game.Instance.GetBase(team);
Transform theirBase = Game.Instance.GetBase(other.team);
float myDistance = Vector2.Distance(transform.position, myBase.position);
float theirDistance = Vector2.Distance(other.transform.position, theirBase.position);
if (myDistance > theirDistance)
{
TagOut();
}
else if (theirDistance > myDistance)
{
other.TagOut();
}
else
{
// Equal distance - both get tagged (more chaos!)
TagOut();
other.TagOut();
}
}
public void TagOut()
{
if (isTaggedOut) return;
isTaggedOut = true;
isMoving = false;
route.Clear();
// Drop flag if carrying
if (hasFlag)
{
var flag = team == Team.Player ? Game.Instance.enemyFlag : Game.Instance.playerFlag;
if (flag != null && flag.carriedBy == this)
{
flag.Drop();
}
}
// Visual feedback - fade out
if (spriteRenderer != null)
{
var color = spriteRenderer.color;
color.a = 0.3f;
spriteRenderer.color = color;
}
StartCoroutine(RespawnCoroutine());
}
IEnumerator RespawnCoroutine()
{
yield return new WaitForSeconds(Game.RespawnDelay);
// Respawn at base
Transform baseTransform = Game.Instance.GetBase(team);
Vector3 offset = new Vector3(Random.Range(-2f, 2f), team == Team.Player ? -2f : 2f, 0);
transform.position = baseTransform.position + offset;
isTaggedOut = false;
// Restore visual
if (spriteRenderer != null)
{
var color = spriteRenderer.color;
color.a = 1f;
spriteRenderer.color = color;
}
}
public void ForceRespawn(Vector3 position)
{
StopAllCoroutines();
transform.position = position;
isTaggedOut = false;
isMoving = false;
route.Clear();
hasFlag = false;
if (spriteRenderer != null)
{
var color = spriteRenderer.color;
color.a = 1f;
spriteRenderer.color = color;
}
}
public bool IsMoving => isMoving;
public List<Vector2> CurrentRoute => route;
}

59
Backyard CTF/Assets/Scripts/Visibility.cs Normal file
View File

@@ -0,0 +1,59 @@
using UnityEngine;
public class Visibility : MonoBehaviour
{
public Unit[] playerUnits;
public Unit[] enemyUnits;
public Flag enemyFlag;
void Update()
{
// Update visibility of enemy units
foreach (var enemy in enemyUnits)
{
if (enemy == null) continue;
bool visible = IsVisibleToAnyPlayerUnit(enemy.transform.position);
var sr = enemy.GetComponent<SpriteRenderer>();
if (sr != null)
{
sr.enabled = visible || enemy.isTaggedOut; // Show tagged out units (they're faded anyway)
}
}
// Update visibility of enemy flag (only when not carried)
if (enemyFlag != null && enemyFlag.carriedBy == null)
{
bool flagVisible = IsVisibleToAnyPlayerUnit(enemyFlag.transform.position);
var flagSr = enemyFlag.GetComponent<SpriteRenderer>();
if (flagSr != null)
{
flagSr.enabled = flagVisible;
}
}
else if (enemyFlag != null && enemyFlag.carriedBy != null)
{
// Flag is carried - always show it (it's attached to a visible unit)
var flagSr = enemyFlag.GetComponent<SpriteRenderer>();
if (flagSr != null)
{
flagSr.enabled = true;
}
}
}
bool IsVisibleToAnyPlayerUnit(Vector2 position)
{
foreach (var unit in playerUnits)
{
if (unit == null || unit.isTaggedOut) continue;
float distance = Vector2.Distance(unit.transform.position, position);
if (distance < Game.VisionRadius)
{
return true;
}
}
return false;
}
}

67
docs/brainstorms/2026-02-01-teaser-prototype-brainstorm.md Normal file
View File

@@ -0,0 +1,67 @@
---
date: 2026-02-01
topic: teaser-prototype
---
# Teaser Prototype: Playable Game Core
## What We're Building
A minimal playable teaser that captures the "practiced chaos" of Neighborhood Quarterback - the Rocket League-style feeling where chaos has patterns you can learn to exploit.
**Scope:**
- 1v1 vs AI opponent
- 5 identical units per side
- Draw-routes for commanding units
- Tag-out respawn (captured units respawn at base after delay)
- Simple fog of war (see near your units only)
- Backyard-style asymmetric map with houses/fences
- First to 3 points (points for flag grab AND returning flag to base)
## Why This Approach
We chose **Minimal Playable Core** over polished slice or systems-first approaches because:
1. **Validate the feel first** - The soul doc's "practiced chaos" needs playtesting to verify
2. **Fast iteration** - Rough edges are fine if we can quickly change what matters
3. **Avoid over-engineering** - Don't build robust systems for unvalidated design
## Key Decisions
- **AI opponent over multiplayer**: Simpler to build, can playtest alone, control pacing
- **Draw routes over click-to-move**: More tactical, matches the "quarterback" command fantasy
- **Tag-out over jail escort**: Simpler first pass; jail escort adds complexity we can add later
- **Fog of war included**: Core to the mind game, worth the complexity
- **5 units (not 3)**: Matches soul doc, enables interesting squad tactics
- **All identical units**: No classes yet; focus on positioning/routes before differentiation
- **Asymmetric map**: Thematic "backyard" feel even if harder to balance
- **First to 3 with grab+return points**: Creates multiple scoring opportunities per round
## What Success Looks Like
When playing, you should see:
- Moments where you read the AI's pattern and exploit it
- Chaotic scrambles when plans collide
- "Almost had it" flag runs that feel learnable
- Fog reveal moments that create tension
## Out of Scope (For Now)
- Class differentiation (Sneak/Patrol/Speed)
- Jail escort mechanics
- Motion lights
- Pre-phase setup (placing flag/jail)
- Multiplayer networking
- Polish/juice/animations
## Open Questions for Planning
1. **Map layout**: What's the minimum topology for interesting play? Lanes, chokepoints, shortcuts?
2. **AI behavior**: How smart does AI need to be to create "practiced chaos"?
3. **Route-drawing UX**: Click-drag? Waypoints? How to visualize planned route?
4. **Fog implementation**: Tile-based? Raycast? Mesh-based reveal?
5. **Scoring flow**: What happens after a point? Reset positions? Continuous play?
## Next Steps
Run `/workflows:plan` to break this down into implementation tasks.

346
docs/plans/2026-02-01-feat-teaser-prototype-playable-core-plan.md Normal file
View File

@@ -0,0 +1,346 @@
---
title: "feat: Teaser Prototype Playable Core"
type: feat
date: 2026-02-01
revised: 2026-02-01
---
# Teaser Prototype: Playable Core (Simplified)
## Overview
Build a minimal playable 1v1 capture-the-flag teaser that captures the "practiced chaos" of Neighborhood Quarterback - where chaos has patterns you can learn to exploit, like Rocket League.
**Target experience:** Fast rounds with flag grabs, chases, tag-outs, and scrambles. Players should feel "I almost had it" and "I can learn this."
## Guiding Principle
**Build the skateboard, not the car chassis.** Get something playable in days, not weeks. Polish comes after validating the core loop is fun.
## Proposed Solution
6 scripts, 3 phases, ~15 tasks:
```
Assets/Scripts/
├── Game.cs # Score, reset, win, spawn
├── Unit.cs # Movement, state, respawn, flag carrying
├── RouteDrawer.cs # Click-drag to draw routes
├── Flag.cs # Pickup, drop, return
├── Visibility.cs # Simple sprite show/hide (no shaders)
└── SimpleAI.cs # Chase flag or flag carrier
```
No feature folders for MVP. No managers. Refactor when needed.
## Technical Decisions
| Decision | Choice | Rationale |
|----------|--------|-----------|
| Pathfinding | None | Draw route, unit follows, stops at obstacles |
| Fog of War | Sprite SetActive | Hide enemies outside vision radius. No shaders. |
| State | Bools/enums on scripts | No state machine frameworks |
| AI | One behavior | Chase player flag (or flag carrier) |
| Events | Direct method calls | No event bus for 6 scripts |
## Constants (Hardcoded, Tune Later)
```csharp
// In Game.cs - move to ScriptableObject if needed
const float UnitSpeed = 5f;
const float VisionRadius = 4f;
const float TagRadius = 0.75f;
const float RespawnDelay = 3f;
const float FlagReturnDelay = 5f;
const int WinScore = 3;
```
---
## Phase 1: Movement & Map (3-4 days)
**Goal:** Draw routes, units follow them, obstacles block.
### Tasks
- [x] **1.1** Create placeholder art in Main.unity:
- Green plane (ground, ~40x30 units)
- Gray rectangles (4-6 houses as obstacles with BoxCollider2D)
- Colored circles (units - blue team, red team)
- Two base zones (opposite corners)
- [x] **1.2** Create `Unit.cs`:
```csharp
public class Unit : MonoBehaviour
{
public enum Team { Player, Enemy }
public Team team;
public bool isTaggedOut;
public bool hasFlag;
List<Vector2> route;
int routeIndex;
public void SetRoute(List<Vector2> waypoints) { ... }
void Update() { /* follow route, stop at end */ }
public void TagOut() { /* disable, start respawn coroutine */ }
IEnumerator Respawn() { /* wait 3s, teleport to base, enable */ }
}
```
- [x] **1.3** Create `RouteDrawer.cs`:
- On mouse down over player unit: start route
- While dragging: collect points, draw LineRenderer preview
- On mouse up: call `unit.SetRoute(points)`
- Clear line after route applied
- [x] **1.4** Create `Game.cs` (partial):
```csharp
public class Game : MonoBehaviour
{
public Unit[] playerUnits; // Assign in inspector
public Unit[] enemyUnits;
public Transform playerBase;
public Transform enemyBase;
void Start() { SpawnUnits(); }
void SpawnUnits() { /* position 5 units at each base */ }
}
```
- [x] **1.5** Wire up scene:
- Create 5 Unit prefabs per team
- Add colliders to obstacles
- Test: draw route, unit follows, stops at obstacle
**Verification:**
- [ ] Can draw route on player unit, unit follows
- [ ] Unit stops when hitting obstacle
- [ ] Unit stops at end of route
- [ ] New route replaces old route
- [ ] Enemy units visible but not controllable
---
## Phase 2: Flag, Tagging, Scoring (2-3 days)
**Goal:** Grab flag, tag enemies, score points, win.
### Tasks
- [x] **2.1** Create `Flag.cs`:
```csharp
public class Flag : MonoBehaviour
{
public Unit.Team team;
public Transform homePosition;
public Unit carriedBy;
float dropTimer;
void Update()
{
if (carriedBy != null)
transform.position = carriedBy.transform.position;
else if (transform.position != homePosition.position)
HandleDroppedState();
}
public void Pickup(Unit unit) { carriedBy = unit; unit.hasFlag = true; }
public void Drop() { carriedBy.hasFlag = false; carriedBy = null; dropTimer = 5f; }
void ReturnHome() { transform.position = homePosition.position; }
}
```
- [x] **2.2** Add flag pickup detection:
- OnTriggerEnter2D: if enemy unit enters flag trigger, Pickup()
- In `Game.cs`: when unit with flag enters own base, Score()
- [x] **2.3** Add tagging to `Unit.cs`:
- OnTriggerEnter2D: if enemy unit overlaps
- Determine loser: farther from own base gets tagged
- (Or for more chaos: both get tagged)
- If tagged unit has flag, call flag.Drop()
- [x] **2.4** Add scoring to `Game.cs`:
```csharp
int playerScore, enemyScore;
public void Score(Unit.Team team)
{
if (team == Unit.Team.Player) playerScore++;
else enemyScore++;
Debug.Log($"Score: {playerScore} - {enemyScore}");
if (playerScore >= WinScore || enemyScore >= WinScore)
EndGame();
else
ResetRound();
}
void ResetRound()
{
// Return flags, respawn all units at bases
}
```
- [x] **2.5** Add simple UI:
- TextMeshPro showing score
- "YOU WIN" / "YOU LOSE" text on game end
- (No menu - press Play in editor)
**Verification:**
- [ ] Walking over enemy flag picks it up
- [ ] Flag follows carrier
- [ ] Reaching base with flag scores point
- [ ] Overlapping enemy triggers tag-out
- [ ] Tagged unit respawns after 3 seconds
- [ ] Dropped flag returns home after 5 seconds
- [ ] First to 3 wins
---
## Phase 3: Visibility & AI (2-3 days)
**Goal:** Can't see enemies outside vision range. AI provides opposition.
### Tasks
- [x] **3.1** Create `Visibility.cs`:
```csharp
public class Visibility : MonoBehaviour
{
public Unit[] playerUnits;
public Unit[] enemyUnits;
public Flag enemyFlag;
void Update()
{
foreach (var enemy in enemyUnits)
{
bool visible = IsVisibleToAnyPlayerUnit(enemy.transform.position);
enemy.GetComponent<SpriteRenderer>().enabled = visible;
}
// Also hide enemy flag if not carried and not visible
if (enemyFlag.carriedBy == null)
enemyFlag.GetComponent<SpriteRenderer>().enabled =
IsVisibleToAnyPlayerUnit(enemyFlag.transform.position);
}
bool IsVisibleToAnyPlayerUnit(Vector2 pos)
{
foreach (var unit in playerUnits)
{
if (unit.isTaggedOut) continue;
if (Vector2.Distance(unit.transform.position, pos) < VisionRadius)
return true;
}
return false;
}
}
```
- [x] **3.2** Create `SimpleAI.cs`:
```csharp
public class SimpleAI : MonoBehaviour
{
public Unit[] aiUnits;
public Flag playerFlag;
public Transform aiBase;
float decisionTimer;
void Update()
{
decisionTimer -= Time.deltaTime;
if (decisionTimer <= 0)
{
MakeDecisions();
decisionTimer = 0.5f; // Decide every 0.5s
}
}
void MakeDecisions()
{
foreach (var unit in aiUnits)
{
if (unit.isTaggedOut) continue;
Vector2 target;
if (unit.hasFlag)
target = aiBase.position; // Return flag
else if (playerFlag.carriedBy != null)
target = playerFlag.carriedBy.transform.position; // Chase carrier
else
target = playerFlag.transform.position; // Go for flag
// Simple route: straight line to target
unit.SetRoute(new List<Vector2> { target });
}
}
}
```
- [x] **3.3** Add slight route randomness:
- Offset target by small random amount
- Prevents all AI units clumping perfectly
- [x] **3.4** Playtest & tune:
- Adjust VisionRadius, TagRadius, speeds
- Make AI beatable but not trivial
**Verification:**
- [ ] Enemy units hidden when far from player units
- [ ] Enemies appear when player unit gets close
- [ ] AI units move toward player flag
- [ ] AI chases player flag carrier
- [ ] AI returns flag to base when carrying
- [ ] Can beat AI after 2-3 attempts
---
## Acceptance Criteria (MVP)
- [ ] Game starts with 5 units per side at bases
- [ ] Draw route on unit, unit follows path
- [ ] Unit stops at obstacles
- [ ] Grabbing enemy flag awards 1 point
- [ ] Returning flag to base (with own flag present) awards 1 more point
- [ ] Overlapping enemies triggers tag-out (farther from base loses)
- [ ] Tagged units respawn at base after 3 seconds
- [ ] Enemies only visible within vision radius of player units
- [ ] AI controls enemy team, chases flag
- [ ] First to 3 points wins
---
## Out of Scope (v2)
- Shader-based fog of war (smooth edges, feathering)
- Unit classes (Sneak/Patrol/Speed)
- Jail escort mechanics
- Motion lights
- Pre-phase setup
- Multiplayer
- AI with strategic roles
- Route obstacle preview
- Audio
- Main menu
- Mobile optimization
---
## What We're Testing
This prototype answers one question: **Is commanding units in CTF fun?**
If yes → Add fog polish, AI strategy, classes
If no → Revisit core mechanics before adding complexity
---
## References
- Soul Doc: `soul.md`
- Brainstorm: `docs/brainstorms/2026-02-01-teaser-prototype-brainstorm.md`
- Input actions: `Assets/Settings/Input/GameInputActions.inputactions`