updates

.gitignore

@@ -1,3 +1,4 @@
 *.env
 *.venv/
-*pycache_*/
+*pycache_*/
+.agents/

api.py

@@ -23,6 +23,8 @@ class StartGameRequest(BaseModel):
     max_agents: int = 8
     num_chests: int = 15
     agent_names: list[str] | None = None
+    system_prompt: str | None = None
+    system_prompts: dict[str, str] | None = None
 
 
 def _serialize(aid: str) -> dict:
@@ -80,8 +82,8 @@ def _game_state() -> dict:
 
 
 BOT_NAMES = [
-    "Vex", "Nyx", "Zara", "Kael",
-    "Rook", "Lyra", "Orin", "Sage",
+    "Leo", "Sam", "Mia", "Alex",
+    "Zoe", "Kai", "Toby", "Zane",
 ]
 
 
@@ -106,7 +108,13 @@ async def start_game(req: StartGameRequest):
     for i, name in enumerate(names):
         if i >= req.max_agents:
             break
-        engine.spawn_agent(agent_id=f"agent_{i}", name=name)
+        aid = f"agent_{i}"
+        prompt = None
+        if req.system_prompts:
+            prompt = req.system_prompts.get(aid) or req.system_prompts.get(name)
+        if not prompt:
+            prompt = req.system_prompt
+        engine.spawn_agent(agent_id=aid, name=name, system_prompt=prompt)
 
     return {"message": f"Game started with {len(names)} agents", "turn": 0}
 
@@ -143,7 +151,19 @@ async def run_full_game(req: StartGameRequest):
     for i, name in enumerate(names):
         if i >= req.max_agents:
             break
-        engine.spawn_agent(agent_id=f"agent_{i}", name=name)
+        aid = f"agent_{i}"
+        prompt = None
+        if req.system_prompts:
+            prompt = req.system_prompts.get(aid) or req.system_prompts.get(name)
+        if not prompt:
+            prompt = req.system_prompt
+        engine.spawn_agent(agent_id=aid, name=name, system_prompt=prompt)
 
     await engine.run_game()
     return _game_state()
+
+
+@app.get("/api/game/default_prompt")
+def get_default_prompt(grid_size: int = 20):
+    from backend.agent.agent import Agent
+    return {"default_prompt": Agent.get_default_system_prompt(grid_size=grid_size)}

backend/agent/agent.py

@@ -26,26 +26,32 @@ class Agent:
         if system_prompt:
             self.system_prompt = system_prompt
         else:
