mirror of
https://github.com/hanzoai/stack.git
synced 2026-11-19 03:06:57 +00:00
609 lines
20 KiB
Python
609 lines
20 KiB
Python
"""Game development team demo - Agents building a game together.
|
|
|
|
This example shows game dev agents collaborating:
|
|
- Game Designer: Creates game concepts and mechanics
|
|
- Artist: Designs visuals and assets
|
|
- Programmer: Implements game logic
|
|
- Sound Designer: Creates audio
|
|
- QA Tester: Tests and finds bugs
|
|
"""
|
|
|
|
import asyncio
|
|
from typing import Any
|
|
|
|
from hanzo_agents import (
|
|
State,
|
|
Web3Agent,
|
|
Web3Network,
|
|
WalletConfig,
|
|
Web3AgentConfig,
|
|
generate_shared_mnemonic,
|
|
)
|
|
from hanzo_agents.core.router import Router
|
|
|
|
|
|
class GameDesignerAgent(Web3Agent):
|
|
"""Game designer creating concepts and mechanics."""
|
|
|
|
name = "game_designer"
|
|
description = "Creates engaging game concepts and balanced mechanics"
|
|
|
|
async def _run_impl(self, state: State, history, network) -> Any:
|
|
"""Design the game concept."""
|
|
print(f"\n🎮 {self.name}: Designing a new game concept...")
|
|
|
|
# Create game concept
|
|
game_concept = {
|
|
"title": "Quantum Maze Runner",
|
|
"genre": "Puzzle/Platformer",
|
|
"theme": "Sci-fi quantum mechanics",
|
|
"core_mechanic": "Phase through dimensions to solve puzzles",
|
|
"target_audience": "Casual to mid-core gamers",
|
|
"platform": "Web/Mobile",
|
|
"monetization": "Free-to-play with cosmetic purchases",
|
|
}
|
|
|
|
# Design core gameplay
|
|
gameplay = {
|
|
"player_abilities": [
|
|
"Quantum jump between dimensions",
|
|
"Time rewind (limited uses)",
|
|
"Phase through certain walls",
|
|
"Create quantum entanglements",
|
|
],
|
|
"level_structure": "50 levels across 5 dimensions",
|
|
"difficulty_curve": "Gradual with spikes every 10 levels",
|
|
"session_length": "3-5 minutes per level",
|
|
"retention_hooks": [
|
|
"Daily challenges",
|
|
"Leaderboards",
|
|
"Collectible quantum particles",
|
|
"Story snippets after each dimension",
|
|
],
|
|
}
|
|
|
|
state["game_concept"] = game_concept
|
|
state["gameplay_design"] = gameplay
|
|
|
|
# Create detailed GDD excerpt
|
|
gdd_excerpt = {
|
|
"controls": {
|
|
"mobile": "Swipe to move, tap to jump, hold to phase",
|
|
"web": "Arrow keys/WASD + Space + Shift",
|
|
},
|
|
"progression": "Linear with optional bonus levels",
|
|
"rewards": "Stars (1-3 per level), Quantum particles, Skins",
|
|
}
|
|
|
|
state["gdd_excerpt"] = gdd_excerpt
|
|
|
|
# Request art concepts
|
|
metadata = {
|
|
"service_offer": {
|
|
"type": "design",
|
|
"description": "Game design consultation",
|
|
"price_eth": 0.05,
|
|
},
|
|
"next_agent": "artist",
|
|
}
|
|
|
|
return self.create_result(
|
|
f"Game concept ready: '{game_concept['title']}' - "
|
|
f"A {game_concept['genre']} with {len(gameplay['player_abilities'])} unique abilities",
|
|
metadata=metadata,
|
|
)
|
|
|
|
|
|
class ArtistAgent(Web3Agent):
|
|
"""Artist creating game visuals."""
|
|
|
|
name = "artist"
|
|
description = "Creates stunning game art and visual assets"
|
|
|
|
async def _run_impl(self, state: State, history, network) -> Any:
|
|
"""Create art concepts and assets."""
|
|
print(
|
|
f"\n🎨 {self.name}: Creating visual concepts for {state['game_concept']['title']}..."
|
|
)
|
|
|
|
game_concept = state.get("game_concept", {})
|
|
|
|
# Define art style
|
|
art_style = {
|
|
"visual_style": "Low-poly with neon accents",
|
|
"color_palette": {
|
|
"primary": ["#00FFFF", "#FF00FF", "#FFFF00"], # Cyan, Magenta, Yellow
|
|
"secondary": ["#0088FF", "#FF0088", "#88FF00"],
|
|
"background": ["#0A0A0A", "#1A1A2E", "#16213E"],
|
|
},
|
|
"inspiration": "Tron meets Monument Valley",
|
|
"shader_effects": ["Holographic", "Glitch", "Particle trails"],
|
|
}
|
|
|
|
# Create asset list
|
|
assets_created = {
|
|
"characters": {
|
|
"player": "Quantum explorer with shifting form",
|
|
"npcs": ["Guide hologram", "Quantum cats", "Time echoes"],
|
|
},
|
|
"environments": {
|
|
"dimension_1": "Neon grid world",
|
|
"dimension_2": "Fractured reality",
|
|
"dimension_3": "Quantum forest",
|
|
"dimension_4": "Time streams",
|
|
"dimension_5": "The Void",
|
|
},
|
|
"ui_elements": {
|
|
"buttons": 12,
|
|
"icons": 24,
|
|
"backgrounds": 5,
|
|
"fonts": ["Quantum Sans", "Digital Mono"],
|
|
},
|
|
"particles": {
|
|
"quantum_jump": "Blue spiral effect",
|
|
"phase_shift": "Purple dissolve",
|
|
"time_rewind": "Golden trails",
|
|
"entanglement": "Connected light beams",
|
|
},
|
|
}
|
|
|
|
state["art_style"] = art_style
|
|
state["game_assets"] = assets_created
|
|
|
|
# Simulate asset creation
|
|
await asyncio.sleep(0.5)
|
|
|
|
# Generate sprite sheets
|
|
sprite_sheets = {
|
|
"player_animations": ["idle", "walk", "jump", "phase", "death"],
|
|
"enemy_animations": ["patrol", "alert", "attack"],
|
|
"total_frames": 120,
|
|
"format": "PNG with transparency",
|
|
"resolution": "128x128 per frame",
|
|
}
|
|
|
|
state["sprite_sheets"] = sprite_sheets
|
|
|
|
# Bill for art
|
|
if self.wallet:
|
|
payment = await self.request_payment(
|
|
from_address=state.get("producer_address", self.address),
|
|
amount_eth=0.08,
|
|
task_description="Game art and asset creation",
|
|
)
|
|
print(f"💰 Art assets delivered, invoiced: {payment['amount_eth']} ETH")
|
|
|
|
metadata = {"next_agent": "programmer"}
|
|
|
|
return self.create_result(
|
|
f"Art complete: {len(assets_created['environments'])} environments, "
|
|
f"{sprite_sheets['total_frames']} animation frames",
|
|
metadata=metadata,
|
|
)
|
|
|
|
|
|
class ProgrammerAgent(Web3Agent):
|
|
"""Programmer implementing game logic."""
|
|
|
|
name = "programmer"
|
|
description = "Codes game mechanics and implements features"
|
|
|
|
async def _run_impl(self, state: State, history, network) -> Any:
|
|
"""Implement the game code."""
|
|
print(f"\n💻 {self.name}: Implementing game mechanics...")
|
|
|
|
gameplay = state.get("gameplay_design", {})
|
|
assets = state.get("game_assets", {})
|
|
|
|
# Implementation details
|
|
implementation = {
|
|
"engine": "Phaser 3",
|
|
"language": "TypeScript",
|
|
"architecture": "ECS (Entity Component System)",
|
|
"modules": {
|
|
"core": ["GameManager", "StateManager", "SaveSystem"],
|
|
"physics": ["QuantumPhysics", "DimensionShift", "Collision"],
|
|
"rendering": ["ParticleSystem", "ShaderManager", "LightingEngine"],
|
|
"gameplay": ["PlayerController", "LevelLoader", "PuzzleManager"],
|
|
"ui": ["MenuSystem", "HUD", "DialogueManager"],
|
|
},
|
|
"total_loc": 8500,
|
|
"test_coverage": "82%",
|
|
}
|
|
|
|
state["implementation"] = implementation
|
|
|
|
# Code key systems
|
|
code_systems = {
|
|
"quantum_mechanics": {
|
|
"phase_shift": "Implemented with state interpolation",
|
|
"dimension_swap": "Seamless transition with fade effect",
|
|
"entanglement": "Physics bodies linked across dimensions",
|
|
},
|
|
"puzzle_system": {
|
|
"types": ["Switch", "Pressure", "Timing", "Pattern", "Quantum"],
|
|
"solver": "A* pathfinding with quantum states",
|
|
"hint_system": "Progressive hints after 3 failed attempts",
|
|
},
|
|
"save_system": {
|
|
"method": "LocalStorage with cloud backup",
|
|
"data": ["Progress", "Collectibles", "Settings", "Achievements"],
|
|
},
|
|
}
|
|
|
|
state["code_systems"] = code_systems
|
|
|
|
# Performance metrics
|
|
performance = {
|
|
"target_fps": 60,
|
|
"achieved_fps": 58,
|
|
"load_time": "2.3 seconds",
|
|
"memory_usage": "45MB average",
|
|
"battery_impact": "Low",
|
|
"optimization_level": "High",
|
|
}
|
|
|
|
state["performance_metrics"] = performance
|
|
|
|
# Deploy to test environment
|
|
if self.confidential_agent:
|
|
deploy_code = """
|
|
# Deploy game to test server
|
|
result = {
|
|
"build_id": "quantum_maze_v0.9",
|
|
"test_url": "https://test.quantummaze.game",
|
|
"api_endpoint": "wss://api.quantummaze.game",
|
|
"cdn_assets": "https://cdn.quantummaze.game"
|
|
}
|
|
"""
|
|
deployment = await self.execute_confidential(
|
|
deploy_code, {"env": "staging"}
|
|
)
|
|
state["test_deployment"] = deployment.get("result", {})
|
|
|
|
metadata = {
|
|
"service_request": {
|
|
"type": "testing",
|
|
"description": "QA testing and bug hunting",
|
|
"max_price_eth": 0.06,
|
|
},
|
|
"next_agent": "sound_designer",
|
|
}
|
|
|
|
return self.create_result(
|
|
f"Game implemented: {implementation['total_loc']} lines of code, "
|
|
f"{len(implementation['modules'])} modules, {performance['achieved_fps']} FPS",
|
|
metadata=metadata,
|
|
)
|
|
|
|
|
|
class SoundDesignerAgent(Web3Agent):
|
|
"""Sound designer creating audio."""
|
|
|
|
name = "sound_designer"
|
|
description = "Creates immersive audio experiences"
|
|
|
|
async def _run_impl(self, state: State, history, network) -> Any:
|
|
"""Create game audio and music."""
|
|
print(f"\n🎵 {self.name}: Composing audio for quantum adventures...")
|
|
|
|
game_concept = state.get("game_concept", {})
|
|
|
|
# Create audio design
|
|
audio_design = {
|
|
"music_tracks": {
|
|
"main_theme": "Ethereal electronica - 2:30",
|
|
"dimension_themes": [
|
|
"Grid World - Retro synthwave",
|
|
"Fractured Reality - Glitch hop",
|
|
"Quantum Forest - Ambient nature",
|
|
"Time Streams - Temporal echoes",
|
|
"The Void - Dark ambient",
|
|
],
|
|
"victory_jingle": "Uplifting chimes - 0:05",
|
|
"game_over": "Quantum collapse - 0:08",
|
|
},
|
|
"sound_effects": {
|
|
"player": ["jump", "land", "phase_in", "phase_out", "death"],
|
|
"abilities": [
|
|
"quantum_jump",
|
|
"time_rewind",
|
|
"entangle",
|
|
"break_entangle",
|
|
],
|
|
"ui": ["button_click", "menu_open", "level_complete", "star_collect"],
|
|
"ambient": ["dimension_hum", "particle_float", "energy_pulse"],
|
|
"total_sfx": 34,
|
|
},
|
|
"audio_tech": {
|
|
"format": "WebAudio API compatible",
|
|
"compression": "OGG Vorbis",
|
|
"3d_audio": "Positional audio for key effects",
|
|
"dynamic_mixing": "Adaptive based on gameplay",
|
|
},
|
|
}
|
|
|
|
state["audio_design"] = audio_design
|
|
|
|
# Create procedural audio system
|
|
procedural_audio = {
|
|
"system": "Quantum harmonics generator",
|
|
"parameters": ["Dimension", "Player velocity", "Puzzle state"],
|
|
"realtime_effects": ["Reverb", "Delay", "Pitch shift", "Low-pass filter"],
|
|
}
|
|
|
|
state["procedural_audio"] = procedural_audio
|
|
|
|
# Audio implementation
|
|
audio_stats = {
|
|
"total_duration": "18 minutes of music",
|
|
"file_size": "12MB compressed",
|
|
"load_strategy": "Progressive with priority queue",
|
|
"mobile_optimization": "Reduced quality option available",
|
|
}
|
|
|
|
state["audio_stats"] = audio_stats
|
|
|
|
metadata = {"next_agent": "qa_tester"}
|
|
|
|
return self.create_result(
|
|
f"Audio complete: {len(audio_design['music_tracks'])} music tracks, "
|
|
f"{audio_design['sound_effects']['total_sfx']} sound effects",
|
|
metadata=metadata,
|
|
)
|
|
|
|
|
|
class QATesterAgent(Web3Agent):
|
|
"""QA tester finding and reporting bugs."""
|
|
|
|
name = "qa_tester"
|
|
description = "Thoroughly tests games and ensures quality"
|
|
|
|
async def _run_impl(self, state: State, history, network) -> Any:
|
|
"""Test the game and find bugs."""
|
|
print(f"\n🐛 {self.name}: Testing {state['game_concept']['title']}...")
|
|
|
|
# Run test suites
|
|
test_results = {
|
|
"automated_tests": {
|
|
"unit_tests": {"passed": 142, "failed": 3},
|
|
"integration_tests": {"passed": 56, "failed": 1},
|
|
"performance_tests": {"passed": 18, "failed": 0},
|
|
"coverage": "86%",
|
|
},
|
|
"manual_testing": {
|
|
"hours_tested": 12,
|
|
"devices_tested": [
|
|
"iPhone 12",
|
|
"Samsung S21",
|
|
"iPad Pro",
|
|
"Chrome/Firefox/Safari",
|
|
],
|
|
"test_cases_executed": 85,
|
|
},
|
|
"bugs_found": [
|
|
{
|
|
"id": "BUG-001",
|
|
"severity": "High",
|
|
"desc": "Player clips through wall in level 23",
|
|
"status": "Fixed",
|
|
},
|
|
{
|
|
"id": "BUG-002",
|
|
"severity": "Medium",
|
|
"desc": "Audio cuts out after dimension shift",
|
|
"status": "Fixed",
|
|
},
|
|
{
|
|
"id": "BUG-003",
|
|
"severity": "Low",
|
|
"desc": "Particle effect persists on menu",
|
|
"status": "Fixed",
|
|
},
|
|
{
|
|
"id": "BUG-004",
|
|
"severity": "Low",
|
|
"desc": "Typo in tutorial text",
|
|
"status": "Fixed",
|
|
},
|
|
],
|
|
"performance_issues": [
|
|
"Frame drops on older devices during particle-heavy scenes",
|
|
"Loading time exceeds 3s on slow connections",
|
|
],
|
|
}
|
|
|
|
state["test_results"] = test_results
|
|
|
|
# Gameplay feedback
|
|
gameplay_feedback = {
|
|
"difficulty": "Well-balanced with good progression",
|
|
"fun_factor": "8.5/10 - Engaging puzzles, satisfying mechanics",
|
|
"issues": [
|
|
"Level 35 puzzle solution not intuitive",
|
|
"Tutorial could be more interactive",
|
|
],
|
|
"suggestions": [
|
|
"Add colorblind mode",
|
|
"Include speed run timer",
|
|
"More particle effects on success",
|
|
],
|
|
}
|
|
|
|
state["gameplay_feedback"] = gameplay_feedback
|
|
|
|
# Create test report
|
|
test_report = {
|
|
"build_tested": state.get("test_deployment", {}).get("build_id", "v0.9"),
|
|
"test_date": "2024-01-25",
|
|
"overall_quality": "Release Candidate",
|
|
"recommendation": "Ready for soft launch after minor fixes",
|
|
"estimated_rating": "4.3/5 stars",
|
|
}
|
|
|
|
state["final_test_report"] = test_report
|
|
|
|
# Bill for QA work
|
|
if self.wallet:
|
|
payment = await self.request_payment(
|
|
from_address=state.get("producer_address", self.address),
|
|
amount_eth=0.05,
|
|
task_description="Comprehensive QA testing",
|
|
)
|
|
print(f"💰 QA testing complete, invoiced: {payment['amount_eth']} ETH")
|
|
|
|
return self.create_result(
|
|
f"QA complete: {len(test_results['bugs_found'])} bugs found (all fixed), "
|
|
f"Quality rating: {test_report['overall_quality']}",
|
|
metadata={"game_ready": True},
|
|
)
|
|
|
|
|
|
class GameProducerRouter(Router):
|
|
"""Routes between game development team members."""
|
|
|
|
async def route(self, network, step, last_result, agents) -> str:
|
|
"""Route through game dev pipeline."""
|
|
if step == 0:
|
|
return "game_designer"
|
|
|
|
# Check completion
|
|
if last_result and last_result.metadata.get("game_ready"):
|
|
return None
|
|
|
|
# Follow metadata hints
|
|
if last_result and last_result.metadata.get("next_agent"):
|
|
return last_result.metadata["next_agent"]
|
|
|
|
# Standard pipeline
|
|
pipeline = [
|
|
"game_designer",
|
|
"artist",
|
|
"programmer",
|
|
"sound_designer",
|
|
"qa_tester",
|
|
]
|
|
|
|
current = last_result.agent if last_result else pipeline[0]
|
|
try:
|
|
idx = pipeline.index(current)
|
|
if idx < len(pipeline) - 1:
|
|
return pipeline[idx + 1]
|
|
except ValueError:
|
|
pass
|
|
|
|
return None
|
|
|
|
|
|
async def run_game_dev_demo():
|
|
"""Run the game development team demo."""
|
|
print("🎮 Game Development Team Demo")
|
|
print("=" * 50)
|
|
|
|
# Create shared mnemonic
|
|
mnemonic = generate_shared_mnemonic()
|
|
|
|
# Initial state
|
|
state = State(
|
|
{
|
|
"project_type": "mobile_game",
|
|
"timeline": "4 weeks",
|
|
"budget_eth": 0.5,
|
|
"producer_address": "0x" + "F" * 40, # Mock producer wallet
|
|
}
|
|
)
|
|
|
|
# Create game dev team
|
|
agents = [
|
|
GameDesignerAgent(
|
|
web3_config=Web3AgentConfig(
|
|
wallet_enabled=True,
|
|
wallet_config=WalletConfig(mnemonic=mnemonic, account_index=0),
|
|
)
|
|
),
|
|
ArtistAgent(
|
|
web3_config=Web3AgentConfig(
|
|
wallet_enabled=True,
|
|
wallet_config=WalletConfig(mnemonic=mnemonic, account_index=1),
|
|
)
|
|
),
|
|
ProgrammerAgent(
|
|
web3_config=Web3AgentConfig(
|
|
wallet_enabled=True,
|
|
tee_enabled=True,
|
|
wallet_config=WalletConfig(mnemonic=mnemonic, account_index=2),
|
|
)
|
|
),
|
|
SoundDesignerAgent(
|
|
web3_config=Web3AgentConfig(
|
|
wallet_enabled=True,
|
|
wallet_config=WalletConfig(mnemonic=mnemonic, account_index=3),
|
|
)
|
|
),
|
|
QATesterAgent(
|
|
web3_config=Web3AgentConfig(
|
|
wallet_enabled=True,
|
|
wallet_config=WalletConfig(mnemonic=mnemonic, account_index=4),
|
|
)
|
|
),
|
|
]
|
|
|
|
# Create network
|
|
network = Web3Network(
|
|
state=state,
|
|
agents=agents,
|
|
router=GameProducerRouter(),
|
|
shared_mnemonic=mnemonic,
|
|
max_steps=10,
|
|
)
|
|
|
|
# Run game development
|
|
final_state = await network.run()
|
|
|
|
# Print game summary
|
|
print("\n" + "=" * 50)
|
|
print("🎮 Game Development Complete!")
|
|
|
|
game = final_state.get("game_concept", {})
|
|
print(f"\nGame: {game.get('title', 'Unknown')}")
|
|
print(f"Genre: {game.get('genre', 'Unknown')}")
|
|
print(f"Platform: {game.get('platform', 'Unknown')}")
|
|
|
|
# Development summary
|
|
print("\n📊 Development Summary:")
|
|
|
|
impl = final_state.get("implementation", {})
|
|
print(
|
|
f" Code: {impl.get('total_loc', 0):,} lines ({impl.get('test_coverage', 'N/A')})"
|
|
)
|
|
|
|
assets = final_state.get("game_assets", {})
|
|
print(f" Art: {len(assets.get('environments', {}))} environments")
|
|
|
|
audio = final_state.get("audio_design", {})
|
|
print(
|
|
f" Audio: {len(audio.get('music_tracks', {}))} tracks, {audio.get('sound_effects', {}).get('total_sfx', 0)} SFX"
|
|
)
|
|
|
|
tests = final_state.get("test_results", {})
|
|
bugs = tests.get("bugs_found", [])
|
|
print(f" QA: {len(bugs)} bugs found and fixed")
|
|
|
|
# Quality report
|
|
report = final_state.get("final_test_report", {})
|
|
print(f"\n✅ Final Status: {report.get('recommendation', 'Unknown')}")
|
|
print(f"📱 Test Build: {report.get('build_tested', 'N/A')}")
|
|
print(f"⭐ Expected Rating: {report.get('estimated_rating', 'N/A')}")
|
|
|
|
# Team stats
|
|
print("\n👥 Team Performance:")
|
|
stats = network.get_agent_stats()
|
|
for agent_name, _agent_stats in stats.items():
|
|
print(f" {agent_name}: Completed tasks")
|
|
|
|
print(f"\n🎉 Game ready for launch!")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
asyncio.run(run_game_dev_demo())
|