-            gs = config.grid_size if config else 20
-            kill_sc = config.kill_score if config else 150
-            srv_sc = config.survival_score_per_turn if config else 1
-            att_dmg = config.attack_damage if config else 35
-            att_rng = config.attack_range if config else 2
-            
-            self.system_prompt = (
-                "You are a competitive AI agent in a grid-based battle royale game on a "
-                f"{gs}x{gs} grid. "
-                "Your goal is to maximize your score and be the last agent standing by eliminating others, collecting loot, and surviving.\n"
-                "CRITICAL STRATEGIC RULES:\n"
-                "1. ALWAYS call observe() at the start of your turn to get details on your HP, abilities, cooldowns, nearby tiles with loot, and visible agents.\n"
-                f"2. SCORING: Eliminating an agent yields +{kill_sc} points. Surviving only gives +{srv_sc} point(s) per turn. Passive play will lose. Actively hunt other agents, especially those with low HP.\n"
-                "3. ABILITIES: Walk over tiles marked with '[has loot]' to automatically collect them. Once acquired, activate them using activate_ability(ability, args):\n"
-                f"   - 'attack': args={{'x': target_x, 'y': target_y}}. Attack an agent within {att_rng} tiles (Manhattan distance <= {att_rng}) for {att_dmg} damage. If they are shielded, their shield breaks instead. Focus fire to eliminate them!\n"
-                "   - 'dash': args={{'dx': dx, 'dy': dy}}. Teleport up to 3 tiles (dx/dy between -3 and 3) to chase agents, escape, or grab loot.\n"
-                "   - 'shield': args={}. Activate a shield to completely block the next incoming attack.\n"
-                "   - 'heal': args={}. Restore 40 HP when your health is low.\n"
-                "4. MOVE: Use move(dx, dy) to move 1 step to an adjacent tile (dx/dy in -1, 0, 1) and automatically pick up any loot on that tile."
-            )
+            self.system_prompt = self.get_default_system_prompt(config)
+
+    @staticmethod
+    def get_default_system_prompt(config: GameConfig | None = None, grid_size: int | None = None) -> str:
+        from backend.environment.config import GameConfig
+        cfg = config or GameConfig()
+        gs = grid_size if grid_size is not None else cfg.grid_size
+        kill_sc = cfg.kill_score
+        srv_sc = cfg.survival_score_per_turn
+        att_dmg = cfg.attack_damage
+        att_rng = cfg.attack_range
+        
+        return (
+            "You are a competitive AI agent in a grid-based battle royale game on a "
+            f"{gs}x{gs} grid. "
+            "Your goal is to maximize your score and be the last agent standing by eliminating others, collecting loot, and surviving.\n"
+            "CRITICAL STRATEGIC RULES:\n"
+            "1. ALWAYS call observe() at the start of your turn to get details on your HP, abilities, cooldowns, nearby tiles with loot, and visible agents.\n"
+            f"2. SCORING: Eliminating an agent yields +{kill_sc} points. Surviving only gives +{srv_sc} point(s) per turn. Passive play will lose. Actively hunt other agents, especially those with low HP.\n"
+            "3. ABILITIES: Walk over tiles marked with '[has loot]' to automatically collect them. Once acquired, activate them using activate_ability(ability, args):\n"
+            f"   - 'attack': args={{'x': target_x, 'y': target_y}}. Attack an agent within {att_rng} tiles (Manhattan distance <= {att_rng}) for {att_dmg} damage (3 uses). If they are shielded, their shield breaks instead. Focus fire to eliminate them!\n"
+            "   - 'dash': args={{'dx': dx, 'dy': dy}}. Teleport up to 3 tiles (dx/dy between -3 and 3) to chase agents, escape, or grab loot (3 uses).\n"
+            "   - 'shield': args={}. Activate a shield to completely block the next incoming attack (2 uses).\n"
+            "   - 'heal': args={}. Restore 40 HP when your health is low (2 uses).\n"
+            "4. MOVE: Use move(dx, dy) to move 1 step to an adjacent tile (dx/dy in -1, 0, 1) and automatically pick up any loot on that tile."
+        )
 
     async def decide(self, messages: list, tools: list[dict]) -> list[ToolCall]:
         import json

backend/environment/ability_registry.py

@@ -100,29 +100,29 @@ ABILITY_REGISTRY: dict[str, AbilityDef] = {
     "attack": AbilityDef(
         name="attack",
         cooldown=1,
-        max_uses=None,
-        description="Attack an agent within 2 tiles for 35 damage",
+        max_uses=3,
+        description="Attack an agent within 2 tiles for 35 damage (3 uses)",
         handler=attack_handler,
     ),
     "dash": AbilityDef(
         name="dash",
         cooldown=2,
         max_uses=3,
-        description="Teleport up to 3 tiles in a direction",
+        description="Teleport up to 3 tiles in a direction (3 uses)",
         handler=dash_handler,
     ),
     "shield": AbilityDef(
         name="shield",
         cooldown=3,
-        max_uses=None,
-        description="Become immune to the next attack",
+        max_uses=2,
+        description="Become immune to the next attack (2 uses)",
         handler=shield_handler,
     ),
     "heal": AbilityDef(
         name="heal",
         cooldown=2,
         max_uses=2,
-        description="Restore 40 HP",
+        description="Restore 40 HP (2 uses)",
         handler=heal_handler,
     ),
 }

design.md

@@ -1,222 +0,0 @@
-# Grid Royale — Design Doc
-
-## Game Mode: Battle Royale (MVP)
-
-8 agents drop onto a 20×20 grid. Last agent standing wins. Loot chests
-contain abilities and points. Killing an agent drops loot — pick up
-their leftover abilities and score.
-
----
-
-## Core Abstraction
-
-### Environment — single source of truth for ALL state
-
-```python
-@dataclass
-class Environment:
-    grid: dict[tuple[int, int], Tile]
-    agents: dict[str, AgentState]
-    turn: int
-    config: GameConfig
-```
-
-### Tile — lightweight, holds terrain + optional loot
-
-```python
-@dataclass
-class LootItem:
-    type: Literal["ability", "points"]
-    ability_name: str | None = None
-    points: int | None = None
-    rarity: str = "common"
-    source: str = "chest"            # "chest" or the agent_id who dropped it
-
-@dataclass
-class Tile:
-    terrain: str
-    loot: list[LootItem] | None = None
-```
-
-No wrapper classes. No separate `DeathCache` / `Chest`. Just a list of `LootItem` on the tile — whether it came from a chest or a dead agent.
-
-### Game Config
-
-```python
-@dataclass
-class GameConfig:
-    mode: Literal["battle_royale"] = "battle_royale"
-    grid_size: int = 20
-    max_turns: int = 50
-    max_agents: int = 8
-    base_hp: int = 100
-    attack_damage: int = 25
-    attack_range: int = 1
-    num_chests: int = 15
-    chest_respawn_interval: int = 5
-    chest_value_range: tuple = (10, 50)
-    kill_score: int = 50
-    survival_score_per_turn: int = 5
-    win_bonus: int = 100
-```
-
-### Agent State
-
-```python
-@dataclass
-class AgentState:
-    id: str
-    name: str
-    pos: list[int]
-    hp: int
-    alive: bool
-    score: int
-    kills: int
-    shielded: bool                          # passive buff from shield ability
-    abilities: list[AbilityInstance]        # acquired abilities with runtime state
-    messages: list[dict]
-    mailbox: list[Message]
-
-@dataclass
-class AbilityInstance:
-    name: str
-    last_used_turn: int = -1               # for cooldown
-    uses_remaining: int | None = None       # None = infinite
-```
-
-### Agent — stateless brain (owns LLM client)
-
-```python
-class Agent:
-    id: str
-    model: str
-    provider: str
-    client: AsyncOpenAI
-
-    async def decide(self, messages: list, tools: list) -> list[ToolCall]:
-        # one LLM call
-```
-
-The brain is ephemeral — owns how the agent thinks (model, provider, client).
-The state of what the agent knows (messages, position, HP, abilities) lives
-in `AgentState` inside `Environment`.
-
-### Tools — static schemas, shared by all agents
-
-Exactly 4 tools. Never changes. No cache misses.
-
-| Tool | Effect |
-|---|---|
-| `move(dx, dy)` | Move to adjacent tile. Auto-loots loot on tile if present. |
-| `observe()` | Return visible tiles + agents within observation radius. |
-| `think(content)` | Internal monologue — appended to conversation, no side effect. |
-| `activate_ability(name, args)` | Dispatch to ability handler. Checks cooldown + remaining uses. |
-
-`activate_ability` takes a flexible `args: object` that each handler
-interprets differently. Example abilities:
-
-```python
-# attack — needs a position target
-activate_ability(name="attack", args={"x": 5, "y": 7})
-
-# shield — self-cast, no args
-activate_ability(name="shield", args={})
-
-# swap (hypothetical rare) — needs a target agent ID
-activate_ability(name="swap", args={"target_id": "agent_3"})
-```
-
-### Abilities — registered internally, not as separate tools
-
-```python
-ABILITY_REGISTRY = {
-    "attack": {"cooldown": 1, "uses": None,   "handler": attack_handler},
-    "dash":   {"cooldown": 2, "uses": 3,       "handler": dash_handler},
-    "shield": {"cooldown": 3, "uses": None,    "handler": shield_handler},
-    "heal":   {"cooldown": 2, "uses": 2,       "handler": heal_handler},
-}
-```
-
-`activate_ability` checks: does agent have this ability? Can it be used
-this turn (cooldown + remaining uses)? Then dispatches to the handler.
-
-### Scoring
-
-| Event | Points |
-|---|---|
-| Kill | +50 |
-| Per turn alive | +5 |
-| Loot collected | 10–100 (by rarity) |
-| Win (last alive) | +100 |
-
-### Engine — orchestrates the turn loop
-
-```python
-class Engine:
-    env: Environment
-    agents: dict[str, Agent]
-
-    async def step(self):
-        # Phase 1: all agents decide (parallel)
-        # Phase 2: execute up to 3 tool calls round-robin
-        # Post-turn: check eliminations → drop loot, respawn chests
-        self.env.turn += 1
-```
-
-Elimination flow:
-1. `attack_handler` reduces HP → if HP ≤ 0, mark `alive=False`
-2. Place `LootItem` entries on their tile (1-2 random abilities + 50% score,
-   `source = dead_agent_id`)
-3. Credit killer with +50 score, increment kills
-
-Respawn (not in BR — only for hypothetical DM mode later): revived agents
-start at random empty tile with base HP and **no abilities**.
-
----
-
-## File Layout
-
-```
-grid-royale/
-  backend/
-    environment/
-      __init__.py
-      environment.py          # Environment dataclass
-      tile.py                 # Tile, LootItem
-      config.py               # GameConfig
-      ability_registry.py     # ABILITY_REGISTRY + handlers
-      scoring.py              # Score logic
-      loot_tables.py          # Loot generation
-    agent/
-      __init__.py
-      state.py                # AgentState, AbilityInstance
-      agent.py                # Agent brain: decide(messages, tools)
-      llm_client.py           # Provider configs + factory
-    tools/
-      __init__.py             # ALL_TOOLS, TOOL_SCHEMAS (4 tools)
-      move.py
-      think.py
-      observe.py
-      activate_ability.py
-    engine.py                 # Engine (turn loop + eliminations + scoring)
-  api.py                      # FastAPI routes
-  main.py                     # uvicorn entry point
-  frontend/
-    dashboard.py              # Gradio app — grid view, game log, agent cards
-
-No `static/index.html`. Gradio serves the UI server-side (Python-native,
-fast for hackathon). Frontend is a thin visualization layer on top of the
-API — reads `env` snapshot and renders it.
-
-## Key Design Properties
-
-| Concept | Lives where | Mutated by |
-|---|---|---|
-| Grid + terrain | `env.grid` | tools |
-| Loot on tiles | `env.grid[x,y].loot` | engine (spawn), MoveTool (pickup) |
-| Agent HP, score, abilities | `env.agents[aid]` | tools |
-| LLM conversation | `env.agents[aid].messages` | agent.decide(), tools |
-| Tool schemas | `tools/__init__.py` | never (static, 4 tools) |
-| Ability logic | `environment/ability_registry.py` | handlers |
-| Scoring logic | `environment/scoring.py` | engine |
-| Loot tables | `environment/loot_tables.py` | engine |

frontend/static/index.html

@@ -150,6 +150,104 @@ body {
   width: 28px; text-align: right;
 }
 
+.lobby-prompt-wrap {
+  margin-top: 10px;
+  margin-bottom: 12px;
+  width: 100%;
+}
+#systemPromptInput {
+  width: 100%;
+  height: 120px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  color: var(--text);
+  font-family: 'JetBrains Mono', monospace;
+  font-size: 10px;
+  line-height: 1.4;
+  padding: 8px 10px;
+  resize: vertical;
+  outline: none;
+  transition: border-color 0.2s, box-shadow 0.2s;
+}
+#systemPromptInput:focus {
+  border-color: var(--active-tab-color, var(--accent));
+  box-shadow: 0 0 10px var(--active-tab-glow, var(--accent-glow));
+}
+
+.lobby-prompt-tabs {
+  display: flex;
+  gap: 8px;
+  margin-top: 10px;
+  margin-bottom: 2px;
+  flex-wrap: wrap;
+  width: 100%;
+}
+.lobby-tab {
+  padding: 6px 12px;
+  border-radius: 6px;
+  background: var(--surface2);
+  border: 1px solid var(--border);
+  color: var(--text-dim);
+  font-family: 'Space Grotesk', sans-serif;
+  font-size: 11px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.2s ease;
+  user-select: none;
+}
+.lobby-tab:hover {
+  border-color: var(--text-muted);
+  color: var(--text);
+}
+.lobby-tab.active {
+  background: var(--surface);
+  border-color: var(--tab-color, var(--accent));
+  color: var(--tab-color, var(--accent));
+  box-shadow: 0 0 8px var(--tab-glow, var(--accent-glow));
+}
+
+.lobby-agent-edit-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-top: 10px;
+  margin-bottom: 8px;
+  width: 100%;
+  background: var(--surface2);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 8px 12px;
+  transition: border-color 0.2s, box-shadow 0.2s;
+}
+.lobby-agent-edit-row:focus-within {
+  border-color: var(--active-tab-color, var(--accent));
+  box-shadow: 0 0 10px var(--active-tab-glow, var(--accent-glow));
+}
+.lobby-agent-color-dot {
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: var(--accent);
+  box-shadow: 0 0 8px var(--accent-glow);
+  flex-shrink: 0;
+  transition: all 0.2s ease;
+}
+.lobby-agent-name-input {
+  flex: 1;
+  background: transparent;
+  border: none;
+  outline: none;
+  color: var(--text);
+  font-family: 'Space Grotesk', sans-serif;
+  font-size: 13px;
+  font-weight: 600;
+  padding: 0;
+}
+.lobby-agent-name-input::placeholder {
+  color: var(--text-dim);
+}
+
 .lobby-deploy {
   width: 100%; margin-top: 24px;
   padding: 15px; border: none; border-radius: 12px;
@@ -1007,6 +1105,15 @@ body {
           <span class="range-val" id="maxTurnsVal">100</span>
         </div>
       </div>
+      <div class="lobby-section-label" style="margin-top: 16px;">Agent Customization</div>
+      <div class="lobby-prompt-tabs" id="agentPromptTabs"></div>
+      <div class="lobby-agent-edit-row">
+        <span class="lobby-agent-color-dot" id="lobbyAgentColorDot"></span>
+        <input type="text" id="lobbyAgentNameInput" class="lobby-agent-name-input" placeholder="Agent Name">
+      </div>
+      <div class="lobby-prompt-wrap">
+        <textarea id="systemPromptInput" placeholder="Configure the agent system prompt..."></textarea>
+      </div>
       <button class="lobby-deploy" id="startBtn">⚔ Deploy Agents</button>
     </div>
   </div>
@@ -1212,12 +1319,136 @@ const AGENT_COLORS = {
   animate();
 })();
 
+const BOT_NAMES = ["Leo", "Sam", "Mia", "Alex", "Zoe", "Kai", "Toby", "Zane"];
+let agentNames = [...BOT_NAMES];
+let agentSystemPrompts = {};
+let activePromptAgent = 'agent_0';
+let promptManuallyEdited = {};
+
+function saveCurrentPrompt() {
+  const promptInput = document.getElementById('systemPromptInput');
+  if (promptInput && activePromptAgent) {
+    agentSystemPrompts[activePromptAgent] = promptInput.value;
+  }
+}
+
+function loadCurrentPrompt() {
+  const promptInput = document.getElementById('systemPromptInput');
+  if (promptInput && activePromptAgent) {
+    promptInput.value = agentSystemPrompts[activePromptAgent] || '';
+  }
+}
+
+function renderPromptTabs() {
+  const numAgents = parseInt(document.getElementById('numAgents').value);
+  const tabsContainer = document.getElementById('agentPromptTabs');
+  if (!tabsContainer) return;
+  
+  tabsContainer.innerHTML = '';
+  
+  const activeIdx = parseInt(activePromptAgent.split('_')[1]);
+  if (activeIdx >= numAgents) {
+    activePromptAgent = 'agent_0';
+  }
+  
+  for (let i = 0; i < numAgents; i++) {
+    const aid = `agent_${i}`;
+    const name = agentNames[i] || `Agent ${i}`;
+    const color = AGENT_COLORS[aid] || '#e8e6e3';
+    
+    const tab = document.createElement('div');
+    tab.className = 'lobby-tab';
+    if (aid === activePromptAgent) {
+      tab.classList.add('active');
+      tab.style.setProperty('--tab-color', color);
+      tab.style.setProperty('--tab-glow', `${color}4D`);
+      
+      const promptInput = document.getElementById('systemPromptInput');
+      if (promptInput) {
+        promptInput.style.setProperty('--active-tab-color', color);
+        promptInput.style.setProperty('--active-tab-glow', `${color}66`);
+      }
+      
+      const colorDot = document.getElementById('lobbyAgentColorDot');
+      if (colorDot) {
+        colorDot.style.background = color;
+        colorDot.style.boxShadow = `0 0 10px ${color}`;
+      }
+      
+      const nameInput = document.getElementById('lobbyAgentNameInput');
+      if (nameInput) {
+        nameInput.value = name;
+      }
+    }
+    tab.textContent = name;
+    tab.addEventListener('click', () => {
+      saveCurrentPrompt();
+      activePromptAgent = aid;
+      renderPromptTabs();
+      loadCurrentPrompt();
+    });
+    tabsContainer.appendChild(tab);
+  }
+}
+
+async function updateAllPrompts() {
+  const gridSize = document.getElementById('gridSize').value;
+  try {
+    const data = await api('GET', `/api/game/default_prompt?grid_size=${gridSize}`);
+    if (data && data.default_prompt) {
+      const maxAgents = 8;
+      for (let i = 0; i < maxAgents; i++) {
+        const aid = `agent_${i}`;
+        if (!promptManuallyEdited[aid]) {
+          agentSystemPrompts[aid] = data.default_prompt;
+        }
+      }
+      loadCurrentPrompt();
+    }
+  } catch (err) {
+    console.error("Failed to fetch default prompts", err);
+  }
+}
+
 ['gridSize','numAgents','numChests','maxTurns'].forEach(id => {
   const el = document.getElementById(id);
   const val = document.getElementById(id+'Val');
-  el.addEventListener('input', () => { val.textContent = el.value; });
+  el.addEventListener('input', () => {
+    val.textContent = el.value;
+    if (id === 'gridSize') {
+      updateAllPrompts();
+    } else if (id === 'numAgents') {
+      renderPromptTabs();
+    }
+  });
+});
+
+document.getElementById('lobbyAgentNameInput').addEventListener('input', (e) => {
+  if (activePromptAgent) {
+    const activeIdx = parseInt(activePromptAgent.split('_')[1]);
+    const newName = e.target.value.trim() || `Agent ${activeIdx}`;
+    agentNames[activeIdx] = newName;
+    
+    const activeTab = document.querySelector('#agentPromptTabs .lobby-tab.active');
+    if (activeTab) {
+      activeTab.textContent = newName;
+    }
+  }
+});
+
+document.getElementById('systemPromptInput').addEventListener('input', () => {
+  if (activePromptAgent) {
+    promptManuallyEdited[activePromptAgent] = true;
+    saveCurrentPrompt();
+  }
 });
 
+// Initialize on load
+(async () => {
+  renderPromptTabs();
+  await updateAllPrompts();
+})();
+
 /* ═══════════ THREE.JS ═══════════ */
 const TILE = 1.6;
 let app = null;
@@ -2491,9 +2722,24 @@ async function startGame() {
   const numAgents=parseInt(document.getElementById('numAgents').value);
   const numChests=parseInt(document.getElementById('numChests').value);
   const maxTurns=parseInt(document.getElementById('maxTurns').value);
+  
+  saveCurrentPrompt();
+  const systemPrompts = {};
+  for (let i = 0; i < numAgents; i++) {
+    const aid = `agent_${i}`;
+    systemPrompts[aid] = agentSystemPrompts[aid] || '';
+  }
+
   document.getElementById('startBtn').disabled=true;
   document.getElementById('startBtn').textContent='Deploying...';
-  state = await api('POST','/api/game/start',{grid_size:gridSize,max_agents:numAgents,num_chests:numChests,max_turns:maxTurns});
+  state = await api('POST','/api/game/start',{
+    grid_size:gridSize,
+    max_agents:numAgents,
+    num_chests:numChests,
+    max_turns:maxTurns,
+    agent_names:agentNames.slice(0, numAgents),
+    system_prompts:systemPrompts
+  });
   state = await api('GET','/api/game/state');
   gameStarted=true;
   nameMaterialCache={};