Fix initial bugs

=0.16.0

@@ -0,0 +1,117 @@
+Collecting gradio
+  Downloading gradio-5.44.1-py3-none-any.whl.metadata (16 kB)
+Requirement already satisfied: huggingface-hub in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (0.26.1)
+Collecting aiofiles<25.0,>=22.0 (from gradio)
+  Downloading aiofiles-24.1.0-py3-none-any.whl.metadata (10 kB)
+Requirement already satisfied: anyio<5.0,>=3.0 in /home/alienware3/.local/lib/python3.10/site-packages (from gradio) (4.9.0)
+Collecting brotli>=1.1.0 (from gradio)
+  Downloading Brotli-1.1.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl.metadata (5.5 kB)
+Collecting fastapi<1.0,>=0.115.2 (from gradio)
+  Downloading fastapi-0.116.1-py3-none-any.whl.metadata (28 kB)
+Collecting ffmpy (from gradio)
+  Downloading ffmpy-0.6.1-py3-none-any.whl.metadata (2.9 kB)
+Collecting gradio-client==1.12.1 (from gradio)
+  Downloading gradio_client-1.12.1-py3-none-any.whl.metadata (7.1 kB)
+Collecting groovy~=0.1 (from gradio)
+  Downloading groovy-0.1.2-py3-none-any.whl.metadata (6.1 kB)
+Requirement already satisfied: httpx<1.0,>=0.24.1 in /home/alienware3/.local/lib/python3.10/site-packages (from gradio) (0.28.1)
+Collecting huggingface-hub
+  Using cached huggingface_hub-0.34.4-py3-none-any.whl.metadata (14 kB)
+Requirement already satisfied: jinja2<4.0 in /home/alienware3/.local/lib/python3.10/site-packages (from gradio) (3.1.6)
+Requirement already satisfied: markupsafe<4.0,>=2.0 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from gradio) (3.0.1)
+Requirement already satisfied: numpy<3.0,>=1.0 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from gradio) (1.26.0)
+Collecting orjson~=3.0 (from gradio)
+  Downloading orjson-3.11.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (41 kB)
+Requirement already satisfied: packaging in /home/alienware3/.local/lib/python3.10/site-packages (from gradio) (25.0)
+Requirement already satisfied: pandas<3.0,>=1.0 in /home/alienware3/.local/lib/python3.10/site-packages (from gradio) (2.3.0)
+Requirement already satisfied: pillow<12.0,>=8.0 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from gradio) (10.3.0)
+Collecting pydantic<2.12,>=2.0 (from gradio)
+  Downloading pydantic-2.11.7-py3-none-any.whl.metadata (67 kB)
+Collecting pydub (from gradio)
+  Downloading pydub-0.25.1-py2.py3-none-any.whl.metadata (1.4 kB)
+Collecting python-multipart>=0.0.18 (from gradio)
+  Downloading python_multipart-0.0.20-py3-none-any.whl.metadata (1.8 kB)
+Requirement already satisfied: pyyaml<7.0,>=5.0 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from gradio) (6.0.2)
+Collecting ruff>=0.9.3 (from gradio)
+  Downloading ruff-0.12.12-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (25 kB)
+Collecting safehttpx<0.2.0,>=0.1.6 (from gradio)
+  Downloading safehttpx-0.1.6-py3-none-any.whl.metadata (4.2 kB)
+Collecting semantic-version~=2.0 (from gradio)
+  Downloading semantic_version-2.10.0-py2.py3-none-any.whl.metadata (9.7 kB)
+Collecting starlette<1.0,>=0.40.0 (from gradio)
+  Downloading starlette-0.47.3-py3-none-any.whl.metadata (6.2 kB)
+Collecting tomlkit<0.14.0,>=0.12.0 (from gradio)
+  Downloading tomlkit-0.13.3-py3-none-any.whl.metadata (2.8 kB)
+Collecting typer<1.0,>=0.12 (from gradio)
+  Downloading typer-0.17.4-py3-none-any.whl.metadata (15 kB)
+Requirement already satisfied: typing-extensions~=4.0 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from gradio) (4.12.2)
+Collecting uvicorn>=0.14.0 (from gradio)
+  Downloading uvicorn-0.35.0-py3-none-any.whl.metadata (6.5 kB)
+Requirement already satisfied: fsspec in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from gradio-client==1.12.1->gradio) (2024.9.0)
+Collecting websockets<16.0,>=10.0 (from gradio-client==1.12.1->gradio)
+  Downloading websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.8 kB)
+Requirement already satisfied: filelock in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from huggingface-hub) (3.16.1)
+Requirement already satisfied: requests in /home/alienware3/.local/lib/python3.10/site-packages (from huggingface-hub) (2.32.4)
+Requirement already satisfied: tqdm>=4.42.1 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from huggingface-hub) (4.66.4)
+Collecting hf-xet<2.0.0,>=1.1.3 (from huggingface-hub)
+  Using cached hf_xet-1.1.9-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (4.7 kB)
+Requirement already satisfied: exceptiongroup>=1.0.2 in /home/alienware3/.local/lib/python3.10/site-packages (from anyio<5.0,>=3.0->gradio) (1.3.0)
+Requirement already satisfied: idna>=2.8 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from anyio<5.0,>=3.0->gradio) (3.10)
+Requirement already satisfied: sniffio>=1.1 in /home/alienware3/.local/lib/python3.10/site-packages (from anyio<5.0,>=3.0->gradio) (1.3.1)
+Requirement already satisfied: certifi in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from httpx<1.0,>=0.24.1->gradio) (2024.8.30)
+Requirement already satisfied: httpcore==1.* in /home/alienware3/.local/lib/python3.10/site-packages (from httpx<1.0,>=0.24.1->gradio) (1.0.9)
+Requirement already satisfied: h11>=0.16 in /home/alienware3/.local/lib/python3.10/site-packages (from httpcore==1.*->httpx<1.0,>=0.24.1->gradio) (0.16.0)
+Requirement already satisfied: python-dateutil>=2.8.2 in /home/alienware3/.local/lib/python3.10/site-packages (from pandas<3.0,>=1.0->gradio) (2.9.0.post0)
+Requirement already satisfied: pytz>=2020.1 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from pandas<3.0,>=1.0->gradio) (2024.2)
+Requirement already satisfied: tzdata>=2022.7 in /home/alienware3/.local/lib/python3.10/site-packages (from pandas<3.0,>=1.0->gradio) (2025.2)
+Collecting annotated-types>=0.6.0 (from pydantic<2.12,>=2.0->gradio)
+  Downloading annotated_types-0.7.0-py3-none-any.whl.metadata (15 kB)
+Collecting pydantic-core==2.33.2 (from pydantic<2.12,>=2.0->gradio)
+  Downloading pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.8 kB)
+Collecting typing-inspection>=0.4.0 (from pydantic<2.12,>=2.0->gradio)
+  Downloading typing_inspection-0.4.1-py3-none-any.whl.metadata (2.6 kB)
+Requirement already satisfied: click>=8.0.0 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from typer<1.0,>=0.12->gradio) (8.1.7)
+Collecting shellingham>=1.3.0 (from typer<1.0,>=0.12->gradio)
+  Downloading shellingham-1.5.4-py2.py3-none-any.whl.metadata (3.5 kB)
+Requirement already satisfied: rich>=10.11.0 in /home/alienware3/.local/lib/python3.10/site-packages (from typer<1.0,>=0.12->gradio) (14.0.0)
+Requirement already satisfied: charset_normalizer<4,>=2 in /home/alienware3/.local/lib/python3.10/site-packages (from requests->huggingface-hub) (3.3.2)
+Requirement already satisfied: urllib3<3,>=1.21.1 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from requests->huggingface-hub) (2.2.3)
+Requirement already satisfied: six>=1.5 in /home/alienware3/miniconda3/envs/diamond/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas<3.0,>=1.0->gradio) (1.16.0)
+Requirement already satisfied: markdown-it-py>=2.2.0 in /home/alienware3/.local/lib/python3.10/site-packages (from rich>=10.11.0->typer<1.0,>=0.12->gradio) (3.0.0)
+Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /home/alienware3/.local/lib/python3.10/site-packages (from rich>=10.11.0->typer<1.0,>=0.12->gradio) (2.19.2)
+Requirement already satisfied: mdurl~=0.1 in /home/alienware3/.local/lib/python3.10/site-packages (from markdown-it-py>=2.2.0->rich>=10.11.0->typer<1.0,>=0.12->gradio) (0.1.2)
+Downloading gradio-5.44.1-py3-none-any.whl (60.2 MB)
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 60.2/60.2 MB 98.5 MB/s eta 0:00:00
+Downloading gradio_client-1.12.1-py3-none-any.whl (324 kB)
+Using cached huggingface_hub-0.34.4-py3-none-any.whl (561 kB)
+Downloading aiofiles-24.1.0-py3-none-any.whl (15 kB)
+Downloading Brotli-1.1.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl (3.0 MB)
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3.0/3.0 MB 100.4 MB/s eta 0:00:00
+Downloading fastapi-0.116.1-py3-none-any.whl (95 kB)
+Downloading groovy-0.1.2-py3-none-any.whl (14 kB)
+Using cached hf_xet-1.1.9-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.2 MB)
+Downloading orjson-3.11.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (132 kB)
+Downloading pydantic-2.11.7-py3-none-any.whl (444 kB)
+Downloading pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.0 MB)
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2.0/2.0 MB 94.6 MB/s eta 0:00:00
+Downloading python_multipart-0.0.20-py3-none-any.whl (24 kB)
+Downloading ruff-0.12.12-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (13.3 MB)
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 13.3/13.3 MB 104.4 MB/s eta 0:00:00
+Downloading safehttpx-0.1.6-py3-none-any.whl (8.7 kB)
+Downloading semantic_version-2.10.0-py2.py3-none-any.whl (15 kB)
+Downloading starlette-0.47.3-py3-none-any.whl (72 kB)
+Downloading tomlkit-0.13.3-py3-none-any.whl (38 kB)
+Downloading typer-0.17.4-py3-none-any.whl (46 kB)
+Downloading uvicorn-0.35.0-py3-none-any.whl (66 kB)
+Downloading ffmpy-0.6.1-py3-none-any.whl (5.5 kB)
+Downloading pydub-0.25.1-py2.py3-none-any.whl (32 kB)
+Downloading annotated_types-0.7.0-py3-none-any.whl (13 kB)
+Downloading shellingham-1.5.4-py2.py3-none-any.whl (9.8 kB)
+Downloading typing_inspection-0.4.1-py3-none-any.whl (14 kB)
+Downloading websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (181 kB)
+Installing collected packages: pydub, brotli, websockets, uvicorn, typing-inspection, tomlkit, shellingham, semantic-version, ruff, python-multipart, pydantic-core, orjson, hf-xet, groovy, ffmpy, annotated-types, aiofiles, pydantic, huggingface-hub, typer, starlette, safehttpx, gradio-client, fastapi, gradio
+  Attempting uninstall: huggingface-hub
+    Found existing installation: huggingface-hub 0.26.1
+    Uninstalling huggingface-hub-0.26.1:
+      Successfully uninstalled huggingface-hub-0.26.1
+Successfully installed aiofiles-24.1.0 annotated-types-0.7.0 brotli-1.1.0 fastapi-0.116.1 ffmpy-0.6.1 gradio-5.44.1 gradio-client-1.12.1 groovy-0.1.2 hf-xet-1.1.9 huggingface-hub-0.34.4 orjson-3.11.3 pydantic-2.11.7 pydantic-core-2.33.2 pydub-0.25.1 python-multipart-0.0.20 ruff-0.12.12 safehttpx-0.1.6 semantic-version-2.10.0 shellingham-1.5.4 starlette-0.47.3 tomlkit-0.13.3 typer-0.17.4 typing-inspection-0.4.1 uvicorn-0.35.0 websockets-15.0.1

DEPLOYMENT.md

@@ -0,0 +1,193 @@
+# Diamond CSGO AI Player - Deployment Guide
+
+## 🚀 Deploying to Hugging Face Spaces
+
+### Prerequisites
+1. Hugging Face account
+2. Model checkpoint files (`agent_epoch_00206.pt` or similar)
+3. Git and Git LFS installed
+
+### Step 1: Prepare Repository
+
+1. **Clone/Fork this repository**
+2. **Install Git LFS** (for large model files):
+   ```bash
+   git lfs install
+   git lfs track "*.pt"
+   git add .gitattributes
+   ```
+
+3. **Add your model checkpoint**:
+   ```bash
+   # Copy your trained model to the project root
+   cp /path/to/your/agent_epoch_00206.pt .
+   git add agent_epoch_00206.pt
+   git commit -m "Add trained model checkpoint"
+   ```
+
+### Step 2: Create Hugging Face Space
+
+1. Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+2. Click "Create new Space"
+3. Configure:
+   - **Space name**: `diamond-csgo-ai` (or your choice)
+   - **License**: Your preferred license
+   - **Space SDK**: `Docker` 
+   - **Space hardware**: 
+     - `CPU basic` (free) - for demo/testing
+     - `GPU T4 small` (paid) - for better performance
+
+### Step 3: Upload Code
+
+```bash
+# Clone your new space
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# Copy all project files
+cp -r /path/to/diamond/* .
+
+# Commit and push
+git add .
+git commit -m "Initial Diamond CSGO AI deployment"
+git push
+```
+
+### Step 4: Configuration Files
+
+Ensure these files are in your space root:
+
+- `app.py` - Main FastAPI application
+- `requirements.txt` - Python dependencies  
+- `Dockerfile` - Container configuration
+- `README.md` - Space description
+- `packages.txt` - System packages (if needed)
+
+### Step 5: Model Setup
+
+If your model is too large for Git (>100MB), use Git LFS or download from Hub:
+
+```python
+# In your app.py, add model downloading:
+from huggingface_hub import hf_hub_download
+
+def download_model():
+    return hf_hub_download(
+        repo_id="YOUR_USERNAME/YOUR_MODEL_REPO",
+        filename="agent_epoch_00206.pt"
+    )
+```
+
+## 🔧 Local Testing
+
+Before deploying, test locally:
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run tests
+python test_web_app.py
+
+# Start local server
+python run_web_demo.py
+```
+
+Visit `http://localhost:7860` to test the interface.
+
+## ⚙️ Configuration Options
+
+### Hardware Requirements
+
+| Tier | CPU | RAM | GPU | Performance |
+|------|-----|-----|-----|-------------|
+| Free | 2 vCPU | 16GB | None | Basic demo |
+| Basic GPU | 4 vCPU | 16GB | T4 | Good performance |
+| Premium | 8 vCPU | 32GB | A10G | Best experience |
+
+### Environment Variables
+
+Add these in your Space settings:
+- `CUDA_VISIBLE_DEVICES=""` (for CPU-only)
+- `PYTHONPATH="/app/src:/app"`
+
+## 🎮 Usage Instructions
+
+Once deployed, users can:
+
+1. Visit your Space URL
+2. Click on the game canvas
+3. Use keyboard controls:
+   - **WASD** - Movement
+   - **Space** - Jump  
+   - **Arrow keys** - Camera
+   - **1,2,3** - Weapons
+   - **R** - Reload
+   - **M** - Switch Human/AI mode
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **Model not loading**:
+   - Check checkpoint file exists
+   - Verify file size (<5GB for Spaces)
+   - Use Git LFS for large files
+
+2. **Import errors**:
+   - Check `requirements.txt` is complete
+   - Verify Python path in `Dockerfile`
+
+3. **Performance issues**:
+   - Use GPU hardware tier
+   - Reduce model complexity
+   - Lower frame rate
+
+4. **WebSocket connection failed**:
+   - Check firewall settings
+   - Verify port 7860 is accessible
+   - Try different browser
+
+### Debug Mode
+
+Enable debug logging:
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+## 📊 Monitoring
+
+Monitor your Space:
+- View logs in HF Spaces interface
+- Check GPU utilization
+- Monitor user sessions
+
+## 🔄 Updates
+
+To update your deployed Space:
+```bash
+git pull  # Get latest changes
+git add .
+git commit -m "Update to latest version"
+git push  # Automatically redeploys
+```
+
+## 💡 Tips for Success
+
+1. **Start with CPU tier** to test basic functionality
+2. **Use smaller models** for faster loading
+3. **Test thoroughly locally** before deploying
+4. **Monitor resource usage** to optimize costs
+5. **Add usage instructions** in your Space README
+
+## 🎯 Next Steps
+
+After successful deployment:
+- Share your Space with the community
+- Collect user feedback
+- Iterate on the interface
+- Add new features like replay saving
+- Consider multi-user support
+
+Happy deploying! 🚀

HF_SPACES_CACHE_FIX.md

@@ -0,0 +1,84 @@
+# 🔧 HF Spaces Cache Permission Fix
+
+## ❌ **Problem:**
+```
+ERROR:app:Failed to load model: [Errno 13] Permission denied: '/.cache'
+```
+
+HF Spaces containers can't write to the root `/.cache` directory, causing model downloads to fail.
+
+## ✅ **Solution Applied:**
+
+### 1. **Fixed Cache Directory in app.py**
+- ✅ Set custom cache directory: `/tmp/torch_cache`
+- ✅ Added proper permissions handling
+- ✅ Fixed OMP_NUM_THREADS environment variable issue
+
+### 2. **Updated Dockerfile**
+- ✅ Set environment variables to use `/tmp` for caches
+- ✅ Pre-create cache directories
+- ✅ Fixed OMP_NUM_THREADS value
+
+### 3. **Key Changes Made:**
+
+#### **app.py Changes:**
+```python
+# Fixed cache directory for torch.hub
+state_dict = torch.hub.load_state_dict_from_url(
+    model_url, 
+    map_location=device,
+    model_dir=cache_dir,          # Custom cache dir
+    check_hash=False              # Skip hash check for speed
+)
+
+# Fixed environment variables
+os.environ["OMP_NUM_THREADS"] = "2"   # Valid integer
+os.environ["TORCH_HOME"] = "/tmp/torch"
+os.environ["HF_HOME"] = "/tmp/huggingface"
+```
+
+#### **Dockerfile Changes:**
+```dockerfile
+ENV OMP_NUM_THREADS=2
+ENV TORCH_HOME=/tmp/torch
+ENV HF_HOME=/tmp/huggingface
+ENV TRANSFORMERS_CACHE=/tmp/transformers
+
+RUN mkdir -p /tmp/torch /tmp/huggingface /tmp/transformers
+```
+
+## 🚀 **Expected Results:**
+- ✅ No more "Permission denied: /.cache" errors
+- ✅ No more "Invalid value for environment variable OMP_NUM_THREADS" warnings
+- ✅ Model downloads work properly on HF Spaces
+- ✅ App starts correctly and clicking works
+
+## 📋 **To Deploy:**
+1. **Commit the changes**: `git add . && git commit -m "Fix HF Spaces cache permissions"`
+2. **Push to HF Spaces**: `git push`
+3. **Monitor logs**: Check that download succeeds without permission errors
+4. **Test**: Click the game area - should work now!
+
+## 🔍 **Log Messages to Look For:**
+### ✅ **Success:**
+```
+INFO:app:Loading state dict from https://huggingface.co/Etadingrui/diamond-1B/resolve/main/agent_epoch_00003.pt
+INFO:app:State dict loaded, applying to agent...
+INFO:app:Model has actor_critic weights: False
+INFO:app:Actor-critic model exists but has no trained weights - using dummy mode!
+INFO:app:WebPlayEnv set to human control mode (no trained weights)
+INFO:app:Models initialized successfully!
+```
+
+### ❌ **If Still Failing:**
+```
+ERROR:app:Failed to load model: [Errno 13] Permission denied
+```
+
+## 🎯 **What This Fixes:**
+1. ✅ **Model downloading** - now uses writable `/tmp` directory
+2. ✅ **Environment variables** - OMP_NUM_THREADS is valid
+3. ✅ **Game clicking** - works after model loads (even without actor_critic)
+4. ✅ **HF Spaces compatibility** - follows container best practices
+
+The app should now work perfectly on HF Spaces! 🎉

HF_SPACES_DEPLOYMENT_GUIDE.md

@@ -0,0 +1,201 @@
+# 🚀 Hugging Face Spaces Deployment - Troubleshooting Guide
+
+## ✅ **Your Local Fix Applied**
+Great news! The core issue has been resolved locally. The problem was that the downloaded model doesn't contain `actor_critic` weights, but the code assumed it did. This caused a `NoneType` error when clicking to start the game.
+
+**Fixed**: The app now properly detects when `actor_critic` weights are missing and falls back to human control mode instead of crashing.
+
+## 🔍 **Potential HF Spaces Issues & Solutions**
+
+### **Issue 1: Model Download Timeouts** ⏰
+
+**Symptoms:**
+- "Model loading timed out" message
+- App shows loading forever
+- Click doesn't start the game
+
+**Root Cause:** HF Spaces network can be slower, 5-minute timeout may not be enough.
+
+**Solution:**
+```python
+# In app.py, update the timeout in _load_model_from_url_async():
+success = await asyncio.wait_for(future, timeout=900.0)  # 15 minutes instead of 5
+```
+
+### **Issue 2: Memory Limitations** 💾
+
+**Symptoms:**
+- App crashes during model loading
+- "Out of memory" errors in logs
+- Models load but inference fails
+
+**Root Cause:** HF Spaces free tier has only 16GB RAM.
+
+**Quick Fix:** Force CPU-only mode
+```python
+# Add at the top of app.py
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # Force CPU mode for HF Spaces
+```
+
+**Better Solution:** Add memory management
+```python
+# Add memory cleanup after model loading
+import gc
+gc.collect()
+if torch.cuda.is_available():
+    torch.cuda.empty_cache()
+```
+
+### **Issue 3: WebSocket Connection Failures** 🔌
+
+**Symptoms:**
+- "Connection Error" or "Disconnected" status
+- Click works but no response
+- Frequent reconnections
+
+**Root Cause:** HF Spaces proxy/domain restrictions.
+
+**Solution:** Update the WebSocket connection code in the HTML template:
+```javascript
+// Replace the connectWebSocket function in app.py HTML
+function connectWebSocket() {
+    const isHFSpaces = window.location.hostname.includes('huggingface.co');
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const wsUrl = `${protocol}//${window.location.host}/ws`;
+    
+    ws = new WebSocket(wsUrl);
+    
+    // Longer timeout for HF Spaces
+    const timeout = isHFSpaces ? 30000 : 10000;
+    
+    const connectTimer = setTimeout(() => {
+        if (ws.readyState !== WebSocket.OPEN) {
+            ws.close();
+            setTimeout(connectWebSocket, 5000); // Retry after 5s
+        }
+    }, timeout);
+    
+    ws.onopen = function(event) {
+        clearTimeout(connectTimer);
+        statusEl.textContent = 'Connected';
+        statusEl.style.color = '#00ff00';
+        
+        // Re-send start if user already clicked
+        if (gameStarted && !gamePlaying) {
+            ws.send(JSON.stringify({ type: 'start' }));
+        }
+    };
+}
+```
+
+### **Issue 4: Actor-Critic Model Missing** 🧠
+
+**Already Fixed!** ✅ The app now handles this gracefully:
+- Detects missing `actor_critic` weights
+- Falls back to human control mode  
+- Shows proper warning messages
+- Game still works (user can control manually)
+
+### **Issue 5: Dockerfile Optimization** 🐳
+
+**Update your Dockerfile for HF Spaces:**
+```dockerfile
+# Add these optimizations
+ENV SHM_SIZE=2g
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512
+ENV OMP_NUM_THREADS=4
+
+# Add health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s \
+  CMD curl --fail http://localhost:7860/health || exit 1
+```
+
+## 🚀 **Quick Deployment Checklist**
+
+### **Before Deploying:**
+1. ✅ **Test locally with conda**: `conda activate diamond && python run_web_demo.py`
+2. ✅ **Verify the fix works**: Click should now work (even without actor_critic weights)
+3. ✅ **Check model download**: Test internet connectivity for HF model URL
+
+### **For HF Spaces Deployment:**
+
+1. **Update timeout values:**
+   ```python
+   # In app.py line ~153
+   success = await asyncio.wait_for(future, timeout=900.0)  # 15 min
+   ```
+
+2. **Add health check endpoint:**
+   ```python
+   @app.get("/health")
+   async def health_check():
+       return {
+           "status": "healthy",
+           "models_ready": game_engine.models_ready,
+           "actor_critic_loaded": game_engine.actor_critic_loaded
+       }
+   ```
+
+3. **Force CPU mode for free tier:**
+   ```python
+   # Add at app.py startup
+   os.environ["CUDA_VISIBLE_DEVICES"] = ""
+   ```
+
+4. **Update Dockerfile** with the optimizations above
+
+5. **Test WebSocket connection** - add the improved connection handling
+
+## 🔧 **Debugging on HF Spaces**
+
+### **Check Logs:**
+1. Go to your Space page on HuggingFace
+2. Click "Logs" tab
+3. Look for these messages:
+   - ✅ `"Actor-critic model exists but has no trained weights - using dummy mode!"`
+   - ✅ `"WebPlayEnv set to human control mode"`
+   - ❌ `"Model loading timed out"`
+   - ❌ `"WebSocket error"`
+
+### **Test Health Endpoint:**
+- Visit: `https://your-space.hf.space/health`
+- Should return JSON with status info
+
+### **Browser Console:**
+- Open Developer Tools (F12)
+- Check for WebSocket connection errors
+- Look for JavaScript errors during click
+
+## 🎯 **Expected Behavior After Fixes**
+
+1. **App loads** → Shows loading progress bar
+2. **Models initialize** → Either loads actor_critic OR shows "no trained weights"  
+3. **User clicks game area** → Game starts immediately (no hanging)
+4. **If actor_critic missing** → User gets manual control (still playable!)
+5. **If actor_critic loaded** → AI takes control automatically
+
+## 🆘 **If Issues Persist**
+
+**Quick Diagnostic:**
+```python
+# Add this test endpoint to app.py
+@app.get("/debug")
+async def debug_info():
+    return {
+        "models_ready": game_engine.models_ready,
+        "actor_critic_loaded": game_engine.actor_critic_loaded,
+        "loading_status": game_engine.loading_status,
+        "game_started": game_engine.game_started,
+        "obs_shape": str(game_engine.obs.shape) if game_engine.obs is not None else "None",
+        "connected_clients": len(connected_clients),
+        "cuda_available": torch.cuda.is_available(),
+        "device_count": torch.cuda.device_count() if torch.cuda.is_available() else 0
+    }
+```
+
+Visit `/debug` endpoint to see the current state.
+
+**Most Common Issue:** If clicking still doesn't work on HF Spaces, it's usually the WebSocket connection. Update the connection handling as described above.
+
+The core model/clicking issue is now fixed - the remaining items are deployment optimizations for HF Spaces' specific environment! 🎉

HF_SPACES_GPU_FIX.md

@@ -0,0 +1,155 @@
+# 🚀 HF Spaces GPU Acceleration Fix
+
+## ❌ **Problem Identified:**
+Your T4 GPU wasn't being used because:
+
+1. **Dockerfile disabled CUDA**: `ENV CUDA_VISIBLE_DEVICES=""` 
+2. **Environment variable issues**: OMP_NUM_THREADS causing warnings
+3. **App running on CPU**: Despite having T4 GPU hardware
+
+## ✅ **Complete Fix Applied:**
+
+### **1. Dockerfile Changes**
+```dockerfile
+# REMOVED this line that was disabling GPU:
+# ENV CUDA_VISIBLE_DEVICES=""  
+
+# Fixed environment variables:
+ENV OMP_NUM_THREADS=2
+ENV MKL_NUM_THREADS=2
+```
+
+### **2. App.py Improvements**
+- ✅ **Fixed OMP_NUM_THREADS early**: Set before any imports
+- ✅ **Improved GPU detection**: Better logging and detection
+- ✅ **Cache directories**: Moved setup to very beginning
+
+### **3. Environment Variable Priority**
+Environment variables are now set in this order:
+1. **Dockerfile** - Base container settings
+2. **app.py top** - Python-level fixes (before imports)
+3. **HF Spaces** - Runtime overrides
+
+## 🎯 **Expected Results After Fix:**
+
+### **Before (CPU mode):**
+```
+INFO:app:Using device: cpu
+INFO:app:CUDA not available, using CPU - this is normal for HF Spaces free tier
+CPU 56%
+GPU 0%
+GPU VRAM 0/16 GB
+```
+
+### **After (GPU mode):**
+```
+INFO:app:Using device: cuda
+INFO:app:CUDA available: True
+INFO:app:GPU device count: 1
+INFO:app:Current GPU: Tesla T4
+INFO:app:GPU memory: 15.1 GB
+INFO:app:🚀 GPU acceleration enabled!
+```
+
+### **Performance Improvement:**
+- **CPU usage**: Should drop to ~20-30%
+- **GPU usage**: Should show 10-50% during AI inference
+- **GPU VRAM**: Should show 2-4GB usage
+- **AI FPS**: Should increase from ~2 FPS to 10+ FPS
+
+## 📋 **Deployment Steps:**
+
+1. **Commit and push changes:**
+   ```bash
+   git add .
+   git commit -m "Enable GPU acceleration for HF Spaces T4"
+   git push
+   ```
+
+2. **Wait for rebuild** (HF Spaces will restart automatically)
+
+3. **Check new logs** for GPU detection:
+   ```
+   INFO:app:🚀 GPU acceleration enabled!
+   ```
+
+4. **Monitor system stats:**
+   - GPU usage should now show activity
+   - GPU VRAM should show memory allocation
+   - Overall performance should be much faster
+
+## 🔍 **Debugging Commands:**
+
+### **Check CUDA in container:**
+```python
+import torch
+print(f"CUDA available: {torch.cuda.is_available()}")
+print(f"GPU count: {torch.cuda.device_count()}")
+if torch.cuda.is_available():
+    print(f"GPU name: {torch.cuda.get_device_name(0)}")
+```
+
+### **Check environment variables:**
+```python
+import os
+print(f"CUDA_VISIBLE_DEVICES: {os.environ.get('CUDA_VISIBLE_DEVICES', 'Not set')}")
+print(f"OMP_NUM_THREADS: {os.environ.get('OMP_NUM_THREADS')}")
+```
+
+## 🚨 **If GPU Still Not Working:**
+
+### **1. Verify HF Spaces Hardware:**
+- Check your Space settings
+- Ensure "T4 small" or "T4 medium" is selected
+- Free tier doesn't have GPU access
+
+### **2. Check Container Logs:**
+Look for these messages:
+- ✅ `"🚀 GPU acceleration enabled!"`
+- ❌ `"CUDA not available"`
+
+### **3. Alternative: Force GPU Detection**
+If needed, add this debug code to app.py:
+```python
+# Debug GPU detection
+logger.info(f"Environment CUDA_VISIBLE_DEVICES: {os.environ.get('CUDA_VISIBLE_DEVICES', 'Not set')}")
+logger.info(f"PyTorch CUDA compiled: {torch.version.cuda}")
+logger.info(f"PyTorch version: {torch.__version__}")
+```
+
+## ⚡ **Performance Optimization Tips:**
+
+### **For T4 GPU:**
+1. **Enable model compilation** (optional):
+   ```bash
+   # Set environment variable in HF Spaces settings:
+   ENABLE_TORCH_COMPILE=1
+   ```
+
+2. **Increase AI FPS** (if needed):
+   ```python
+   # In app.py, line ~86:
+   self.ai_fps = 15  # Increase from 10 to 15
+   ```
+
+3. **Monitor GPU memory**:
+   - T4 has 16GB VRAM
+   - App should use 2-4GB
+   - Leave headroom for other processes
+
+## 🎮 **Expected User Experience:**
+
+1. **Faster loading**: Models load to GPU memory
+2. **Responsive gameplay**: AI inference runs at 10+ FPS
+3. **Smoother visuals**: Display updates without lag
+4. **Better AI performance**: GPU acceleration improves model inference
+
+Your HF Spaces deployment should now fully utilize the T4 GPU! 🚀
+
+## 📊 **Monitor These Metrics:**
+- **GPU Utilization**: 10-50% during gameplay
+- **GPU Memory**: 2-4GB allocated
+- **AI FPS**: 10-15 FPS (displayed in web interface)
+- **CPU Usage**: Should decrease to 20-30%
+
+The game should feel much more responsive now! 🎉

app.py.backup

@@ -0,0 +1,1114 @@
+"""
+Web-based Diamond CSGO AI Player for Hugging Face Spaces
+Uses FastAPI + WebSocket for real-time keyboard input and game streaming
+"""
+
+# Fix environment variables FIRST, before any other imports
+import os
+import tempfile
+
+# Fix OMP_NUM_THREADS immediately (before PyTorch/NumPy imports)
+if "OMP_NUM_THREADS" not in os.environ or not os.environ.get("OMP_NUM_THREADS", "").isdigit():
+    os.environ["OMP_NUM_THREADS"] = "2"
+
+# Set up cache directories immediately
+temp_dir = tempfile.gettempdir()
+os.environ.setdefault("TORCH_HOME", os.path.join(temp_dir, "torch"))
+os.environ.setdefault("HF_HOME", os.path.join(temp_dir, "huggingface"))
+os.environ.setdefault("TRANSFORMERS_CACHE", os.path.join(temp_dir, "transformers"))
+
+# Create cache directories
+for cache_var in ["TORCH_HOME", "HF_HOME", "TRANSFORMERS_CACHE"]:
+    cache_path = os.environ[cache_var]
+    os.makedirs(cache_path, exist_ok=True)
+
+import asyncio
+import base64
+import io
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+import cv2
+import numpy as np
+import torch
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from hydra import compose, initialize
+from hydra.utils import instantiate
+from omegaconf import DictConfig, OmegaConf
+from PIL import Image
+
+# Import your modules
+import sys
+from pathlib import Path
+
+# Add project root to path for src package imports
+project_root = Path(__file__).parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+from src.agent import Agent
+from src.csgo.web_action_processing import WebCSGOAction, web_keys_to_csgo_action_names
+from src.envs import WorldModelEnv
+from src.game.web_play_env import WebPlayEnv
+from src.utils import extract_state_dict
+from config_web import web_config
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global variables
+app = FastAPI(title="Diamond CSGO AI Player")
+
+# Set safe defaults for headless CI/Spaces environments
+os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
+os.environ.setdefault("SDL_AUDIODRIVER", "dummy")
+os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1")
+
+# Environment variables already set at top of file
+connected_clients: Set[WebSocket] = set()
+
+class WebKeyMap:
+    """Map web key codes to pygame-like keys for CSGO actions"""
+    WEB_TO_CSGO = {
+        'KeyW': 'w',
+        'KeyA': 'a', 
+        'KeyS': 's',
+        'KeyD': 'd',
+        'Space': 'space',
+        'ControlLeft': 'left ctrl',
+        'ShiftLeft': 'left shift',
+        'Digit1': '1',
+        'Digit2': '2', 
+        'Digit3': '3',
+        'KeyR': 'r',
+        'ArrowUp': 'camera_up',
+        'ArrowDown': 'camera_down',
+        'ArrowLeft': 'camera_left',
+        'ArrowRight': 'camera_right'
+    }
+
+class WebGameEngine:
+    """Web-compatible game engine that replaces pygame functionality"""
+    
+    def __init__(self):
+        self.play_env: Optional[WebPlayEnv] = None
+        self.obs = None
+        self.running = False
+        self.game_started = False
+        self.fps = 30  # Display FPS
+        self.ai_fps = 15  # AI inference FPS (matching standalone play.py performance)
+        self.frame_count = 0
+        self.ai_frame_count = 0
+        self.last_ai_time = 0
+        self.start_time = 0  # Track when AI started for proper FPS calculation
+        self.last_frame_send_time = 0  # Track frame sending for optimization
+        self.web_fps = 20  # Web display FPS (lower than AI FPS to reduce network overhead)
+        self.pressed_keys: Set[str] = set()
+        self.mouse_x = 0
+        self.mouse_y = 0
+        self.l_click = False
+        self.r_click = False
+        self.should_reset = False
+        self.cached_obs = None  # Cache last observation for frame skipping
+        self.first_inference_done = False  # Track if first inference completed
+        self.models_ready = False  # Track if models are loaded
+        self.download_progress = 0  # Track download progress (0-100)
+        self.loading_status = "Initializing..."  # Loading status message
+        self.actor_critic_loaded = False  # Track if actor_critic was loaded with trained weights
+        import time
+        self.time_module = time
+    
+    async def _load_model_from_url_async(self, agent, device):
+        """Load model from URL using torch.hub (HF Spaces compatible)"""
+        import asyncio
+        import concurrent.futures
+        
+        def load_model_weights():
+            """Load model weights in thread pool to avoid blocking"""
+            try:
+                logger.info("Loading model using torch.hub.load_state_dict_from_url...")
+                self.loading_status = "Downloading model..."
+                self.download_progress = 10
+                
+                model_url = "https://huggingface.co/Etadingrui/diamond-1B/resolve/main/agent_epoch_00003.pt"
+                
+                # Use torch.hub to download and load state dict with custom cache dir
+                logger.info(f"Loading state dict from {model_url}")
+                
+                # Set custom cache directory that we have write permissions for
+                cache_dir = os.path.join(tempfile.gettempdir(), "torch_cache")
+                os.makedirs(cache_dir, exist_ok=True)
+                
+                # Use torch.hub with custom cache directory
+                state_dict = torch.hub.load_state_dict_from_url(
+                    model_url, 
+                    map_location=device,
+                    model_dir=cache_dir,
+                    check_hash=False  # Skip hash check for faster loading
+                )
+                
+                self.download_progress = 60
+                self.loading_status = "Loading model weights into agent..."
+                logger.info("State dict loaded, applying to agent...")
+                
+                # Load state dict into agent, but skip actor_critic if not present
+                has_actor_critic = any(k.startswith('actor_critic.') for k in state_dict.keys())
+                logger.info(f"Model has actor_critic weights: {has_actor_critic}")
+                agent.load_state_dict(state_dict, load_actor_critic=has_actor_critic)
+                
+                # Track if actor_critic was actually loaded with trained weights
+                self.actor_critic_loaded = has_actor_critic
+                
+                self.download_progress = 100
+                self.loading_status = "Model loaded successfully!"
+                logger.info("All model weights loaded successfully!")
+                return True
+                
+            except Exception as e:
+                logger.error(f"Failed to load model: {e}")
+                import traceback
+                traceback.print_exc()
+                return False
+            
+        # Run in thread pool to avoid blocking with timeout
+        loop = asyncio.get_event_loop()
+        try:
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                # Add timeout for model loading (5 minutes max)
+                future = loop.run_in_executor(executor, load_model_weights)
+                success = await asyncio.wait_for(future, timeout=300.0)  # 5 minute timeout
+                return success
+        except asyncio.TimeoutError:
+            logger.error("Model loading timed out after 5 minutes")
+            self.loading_status = "Model loading timed out - using dummy mode"
+            return False
+        except Exception as e:
+            logger.error(f"Error in model loading executor: {e}")
+            self.loading_status = f"Model loading error: {str(e)[:50]}..."
+            return False
+        
+    async def initialize_models(self):
+        """Initialize the AI models and environment"""
+        try:
+            import torch
+            logger.info("Initializing models...")
+            
+            # Setup environment and paths
+            web_config.setup_environment_variables()
+            web_config.create_default_configs()
+            
+            config_path = web_config.get_config_path()
+            logger.info(f"Using config path: {config_path}")
+            
+            # For Hydra, use relative path from app.py location
+            # Since app.py is in project root, config is simply "config"
+            relative_config_path = "config"
+            logger.info(f"Relative config path: {relative_config_path}")
+                
+            with initialize(version_base="1.3", config_path=relative_config_path):
+                cfg = compose(config_name="trainer")
+            
+            # Override config for deployment
+            cfg.agent = OmegaConf.load(config_path / "agent" / "csgo.yaml")
+            cfg.env = OmegaConf.load(config_path / "env" / "csgo.yaml") 
+            
+            # Use GPU if available, otherwise fall back to CPU
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            logger.info(f"Using device: {device}")
+            
+            # Log GPU availability and CUDA info for debugging
+            if torch.cuda.is_available():
+                logger.info(f"CUDA available: {torch.cuda.is_available()}")
+                logger.info(f"GPU device count: {torch.cuda.device_count()}")
+                logger.info(f"Current GPU: {torch.cuda.get_device_name(0)}")
+                logger.info(f"GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
+                logger.info("🚀 GPU acceleration enabled!")
+            else:
+                logger.info("CUDA not available, using CPU mode")
+            
+            # Initialize agent first
+            num_actions = cfg.env.num_actions
+            agent = Agent(instantiate(cfg.agent, num_actions=num_actions)).to(device).eval()
+            
+            # Get spawn directory
+            spawn_dir = web_config.get_spawn_dir()
+            
+            # Try to load checkpoint (remote first, then local, then dummy mode)
+            try:
+                # First try to load from Hugging Face Hub using torch.hub
+                logger.info("Loading model from Hugging Face Hub with torch.hub...")
+                
+                success = await self._load_model_from_url_async(agent, device)
+                
+                if success:
+                    logger.info("Successfully loaded checkpoint from HF Hub")
+                else:
+                    # Fallback to local checkpoint if available
+                    logger.error("Failed to load from HF Hub! Check the detailed error above.")
+                    checkpoint_path = web_config.get_checkpoint_path()
+                    if checkpoint_path.exists():
+                        logger.info(f"Loading local checkpoint: {checkpoint_path}")
+                        self.loading_status = "Loading local checkpoint..."
+                        agent.load(checkpoint_path)
+                        logger.info(f"Successfully loaded local checkpoint: {checkpoint_path}")
+                        # Assume local checkpoint has actor_critic weights (may need verification)
+                        self.actor_critic_loaded = True
+                    else:
+                        logger.error(f"No local checkpoint found at: {checkpoint_path}")
+                        raise FileNotFoundError("No model checkpoint available (local or remote)")
+                        
+            except Exception as e:
+                logger.error(f"Failed to load any checkpoint: {e}")
+                self._init_dummy_mode()
+                self.actor_critic_loaded = False  # No actor_critic in dummy mode
+                return True
+            
+            # Initialize world model environment
+            try:
+                sl = cfg.agent.denoiser.inner_model.num_steps_conditioning
+                if agent.upsampler is not None:
+                    sl = max(sl, cfg.agent.upsampler.inner_model.num_steps_conditioning)
+                wm_env_cfg = instantiate(cfg.world_model_env, num_batches_to_preload=1)
+                wm_env = WorldModelEnv(agent.denoiser, agent.upsampler, agent.rew_end_model, 
+                                     spawn_dir, 1, sl, wm_env_cfg, return_denoising_trajectory=True)
+                
+                # Create play environment
+                self.play_env = WebPlayEnv(agent, wm_env, False, False, False)
+                
+                # Verify actor-critic is loaded and ready for inference
+                if agent.actor_critic is not None and self.actor_critic_loaded:
+                    logger.info(f"Actor-critic model loaded with {agent.actor_critic.lstm_dim} LSTM dimensions")
+                    logger.info(f"Actor-critic device: {agent.actor_critic.device}")
+                    # Force AI control for web demo
+                    self.play_env.is_human_player = False
+                    logger.info("WebPlayEnv set to AI control mode")
+                elif agent.actor_critic is not None and not self.actor_critic_loaded:
+                    logger.warning("Actor-critic model exists but has no trained weights - using dummy mode!")
+                    self.play_env.is_human_player = True
+                    logger.info("WebPlayEnv set to human control mode (no trained weights)")
+                else:
+                    logger.warning("No actor-critic model found - AI inference will not work!")
+                    self.play_env.is_human_player = True
+                    logger.info("WebPlayEnv set to human control mode (fallback)")
+                
+                # Enable model compilation for better performance (like standalone play.py)
+                # This gives 20-50% speedup but causes 10-30s delay on first inference
+                import os
+                enable_compile = device.type == "cuda" and os.getenv("ENABLE_TORCH_COMPILE", "1") == "1"
+                
+                if enable_compile:
+                    logger.info("🚀 Compiling models for faster inference (like standalone play.py)...")
+                    logger.info("⏱️  First inference will take 10-30s, but subsequent inferences will be much faster!")
+                    try:
+                        wm_env.predict_next_obs = torch.compile(wm_env.predict_next_obs, mode="reduce-overhead")
+                        if wm_env.upsample_next_obs is not None:
+                            wm_env.upsample_next_obs = torch.compile(wm_env.upsample_next_obs, mode="reduce-overhead")
+                        logger.info("✅ Model compilation enabled - expect 20-50% speedup!")
+                    except Exception as e:
+                        logger.warning(f"Model compilation failed: {e}")
+                        enable_compile = False
+                
+                if not enable_compile:
+                    logger.info("Model compilation disabled. Set ENABLE_TORCH_COMPILE=1 for better performance.")
+                
+                # Reset environment
+                self.obs, _ = self.play_env.reset()
+                self.cached_obs = self.obs  # Initialize cache
+                
+                logger.info("Models initialized successfully!")
+                logger.info(f"Initial observation shape: {self.obs.shape if self.obs is not None else 'None'}")
+                self.models_ready = True
+                self.loading_status = "Ready!"
+                return True
+                
+            except Exception as e:
+                logger.error(f"Failed to initialize world model environment: {e}")
+                self._init_dummy_mode()
+                self.actor_critic_loaded = False  # No actor_critic in dummy mode
+                self.models_ready = True
+                self.loading_status = "Using dummy mode"
+                return True
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize models: {e}")
+            import traceback
+            traceback.print_exc()
+            self._init_dummy_mode()
+            self.actor_critic_loaded = False  # No actor_critic in dummy mode
+            self.models_ready = True
+            self.loading_status = "Error - using dummy mode"
+            return True
+    
+    def _init_dummy_mode(self):
+        """Initialize dummy mode for testing without models"""
+        logger.info("Initializing dummy mode...")
+        
+        # Create a test observation
+        height, width = 150, 600
+        img_array = np.zeros((height, width, 3), dtype=np.uint8)
+        
+        # Add test pattern
+        for y in range(height):
+            for x in range(width):
+                img_array[y, x, 0] = (x % 256)  # Red gradient
+                img_array[y, x, 1] = (y % 256)  # Green gradient  
+                img_array[y, x, 2] = ((x + y) % 256)  # Blue pattern
+        
+        # Convert to torch tensor in expected format [-1, 1]
+        tensor = torch.from_numpy(img_array).float().permute(2, 0, 1)  # CHW format
+        tensor = tensor.div(255).mul(2).sub(1)  # Convert to [-1, 1] range
+        tensor = tensor.unsqueeze(0)  # Add batch dimension
+        
+        self.obs = tensor
+        self.play_env = None  # No real environment in dummy mode
+        logger.info("Dummy mode initialized with test pattern")
+    
+    
+    def step_environment(self):
+        """Step the environment with current input state (with intelligent frame skipping)"""
+        if self.play_env is None:
+            # Dummy mode - just return current observation
+            return self.obs, 0.0, False, False, {"mode": "dummy"}
+            
+        try:
+            # Check if reset is requested
+            if self.should_reset:
+                self.reset_environment()
+                self.should_reset = False
+                self.last_ai_time = self.time_module.time()  # Reset AI timer
+                return self.obs, 0.0, False, False, {"reset": True}
+            
+            # Intelligent frame skipping: only run AI inference at target FPS
+            current_time = self.time_module.time()
+            time_since_last_ai = current_time - self.last_ai_time
+            should_run_ai = time_since_last_ai >= (1.0 / self.ai_fps)
+            
+            if should_run_ai:
+                # Show loading indicator for first inference (can be slow)
+                if not self.first_inference_done:
+                    logger.info("Running first AI inference (may take 5-15 seconds)...")
+                
+                # Run AI inference
+                inference_start = self.time_module.time()
+                next_obs, reward, done, truncated, info = self.play_env.step_from_web_input(
+                    pressed_keys=self.pressed_keys,
+                    mouse_x=self.mouse_x,
+                    mouse_y=self.mouse_y,
+                    l_click=self.l_click,
+                    r_click=self.r_click
+                )
+                inference_time = self.time_module.time() - inference_start
+                
+                # Log first inference completion
+                if not self.first_inference_done:
+                    self.first_inference_done = True
+                    logger.info(f"First AI inference completed in {inference_time:.2f}s - subsequent inferences will be faster!")
+                
+                # Cache the new observation and update timing
+                self.cached_obs = next_obs
+                self.last_ai_time = current_time
+                self.ai_frame_count += 1
+                
+                # Add AI performance info
+                info = info or {}
+                info["ai_inference"] = True
+                
+                # Calculate proper AI FPS: frames / elapsed time since start
+                elapsed_time = current_time - self.start_time
+                if elapsed_time > 0 and self.ai_frame_count > 0:
+                    ai_fps = self.ai_frame_count / elapsed_time
+                    # Cap at reasonable maximum (shouldn't exceed 100 FPS for AI inference)
+                    info["ai_fps"] = min(ai_fps, 100.0)
+                else:
+                    info["ai_fps"] = 0
+                
+                info["inference_time"] = inference_time
+                
+                return next_obs, reward, done, truncated, info
+            else:
+                # Use cached observation for smoother display without AI overhead
+                obs_to_return = self.cached_obs if self.cached_obs is not None else self.obs
+                
+                # Calculate AI FPS for cached frames too
+                elapsed_time = current_time - self.start_time
+                if elapsed_time > 0 and self.ai_frame_count > 0:
+                    ai_fps = min(self.ai_frame_count / elapsed_time, 100.0)  # Cap at 100 FPS
+                else:
+                    ai_fps = 0
+                
+                return obs_to_return, 0.0, False, False, {"cached": True, "ai_fps": ai_fps}
+            
+        except Exception as e:
+            logger.error(f"Error stepping environment: {e}")
+            obs_to_return = self.cached_obs if self.cached_obs is not None else self.obs
+            return obs_to_return, 0.0, False, False, {"error": str(e)}
+    
+    def reset_environment(self):
+        """Reset the environment"""
+        try:
+            if self.play_env is not None:
+                self.obs, _ = self.play_env.reset()
+                self.cached_obs = self.obs  # Update cache
+                logger.info("Environment reset successfully")
+            else:
+                # Dummy mode - recreate test pattern
+                self._init_dummy_mode()
+                self.cached_obs = self.obs  # Update cache
+                logger.info("Dummy environment reset")
+        except Exception as e:
+            logger.error(f"Error resetting environment: {e}")
+    
+    def request_reset(self):
+        """Request environment reset on next step"""
+        self.should_reset = True
+        logger.info("Environment reset requested")
+    
+    def start_game(self):
+        """Start the game"""
+        self.game_started = True
+        self.start_time = self.time_module.time()  # Reset start time for FPS calculation
+        self.ai_frame_count = 0  # Reset AI frame count
+        logger.info("Game started")
+    
+    def pause_game(self):
+        """Pause/stop the game"""
+        self.game_started = False
+        logger.info("Game paused")
+    
+    def obs_to_base64(self, obs: torch.Tensor) -> str:
+        """Convert observation tensor to base64 image for web display (optimized for speed)"""
+        if obs is None:
+            return ""
+            
+        try:
+            # Handle observation tensor conversion based on dimensions
+            if obs.ndim == 4 and obs.size(0) == 1:
+                # 4D tensor with batch dimension [1, C, H, W] -> [C, H, W]
+                img_tensor = obs[0]
+            elif obs.ndim == 3:
+                # 3D tensor [C, H, W] 
+                img_tensor = obs
+            elif obs.ndim == 2:
+                # 2D tensor - likely an error, return empty string
+                logger.warning(f"Unexpected 2D observation tensor: {obs.shape}")
+                return ""
+            else:
+                logger.warning(f"Unexpected observation dimensions: {obs.shape}")
+                return ""
+            
+            # Convert to numpy with proper range conversion
+            img_array = img_tensor.mul(127.5).add_(127.5).clamp_(0, 255).byte()
+            img_array = img_array.permute(1, 2, 0).cpu().numpy()
+            
+            # Direct resize with OpenCV (much faster than PIL)
+            img_array = cv2.resize(img_array, (600, 150), interpolation=cv2.INTER_NEAREST)
+            
+            # Convert BGR to RGB if needed (OpenCV uses BGR)
+            if img_array.shape[2] == 3:
+                img_array = cv2.cvtColor(img_array, cv2.COLOR_BGR2RGB)
+            
+            # Optimized JPEG encoding with OpenCV (faster than PIL)
+            success, buffer = cv2.imencode('.jpg', img_array, [cv2.IMWRITE_JPEG_QUALITY, 80])
+            if success:
+                img_str = base64.b64encode(buffer).decode()
+                return f"data:image/jpeg;base64,{img_str}"
+            else:
+                logger.warning("Frame encoding failed, using fallback")
+                return ""
+            
+        except Exception as e:
+            logger.error(f"Error converting observation to base64: {e}")
+            return ""
+    
+    async def game_loop(self):
+        """Main game loop that runs continuously"""
+        self.running = True
+        
+        while self.running:
+            try:
+                # Check if models are ready
+                if not self.models_ready:
+                    # Send loading status to clients
+                    if connected_clients:
+                        loading_data = {
+                            'type': 'loading',
+                            'status': self.loading_status,
+                            'progress': self.download_progress,
+                            'ready': False
+                        }
+                        disconnected = set()
+                        for client in connected_clients.copy():
+                            try:
+                                await client.send_text(json.dumps(loading_data))
+                            except:
+                                disconnected.add(client)
+                        connected_clients.difference_update(disconnected)
+                    
+                    await asyncio.sleep(0.5)  # Check every 500ms during loading
+                    continue
+                
+                # Only step environment if game is started
+                if not self.game_started:
+                    # Game not started - just send current observation without stepping
+                    should_send_frame = True if (self.obs is not None and connected_clients) else False
+                    # Don't modify self.obs when game isn't started!
+                    await asyncio.sleep(0.1)
+                else:
+                    # Game is started - step environment
+                    should_send_frame = True
+                    if self.play_env is None:
+                        await asyncio.sleep(0.1)
+                        continue
+                    
+                    # Step environment with current input state
+                    next_obs, reward, done, truncated, info = self.step_environment()
+                    
+                    if done or truncated:
+                        # Auto-reset when episode ends
+                        self.reset_environment()
+                    else:
+                        self.obs = next_obs
+                
+                # Send frame to all connected clients with smart throttling for performance
+                current_time = self.time_module.time()
+                time_since_last_frame_send = current_time - self.last_frame_send_time
+                should_send_web_frame = time_since_last_frame_send >= (1.0 / self.web_fps)
+                
+                if should_send_frame and should_send_web_frame and connected_clients and self.obs is not None:
+                    # Set default values for when game isn't running
+                    if not self.game_started:
+                        reward = 0.0
+                        info = {"waiting": True}
+                    # If game is started, reward and info should be set above
+                    
+                    # Convert observation to base64
+                    image_data = self.obs_to_base64(self.obs)
+                    
+                    # Debug logging for first few frames
+                    if self.frame_count < 5:
+                        logger.info(f"Frame {self.frame_count}: obs shape={self.obs.shape if self.obs is not None else 'None'}, "
+                                  f"image_data_length={len(image_data) if image_data else 0}, "
+                                  f"game_started={self.game_started}")
+                    
+                    frame_data = {
+                        'type': 'frame',
+                        'image': image_data,
+                        'frame_count': self.frame_count,
+                        'reward': float(reward.item()) if hasattr(reward, 'item') else float(reward) if reward is not None else 0.0,
+                        'info': str(info) if info else "",
+                        'ai_fps': info.get('ai_fps', 0) if isinstance(info, dict) else 0,
+                        'is_ai_frame': info.get('ai_inference', False) if isinstance(info, dict) else False,
+                        'web_fps': self.web_fps,  # Add web FPS for monitoring
+                        'ai_target_fps': self.ai_fps  # Add target AI FPS for monitoring
+                    }
+                    
+                    # Send to all connected clients
+                    disconnected = set()
+                    for client in connected_clients.copy():
+                        try:
+                            await client.send_text(json.dumps(frame_data))
+                        except:
+                            disconnected.add(client)
+                    
+                    # Remove disconnected clients
+                    connected_clients.difference_update(disconnected)
+                    
+                    # Update frame send timing
+                    self.last_frame_send_time = current_time
+                
+                self.frame_count += 1
+                await asyncio.sleep(1.0 / self.fps)  # Control FPS
+                
+            except Exception as e:
+                logger.error(f"Error in game loop: {e}")
+                await asyncio.sleep(0.1)
+
+# Global game engine instance
+game_engine = WebGameEngine()
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize models when the app starts"""
+    # Start the game loop immediately (it will handle loading state)
+    asyncio.create_task(game_engine.game_loop())
+    
+    # Initialize models in background (non-blocking)
+    asyncio.create_task(game_engine.initialize_models())
+
+@app.get("/performance")
+async def get_performance_stats():
+    """Get current performance statistics"""
+    current_time = game_engine.time_module.time()
+    elapsed_time = current_time - game_engine.start_time if game_engine.start_time > 0 else 0
+    
+    return {
+        "ai_fps_current": game_engine.ai_frame_count / elapsed_time if elapsed_time > 0 else 0,
+        "ai_fps_target": game_engine.ai_fps,
+        "web_fps_target": game_engine.web_fps,
+        "display_fps_target": game_engine.fps,
+        "models_ready": game_engine.models_ready,
+        "actor_critic_loaded": game_engine.actor_critic_loaded,
+        "game_started": game_engine.game_started,
+        "connected_clients": len(connected_clients),
+        "total_ai_frames": game_engine.ai_frame_count,
+        "total_display_frames": game_engine.frame_count,
+        "elapsed_time": elapsed_time,
+        "torch_compile_enabled": os.environ.get("ENABLE_TORCH_COMPILE", "1") == "1",
+        "device": "cuda" if torch.cuda.is_available() else "cpu"
+    }
+
+@app.get("/", response_class=HTMLResponse)
+async def get_homepage():
+    """Serve the main game interface"""
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Physics-informed BEV World Model</title>
+        <style>
+            body {
+                margin: 0;
+                padding: 20px;
+                background: #1a1a1a;
+                color: white;
+                font-family: 'Courier New', monospace;
+                text-align: center;
+            }
+            #gameCanvas {
+                border: 2px solid #00ff00;
+                background: #000;
+                margin: 20px auto;
+                display: block;
+            }
+            #controls {
+                margin: 20px;
+                display: grid;
+                grid-template-columns: 1fr 1fr;
+                gap: 20px;
+                max-width: 800px;
+                margin: 20px auto;
+            }
+            .control-section {
+                background: #2a2a2a;
+                padding: 15px;
+                border-radius: 8px;
+                border: 1px solid #444;
+            }
+            .key-display {
+                background: #333;
+                border: 1px solid #555;
+                padding: 5px 10px;
+                margin: 2px;
+                border-radius: 4px;
+                display: inline-block;
+                min-width: 30px;
+            }
+            .key-pressed {
+                background: #00ff00;
+                color: #000;
+            }
+            #status {
+                margin: 10px;
+                padding: 10px;
+                background: #2a2a2a;
+                border-radius: 4px;
+            }
+            .info {
+                color: #00ff00;
+                margin: 5px 0;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>🎮 Physics-informed BEV World Model</h1>
+        <p><strong>Click the game canvas to start playing!</strong> Use ESC to pause, Enter to reset environment.</p>
+        <p id="loadingIndicator" style="color: #ffff00; display: none;">🚀 Starting AI inference... This may take 5-15 seconds on first run.</p>
+        
+        <!-- Model Download Progress -->
+        <div id="downloadSection" style="display: none; margin: 20px;">
+            <p id="downloadStatus" style="color: #ffaa00; margin: 10px 0;">📥 Downloading AI model...</p>
+            <div style="background: #333; border-radius: 10px; padding: 3px; width: 100%; max-width: 600px; margin: 0 auto;">
+                <div id="progressBar" style="background: linear-gradient(90deg, #00ff00, #88ff00); height: 20px; border-radius: 7px; width: 0%; transition: width 0.3s;"></div>
+            </div>
+            <p id="progressText" style="color: #aaa; font-size: 14px; margin: 5px 0;">0% - Initializing...</p>
+        </div>
+        
+        <canvas id="gameCanvas" width="600" height="150" tabindex="0"></canvas>
+        
+        <div id="status">
+            <div class="info">Status: <span id="connectionStatus">Connecting...</span></div>
+            <div class="info">Game: <span id="gameStatus">Click to Start</span></div>
+            <div class="info">Frame: <span id="frameCount">0</span> | AI FPS: <span id="aiFps">0</span></div>
+            <div class="info">Reward: <span id="reward">0</span></div>
+        </div>
+        
+        <div id="controls">
+            <div class="control-section">
+                <h3>Movement</h3>
+                <div>
+                    <span class="key-display" id="key-w">W</span> Forward<br>
+                    <span class="key-display" id="key-a">A</span> Left
+                    <span class="key-display" id="key-s">S</span> Back
+                    <span class="key-display" id="key-d">D</span> Right<br>
+                    <span class="key-display" id="key-space">Space</span> Jump
+                    <span class="key-display" id="key-ctrl">Ctrl</span> Crouch
+                    <span class="key-display" id="key-shift">Shift</span> Walk
+                </div>
+            </div>
+            
+            <div class="control-section">
+                <h3>Actions</h3>
+                <div>
+                    <span class="key-display" id="key-1">1</span> Weapon 1<br>
+                    <span class="key-display" id="key-2">2</span> Weapon 2
+                    <span class="key-display" id="key-3">3</span> Weapon 3<br>
+                    <span class="key-display" id="key-r">R</span> Reload<br>
+                    <span class="key-display" id="key-arrows">↑↓←→</span> Camera<br>
+                    <span class="key-display" id="key-enter">Enter</span> Reset Game<br>
+                    <span class="key-display" id="key-esc">Esc</span> Pause/Quit
+                </div>
+            </div>
+        </div>
+        
+        <script>
+            const canvas = document.getElementById('gameCanvas');
+            const ctx = canvas.getContext('2d');
+            const statusEl = document.getElementById('connectionStatus');
+            const gameStatusEl = document.getElementById('gameStatus');
+            const frameEl = document.getElementById('frameCount');
+            const aiFpsEl = document.getElementById('aiFps');
+            const rewardEl = document.getElementById('reward');
+            const loadingEl = document.getElementById('loadingIndicator');
+            const downloadSectionEl = document.getElementById('downloadSection');
+            const downloadStatusEl = document.getElementById('downloadStatus');
+            const progressBarEl = document.getElementById('progressBar');
+            const progressTextEl = document.getElementById('progressText');
+            
+            let ws = null;
+            let pressedKeys = new Set();
+            let gameStarted = false;
+            
+            // Key mapping
+            const keyDisplayMap = {
+                'KeyW': 'key-w',
+                'KeyA': 'key-a', 
+                'KeyS': 'key-s',
+                'KeyD': 'key-d',
+                'Space': 'key-space',
+                'ControlLeft': 'key-ctrl',
+                'ShiftLeft': 'key-shift',
+                'Digit1': 'key-1',
+                'Digit2': 'key-2',
+                'Digit3': 'key-3',
+                'KeyR': 'key-r',
+                'ArrowUp': 'key-arrows',
+                'ArrowDown': 'key-arrows',
+                'ArrowLeft': 'key-arrows',
+                'ArrowRight': 'key-arrows',
+                'Enter': 'key-enter',
+                'Escape': 'key-esc'
+            };
+            
+            function connectWebSocket() {
+                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+                const wsUrl = `${protocol}//${window.location.host}/ws`;
+                
+                ws = new WebSocket(wsUrl);
+                
+                ws.onopen = function(event) {
+                    statusEl.textContent = 'Connected';
+                    statusEl.style.color = '#00ff00';
+                    // If user already clicked to start before WS was ready, send start now
+                    if (gameStarted) {
+                        ws.send(JSON.stringify({ type: 'start' }));
+                    }
+                };
+                
+                ws.onmessage = function(event) {
+                    const data = JSON.parse(event.data);
+                    
+                    if (data.type === 'loading') {
+                        // Handle loading status
+                        downloadSectionEl.style.display = 'block';
+                        downloadStatusEl.textContent = data.status;
+                        
+                        if (data.progress !== undefined) {
+                            progressBarEl.style.width = data.progress + '%';
+                            progressTextEl.textContent = data.progress + '% - ' + data.status;
+                        } else {
+                            progressTextEl.textContent = data.status;
+                        }
+                        
+                        gameStatusEl.textContent = 'Loading Models...';
+                        gameStatusEl.style.color = '#ffaa00';
+                        
+                    } else if (data.type === 'frame') {
+                        // Hide loading indicators once we get frames
+                        downloadSectionEl.style.display = 'none';
+                        // Update frame display
+                        if (data.image) {
+                            const img = new Image();
+                            img.onload = function() {
+                                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                                ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+                            };
+                            img.src = data.image;
+                        }
+                        
+                        frameEl.textContent = data.frame_count;
+                        rewardEl.textContent = data.reward.toFixed(2);
+                        
+                        // Update AI FPS display and hide loading indicator once AI starts
+                        if (data.ai_fps !== undefined && data.ai_fps !== null) {
+                            // Ensure FPS value is reasonable
+                            const aiFps = Math.min(Math.max(data.ai_fps, 0), 100);
+                            aiFpsEl.textContent = aiFps.toFixed(1);
+                            
+                            // Color code AI FPS for performance indication
+                            if (aiFps >= 8) {
+                                aiFpsEl.style.color = '#00ff00';  // Green for good performance
+                            } else if (aiFps >= 5) {
+                                aiFpsEl.style.color = '#ffff00';  // Yellow for moderate performance
+                            } else if (aiFps > 0) {
+                                aiFpsEl.style.color = '#ff0000';  // Red for poor performance
+                            } else {
+                                aiFpsEl.style.color = '#888888';  // Gray for inactive
+                            }
+                            
+                            // Hide loading indicator once AI inference starts working
+                            if (aiFps > 0 && gameStarted) {
+                                loadingEl.style.display = 'none';
+                                gameStatusEl.textContent = 'Playing';
+                                gameStatusEl.style.color = '#00ff00';
+                            }
+                        }
+                    }
+                };
+                
+                ws.onclose = function(event) {
+                    statusEl.textContent = 'Disconnected';
+                    statusEl.style.color = '#ff0000';
+                    setTimeout(connectWebSocket, 1000); // Reconnect after 1 second
+                };
+                
+                ws.onerror = function(event) {
+                    statusEl.textContent = 'Error';
+                    statusEl.style.color = '#ff0000';
+                };
+            }
+            
+            function sendKeyState() {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'keys',
+                        keys: Array.from(pressedKeys)
+                    }));
+                }
+            }
+            
+            function startGame() {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'start'
+                    }));
+                    gameStarted = true;
+                    gameStatusEl.textContent = 'Starting AI...';
+                    gameStatusEl.style.color = '#ffff00';
+                    loadingEl.style.display = 'block';
+                    console.log('Game started');
+                }
+            }
+            
+            function pauseGame() {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'pause'
+                    }));
+                    gameStarted = false;
+                    gameStatusEl.textContent = 'Paused - Click to Resume';
+                    gameStatusEl.style.color = '#ffff00';
+                    console.log('Game paused');
+                }
+            }
+            
+            function updateKeyDisplay() {
+                // Reset all key displays
+                Object.values(keyDisplayMap).forEach(id => {
+                    const el = document.getElementById(id);
+                    if (el) el.classList.remove('key-pressed');
+                });
+                
+                // Highlight pressed keys
+                pressedKeys.forEach(key => {
+                    const displayId = keyDisplayMap[key];
+                    if (displayId) {
+                        const el = document.getElementById(displayId);
+                        if (el) el.classList.add('key-pressed');
+                    }
+                });
+            }
+            
+            // Focus canvas and handle keyboard events
+            canvas.addEventListener('click', () => {
+                canvas.focus();
+                if (!gameStarted) {
+                    // Queue start locally and send immediately if WS is open
+                    gameStarted = true;
+                    gameStatusEl.textContent = 'Starting AI...';
+                    gameStatusEl.style.color = '#ffff00';
+                    loadingEl.style.display = 'block';
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({ type: 'start' }));
+                    }
+                }
+            });
+            
+            canvas.addEventListener('keydown', (event) => {
+                event.preventDefault();
+                
+                // Handle special keys
+                if (event.code === 'Enter') {
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: 'reset'
+                        }));
+                        console.log('Environment reset requested');
+                    }
+                    // Add to pressedKeys for visual feedback
+                    pressedKeys.add(event.code);
+                    updateKeyDisplay();
+                    
+                    // Remove Enter from pressedKeys after a short delay for visual feedback
+                    setTimeout(() => {
+                        pressedKeys.delete(event.code);
+                        updateKeyDisplay();
+                    }, 200);
+                } else if (event.code === 'Escape') {
+                    pauseGame();
+                    // Add to pressedKeys for visual feedback
+                    pressedKeys.add(event.code);
+                    updateKeyDisplay();
+                    
+                    // Remove ESC from pressedKeys after a short delay for visual feedback
+                    setTimeout(() => {
+                        pressedKeys.delete(event.code);
+                        updateKeyDisplay();
+                    }, 200);
+                } else {
+                    // Only send game keys if game is started
+                    if (gameStarted) {
+                        pressedKeys.add(event.code);
+                        updateKeyDisplay();
+                        sendKeyState();
+                    }
+                }
+            });
+            
+            canvas.addEventListener('keyup', (event) => {
+                event.preventDefault();
+                
+                // Don't handle special keys release (handled in keydown with timeout)
+                if (event.code !== 'Enter' && event.code !== 'Escape') {
+                    if (gameStarted) {
+                        pressedKeys.delete(event.code);
+                        updateKeyDisplay();
+                        sendKeyState();
+                    }
+                }
+            });
+            
+            // Handle mouse events for clicks
+            canvas.addEventListener('mousedown', (event) => {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'mouse',
+                        button: event.button,
+                        action: 'down',
+                        x: event.offsetX,
+                        y: event.offsetY
+                    }));
+                }
+            });
+            
+            canvas.addEventListener('mouseup', (event) => {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'mouse',
+                        button: event.button,
+                        action: 'up',
+                        x: event.offsetX,
+                        y: event.offsetY
+                    }));
+                }
+            });
+            
+            // Initialize
+            connectWebSocket();
+            canvas.focus();
+        </script>
+    </body>
+    </html>
+    """
+    return html_content
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """Handle WebSocket connections for real-time game communication"""
+    await websocket.accept()
+    connected_clients.add(websocket)
+    
+    try:
+        while True:
+            # Receive messages from client
+            data = await websocket.receive_text()
+            message = json.loads(data)
+            
+            if message['type'] == 'keys':
+                # Update pressed keys
+                game_engine.pressed_keys = set(message['keys'])
+                
+            elif message['type'] == 'reset':
+                # Handle environment reset request
+                game_engine.request_reset()
+                
+            elif message['type'] == 'start':
+                # Handle game start request
+                game_engine.start_game()
+                
+            elif message['type'] == 'pause':
+                # Handle game pause request
+                game_engine.pause_game()
+                
+            elif message['type'] == 'mouse':
+                # Handle mouse events
+                if message['action'] == 'down':
+                    if message['button'] == 0:  # Left click
+                        game_engine.l_click = True
+                    elif message['button'] == 2:  # Right click
+                        game_engine.r_click = True
+                elif message['action'] == 'up':
+                    if message['button'] == 0:  # Left click
+                        game_engine.l_click = False
+                    elif message['button'] == 2:  # Right click
+                        game_engine.r_click = False
+                        
+                # Update mouse position (relative to canvas)
+                game_engine.mouse_x = message.get('x', 0) - 300  # Center at 300px
+                game_engine.mouse_y = message.get('y', 0) - 150  # Center at 150px
+                
+    except WebSocketDisconnect:
+        connected_clients.discard(websocket)
+    except Exception as e:
+        logger.error(f"WebSocket error: {e}")
+        connected_clients.discard(websocket)
+
+if __name__ == "__main__":
+    # For local development
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)
+

app.py.backup2

@@ -0,0 +1,1112 @@
+"""
+Web-based Diamond CSGO AI Player for Hugging Face Spaces
+Uses FastAPI + WebSocket for real-time keyboard input and game streaming
+"""
+
+# Fix environment variables FIRST, before any other imports
+import os
+import tempfile
+
+# Fix OMP_NUM_THREADS immediately (before PyTorch/NumPy imports)
+if "OMP_NUM_THREADS" not in os.environ or not os.environ.get("OMP_NUM_THREADS", "").isdigit():
+    os.environ["OMP_NUM_THREADS"] = "2"
+
+# Set up cache directories immediately
+temp_dir = tempfile.gettempdir()
+os.environ.setdefault("TORCH_HOME", os.path.join(temp_dir, "torch"))
+os.environ.setdefault("HF_HOME", os.path.join(temp_dir, "huggingface"))
+os.environ.setdefault("TRANSFORMERS_CACHE", os.path.join(temp_dir, "transformers"))
+
+# Create cache directories
+for cache_var in ["TORCH_HOME", "HF_HOME", "TRANSFORMERS_CACHE"]:
+    cache_path = os.environ[cache_var]
+    os.makedirs(cache_path, exist_ok=True)
+
+import asyncio
+import base64
+import io
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+import cv2
+import numpy as np
+import torch
+import uvicorn
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from hydra import compose, initialize
+from hydra.utils import instantiate
+from omegaconf import DictConfig, OmegaConf
+from PIL import Image
+
+# Import your modules
+import sys
+from pathlib import Path
+
+# Add project root to path for src package imports
+project_root = Path(__file__).parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+from src.agent import Agent
+from src.csgo.web_action_processing import WebCSGOAction, web_keys_to_csgo_action_names
+from src.envs import WorldModelEnv
+from src.game.web_play_env import WebPlayEnv
+from src.utils import extract_state_dict
+from config_web import web_config
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global variables
+app = FastAPI(title="Diamond CSGO AI Player")
+
+# Set safe defaults for headless CI/Spaces environments
+os.environ.setdefault("SDL_VIDEODRIVER", "dummy")
+os.environ.setdefault("SDL_AUDIODRIVER", "dummy")
+os.environ.setdefault("PYGAME_HIDE_SUPPORT_PROMPT", "1")
+
+# Environment variables already set at top of file
+connected_clients: Set[WebSocket] = set()
+
+class WebKeyMap:
+    """Map web key codes to pygame-like keys for CSGO actions"""
+    WEB_TO_CSGO = {
+        'KeyW': 'w',
+        'KeyA': 'a', 
+        'KeyS': 's',
+        'KeyD': 'd',
+        'Space': 'space',
+        'ControlLeft': 'left ctrl',
+        'ShiftLeft': 'left shift',
+        'Digit1': '1',
+        'Digit2': '2', 
+        'Digit3': '3',
+        'KeyR': 'r',
+        'ArrowUp': 'camera_up',
+        'ArrowDown': 'camera_down',
+        'ArrowLeft': 'camera_left',
+        'ArrowRight': 'camera_right'
+    }
+
+class WebGameEngine:
+    """Web-compatible game engine that replaces pygame functionality"""
+    
+    def __init__(self):
+        self.play_env: Optional[WebPlayEnv] = None
+        self.obs = None
+        self.running = False
+        self.game_started = False
+        self.fps = 30  # Display FPS
+        self.ai_fps = 40  # AI inference FPS (matching standalone play.py performance)
+        self.frame_count = 0
+        self.ai_frame_count = 0
+        self.last_ai_time = 0
+        self.start_time = 0  # Track when AI started for proper FPS calculation
+        self.last_frame_send_time = 0  # Track frame sending for optimization
+        self.web_fps = 20  # Web display FPS (lower than AI FPS to reduce network overhead)
+        self.pressed_keys: Set[str] = set()
+        self.mouse_x = 0
+        self.mouse_y = 0
+        self.l_click = False
+        self.r_click = False
+        self.should_reset = False
+        self.cached_obs = None  # Cache last observation for frame skipping
+        self.first_inference_done = False  # Track if first inference completed
+        self.models_ready = False  # Track if models are loaded
+        self.download_progress = 0  # Track download progress (0-100)
+        self.loading_status = "Initializing..."  # Loading status message
+        self.actor_critic_loaded = False  # Track if actor_critic was loaded with trained weights
+        import time
+        self.time_module = time
+    
+    async def _load_model_from_url_async(self, agent, device):
+        """Load model from URL using torch.hub (HF Spaces compatible)"""
+        import asyncio
+        import concurrent.futures
+        
+        def load_model_weights():
+            """Load model weights in thread pool to avoid blocking"""
+            try:
+                logger.info("Loading model using torch.hub.load_state_dict_from_url...")
+                self.loading_status = "Downloading model..."
+                self.download_progress = 10
+                
+                model_url = "https://huggingface.co/Etadingrui/diamond-1B/resolve/main/agent_epoch_00003.pt"
+                
+                # Use torch.hub to download and load state dict with custom cache dir
+                logger.info(f"Loading state dict from {model_url}")
+                
+                # Set custom cache directory that we have write permissions for
+                cache_dir = os.path.join(tempfile.gettempdir(), "torch_cache")
+                os.makedirs(cache_dir, exist_ok=True)
+                
+                # Use torch.hub with custom cache directory
+                state_dict = torch.hub.load_state_dict_from_url(
+                    model_url, 
+                    map_location=device,
+                    model_dir=cache_dir,
+                    check_hash=False  # Skip hash check for faster loading
+                )
+                
+                self.download_progress = 60
+                self.loading_status = "Loading model weights into agent..."
+                logger.info("State dict loaded, applying to agent...")
+                
+                # Load state dict into agent, but skip actor_critic if not present
+                has_actor_critic = any(k.startswith('actor_critic.') for k in state_dict.keys())
+                logger.info(f"Model has actor_critic weights: {has_actor_critic}")
+                agent.load_state_dict(state_dict, load_actor_critic=has_actor_critic)
+                
+                # Track if actor_critic was actually loaded with trained weights
+                self.actor_critic_loaded = has_actor_critic
+                
+                self.download_progress = 100
+                self.loading_status = "Model loaded successfully!"
+                logger.info("All model weights loaded successfully!")
+                return True
+                
+            except Exception as e:
+                logger.error(f"Failed to load model: {e}")
+                import traceback
+                traceback.print_exc()
+                return False
+            
+        # Run in thread pool to avoid blocking with timeout
+        loop = asyncio.get_event_loop()
+        try:
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                # Add timeout for model loading (5 minutes max)
+                future = loop.run_in_executor(executor, load_model_weights)
+                success = await asyncio.wait_for(future, timeout=300.0)  # 5 minute timeout
+                return success
+        except asyncio.TimeoutError:
+            logger.error("Model loading timed out after 5 minutes")
+            self.loading_status = "Model loading timed out - using dummy mode"
+            return False
+        except Exception as e:
+            logger.error(f"Error in model loading executor: {e}")
+            self.loading_status = f"Model loading error: {str(e)[:50]}..."
+            return False
+        
+    async def initialize_models(self):
+        """Initialize the AI models and environment"""
+        try:
+            import torch
+            logger.info("Initializing models...")
+            
+            # Setup environment and paths
+            web_config.setup_environment_variables()
+            web_config.create_default_configs()
+            
+            config_path = web_config.get_config_path()
+            logger.info(f"Using config path: {config_path}")
+            
+            # For Hydra, use relative path from app.py location
+            # Since app.py is in project root, config is simply "config"
+            relative_config_path = "config"
+            logger.info(f"Relative config path: {relative_config_path}")
+                
+            with initialize(version_base="1.3", config_path=relative_config_path):
+                cfg = compose(config_name="trainer")
+            
+            # Override config for deployment
+            cfg.agent = OmegaConf.load(config_path / "agent" / "csgo.yaml")
+            cfg.env = OmegaConf.load(config_path / "env" / "csgo.yaml") 
+            
+            # Use GPU if available, otherwise fall back to CPU
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+            logger.info(f"Using device: {device}")
+            
+            # Log GPU availability and CUDA info for debugging
+            if torch.cuda.is_available():
+                logger.info(f"CUDA available: {torch.cuda.is_available()}")
+                logger.info(f"GPU device count: {torch.cuda.device_count()}")
+                logger.info(f"Current GPU: {torch.cuda.get_device_name(0)}")
+                logger.info(f"GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
+                logger.info("🚀 GPU acceleration enabled!")
+            else:
+                logger.info("CUDA not available, using CPU mode")
+            
+            # Initialize agent first
+            num_actions = cfg.env.num_actions
+            agent = Agent(instantiate(cfg.agent, num_actions=num_actions)).to(device).eval()
+            
+            # Get spawn directory
+            spawn_dir = web_config.get_spawn_dir()
+            
+            # Try to load checkpoint (remote first, then local, then dummy mode)
+            try:
+                # First try to load from Hugging Face Hub using torch.hub
+                logger.info("Loading model from Hugging Face Hub with torch.hub...")
+                
+                success = await self._load_model_from_url_async(agent, device)
+                
+                if success:
+                    logger.info("Successfully loaded checkpoint from HF Hub")
+                else:
+                    # Fallback to local checkpoint if available
+                    logger.error("Failed to load from HF Hub! Check the detailed error above.")
+                    checkpoint_path = web_config.get_checkpoint_path()
+                    if checkpoint_path.exists():
+                        logger.info(f"Loading local checkpoint: {checkpoint_path}")
+                        self.loading_status = "Loading local checkpoint..."
+                        agent.load(checkpoint_path)
+                        logger.info(f"Successfully loaded local checkpoint: {checkpoint_path}")
+                        # Assume local checkpoint has actor_critic weights (may need verification)
+                        self.actor_critic_loaded = True
+                    else:
+                        logger.error(f"No local checkpoint found at: {checkpoint_path}")
+                        raise FileNotFoundError("No model checkpoint available (local or remote)")
+                        
+            except Exception as e:
+                logger.error(f"Failed to load any checkpoint: {e}")
+                self._init_dummy_mode()
+                self.actor_critic_loaded = False  # No actor_critic in dummy mode
+                return True
+            
+            # Initialize world model environment
+            try:
+                sl = cfg.agent.denoiser.inner_model.num_steps_conditioning
+                if agent.upsampler is not None:
+                    sl = max(sl, cfg.agent.upsampler.inner_model.num_steps_conditioning)
+                wm_env_cfg = instantiate(cfg.world_model_env, num_batches_to_preload=1)
+                wm_env = WorldModelEnv(agent.denoiser, agent.upsampler, agent.rew_end_model, 
+                                     spawn_dir, 1, sl, wm_env_cfg, return_denoising_trajectory=True)
+                
+                # Create play environment
+                self.play_env = WebPlayEnv(agent, wm_env, False, False, False)
+                
+                # Verify actor-critic is loaded and ready for inference
+                if agent.actor_critic is not None and self.actor_critic_loaded:
+                    logger.info(f"Actor-critic model loaded with {agent.actor_critic.lstm_dim} LSTM dimensions")
+                    logger.info(f"Actor-critic device: {agent.actor_critic.device}")
+                    # Force AI control for web demo
+                    self.play_env.is_human_player = False
+                    logger.info("WebPlayEnv set to AI control mode")
+                elif agent.actor_critic is not None and not self.actor_critic_loaded:
+                    logger.warning("Actor-critic model exists but has no trained weights - using dummy mode!")
+                    self.play_env.is_human_player = True
+                    logger.info("WebPlayEnv set to human control mode (no trained weights)")
+                else:
+                    logger.warning("No actor-critic model found - AI inference will not work!")
+                    self.play_env.is_human_player = True
+                    logger.info("WebPlayEnv set to human control mode (fallback)")
+                
+                # Enable model compilation for better performance (like standalone play.py)
+                # This gives 20-50% speedup but causes 10-30s delay on first inference
+                import os
+                enable_compile = device.type == "cuda" and os.getenv("ENABLE_TORCH_COMPILE", "1") == "1"
+                
+                if enable_compile:
+                    logger.info("🚀 Compiling models for faster inference (like standalone play.py)...")
+                    logger.info("⏱️  First inference will take 10-30s, but subsequent inferences will be much faster!")
+                    try:
+                        wm_env.predict_next_obs = torch.compile(wm_env.predict_next_obs, mode="reduce-overhead")
+                        if wm_env.upsample_next_obs is not None:
+                            wm_env.upsample_next_obs = torch.compile(wm_env.upsample_next_obs, mode="reduce-overhead")
+                        logger.info("✅ Model compilation enabled - expect 20-50% speedup!")
+                    except Exception as e:
+                        logger.warning(f"Model compilation failed: {e}")
+                        enable_compile = False
+                
+                if not enable_compile:
+                    logger.info("Model compilation disabled. Set ENABLE_TORCH_COMPILE=1 for better performance.")
+                
+                # Reset environment
+                self.obs, _ = self.play_env.reset()
+                self.cached_obs = self.obs  # Initialize cache
+                
+                logger.info("Models initialized successfully!")
+                logger.info(f"Initial observation shape: {self.obs.shape if self.obs is not None else 'None'}")
+                self.models_ready = True
+                self.loading_status = "Ready!"
+                return True
+                
+            except Exception as e:
+                logger.error(f"Failed to initialize world model environment: {e}")
+                self._init_dummy_mode()
+                self.actor_critic_loaded = False  # No actor_critic in dummy mode
+                self.models_ready = True
+                self.loading_status = "Using dummy mode"
+                return True
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize models: {e}")
+            import traceback
+            traceback.print_exc()
+            self._init_dummy_mode()
+            self.actor_critic_loaded = False  # No actor_critic in dummy mode
+            self.models_ready = True
+            self.loading_status = "Error - using dummy mode"
+            return True
+    
+    def _init_dummy_mode(self):
+        """Initialize dummy mode for testing without models"""
+        logger.info("Initializing dummy mode...")
+        
+        # Create a test observation
+        height, width = 150, 600
+        img_array = np.zeros((height, width, 3), dtype=np.uint8)
+        
+        # Add test pattern
+        for y in range(height):
+            for x in range(width):
+                img_array[y, x, 0] = (x % 256)  # Red gradient
+                img_array[y, x, 1] = (y % 256)  # Green gradient  
+                img_array[y, x, 2] = ((x + y) % 256)  # Blue pattern
+        
+        # Convert to torch tensor in expected format [-1, 1]
+        tensor = torch.from_numpy(img_array).float().permute(2, 0, 1)  # CHW format
+        tensor = tensor.div(255).mul(2).sub(1)  # Convert to [-1, 1] range
+        tensor = tensor.unsqueeze(0)  # Add batch dimension
+        
+        self.obs = tensor
+        self.play_env = None  # No real environment in dummy mode
+        logger.info("Dummy mode initialized with test pattern")
+    
+    
+    def step_environment(self):
+        """Step the environment with current input state (with intelligent frame skipping)"""
+        if self.play_env is None:
+            # Dummy mode - just return current observation
+            return self.obs, 0.0, False, False, {"mode": "dummy"}
+            
+        try:
+            # Check if reset is requested
+            if self.should_reset:
+                self.reset_environment()
+                self.should_reset = False
+                self.last_ai_time = self.time_module.time()  # Reset AI timer
+                return self.obs, 0.0, False, False, {"reset": True}
+            
+            # Intelligent frame skipping: only run AI inference at target FPS
+            current_time = self.time_module.time()
+            time_since_last_ai = current_time - self.last_ai_time
+            should_run_ai = time_since_last_ai >= (1.0 / self.ai_fps)
+            
+            if should_run_ai:
+                # Show loading indicator for first inference (can be slow)
+                if not self.first_inference_done:
+                    logger.info("Running first AI inference (may take 5-15 seconds)...")
+                
+                # Run AI inference
+                inference_start = self.time_module.time()
+                next_obs, reward, done, truncated, info = self.play_env.step_from_web_input(
+                    pressed_keys=self.pressed_keys,
+                    mouse_x=self.mouse_x,
+                    mouse_y=self.mouse_y,
+                    l_click=self.l_click,
+                    r_click=self.r_click
+                )
+                inference_time = self.time_module.time() - inference_start
+                
+                # Log first inference completion
+                if not self.first_inference_done:
+                    self.first_inference_done = True
+                    logger.info(f"First AI inference completed in {inference_time:.2f}s - subsequent inferences will be faster!")
+                
+                # Cache the new observation and update timing
+                self.cached_obs = next_obs
+                self.last_ai_time = current_time
+                self.ai_frame_count += 1
+                
+                # Add AI performance info
+                info = info or {}
+                info["ai_inference"] = True
+                
+                # Calculate proper AI FPS: frames / elapsed time since start
+                elapsed_time = current_time - self.start_time
+                if elapsed_time > 0 and self.ai_frame_count > 0:
+                    ai_fps = self.ai_frame_count / elapsed_time
+                    # Cap at reasonable maximum (shouldn't exceed 100 FPS for AI inference)
+                    info["ai_fps"] = min(ai_fps, 100.0)
+                else:
+                    info["ai_fps"] = 0
+                
+                info["inference_time"] = inference_time
+                
+                return next_obs, reward, done, truncated, info
+            else:
+                # Use cached observation for smoother display without AI overhead
+                obs_to_return = self.cached_obs if self.cached_obs is not None else self.obs
+                
+                # Calculate AI FPS for cached frames too
+                elapsed_time = current_time - self.start_time
+                if elapsed_time > 0 and self.ai_frame_count > 0:
+                    ai_fps = min(self.ai_frame_count / elapsed_time, 100.0)  # Cap at 100 FPS
+                else:
+                    ai_fps = 0
+                
+                return obs_to_return, 0.0, False, False, {"cached": True, "ai_fps": ai_fps}
+            
+        except Exception as e:
+            logger.error(f"Error stepping environment: {e}")
+            obs_to_return = self.cached_obs if self.cached_obs is not None else self.obs
+            return obs_to_return, 0.0, False, False, {"error": str(e)}
+    
+    def reset_environment(self):
+        """Reset the environment"""
+        try:
+            if self.play_env is not None:
+                self.obs, _ = self.play_env.reset()
+                self.cached_obs = self.obs  # Update cache
+                logger.info("Environment reset successfully")
+            else:
+                # Dummy mode - recreate test pattern
+                self._init_dummy_mode()
+                self.cached_obs = self.obs  # Update cache
+                logger.info("Dummy environment reset")
+        except Exception as e:
+            logger.error(f"Error resetting environment: {e}")
+    
+    def request_reset(self):
+        """Request environment reset on next step"""
+        self.should_reset = True
+        logger.info("Environment reset requested")
+    
+    def start_game(self):
+        """Start the game"""
+        self.game_started = True
+        self.start_time = self.time_module.time()  # Reset start time for FPS calculation
+        self.ai_frame_count = 0  # Reset AI frame count
+        logger.info("Game started")
+    
+    def pause_game(self):
+        """Pause/stop the game"""
+        self.game_started = False
+        logger.info("Game paused")
+    
+    def obs_to_base64(self, obs: torch.Tensor) -> str:
+        """Convert observation tensor to base64 image for web display (optimized for speed)"""
+        if obs is None:
+            return ""
+            
+        try:
+            # Handle observation tensor conversion based on dimensions
+            if obs.ndim == 4 and obs.size(0) == 1:
+                # 4D tensor with batch dimension [1, C, H, W] -> [C, H, W]
+                img_tensor = obs[0]
+            elif obs.ndim == 3:
+                # 3D tensor [C, H, W] 
+                img_tensor = obs
+            elif obs.ndim == 2:
+                # 2D tensor - likely an error, return empty string
+                logger.warning(f"Unexpected 2D observation tensor: {obs.shape}")
+                return ""
+            else:
+                logger.warning(f"Unexpected observation dimensions: {obs.shape}")
+                return ""
+            
+            # Convert to numpy with proper range conversion
+            img_array = img_tensor.mul(127.5).add_(127.5).clamp_(0, 255).byte()
+            img_array = img_array.permute(1, 2, 0).cpu().numpy()
+            
+            # Direct resize with OpenCV (much faster than PIL)
+            img_array = cv2.resize(img_array, (600, 150), interpolation=cv2.INTER_CUBIC)
+            
+            # Note: img_array is already in RGB format from PyTorch tensor, no conversion needed
+            
+            # Optimized JPEG encoding with OpenCV (faster than PIL)
+            success, buffer = cv2.imencode('.jpg', img_array, [cv2.IMWRITE_JPEG_QUALITY, 95])
+            if success:
+                img_str = base64.b64encode(buffer).decode()
+                return f"data:image/jpeg;base64,{img_str}"
+            else:
+                logger.warning("Frame encoding failed, using fallback")
+                return ""
+            
+        except Exception as e:
+            logger.error(f"Error converting observation to base64: {e}")
+            return ""
+    
+    async def game_loop(self):
+        """Main game loop that runs continuously"""
+        self.running = True
+        
+        while self.running:
+            try:
+                # Check if models are ready
+                if not self.models_ready:
+                    # Send loading status to clients
+                    if connected_clients:
+                        loading_data = {
+                            'type': 'loading',
+                            'status': self.loading_status,
+                            'progress': self.download_progress,
+                            'ready': False
+                        }
+                        disconnected = set()
+                        for client in connected_clients.copy():
+                            try:
+                                await client.send_text(json.dumps(loading_data))
+                            except:
+                                disconnected.add(client)
+                        connected_clients.difference_update(disconnected)
+                    
+                    await asyncio.sleep(0.5)  # Check every 500ms during loading
+                    continue
+                
+                # Only step environment if game is started
+                if not self.game_started:
+                    # Game not started - just send current observation without stepping
+                    should_send_frame = True if (self.obs is not None and connected_clients) else False
+                    # Don't modify self.obs when game isn't started!
+                    await asyncio.sleep(0.1)
+                else:
+                    # Game is started - step environment
+                    should_send_frame = True
+                    if self.play_env is None:
+                        await asyncio.sleep(0.1)
+                        continue
+                    
+                    # Step environment with current input state
+                    next_obs, reward, done, truncated, info = self.step_environment()
+                    
+                    if done or truncated:
+                        # Auto-reset when episode ends
+                        self.reset_environment()
+                    else:
+                        self.obs = next_obs
+                
+                # Send frame to all connected clients with smart throttling for performance
+                current_time = self.time_module.time()
+                time_since_last_frame_send = current_time - self.last_frame_send_time
+                should_send_web_frame = time_since_last_frame_send >= (1.0 / self.web_fps)
+                
+                if should_send_frame and should_send_web_frame and connected_clients and self.obs is not None:
+                    # Set default values for when game isn't running
+                    if not self.game_started:
+                        reward = 0.0
+                        info = {"waiting": True}
+                    # If game is started, reward and info should be set above
+                    
+                    # Convert observation to base64
+                    image_data = self.obs_to_base64(self.obs)
+                    
+                    # Debug logging for first few frames
+                    if self.frame_count < 5:
+                        logger.info(f"Frame {self.frame_count}: obs shape={self.obs.shape if self.obs is not None else 'None'}, "
+                                  f"image_data_length={len(image_data) if image_data else 0}, "
+                                  f"game_started={self.game_started}")
+                    
+                    frame_data = {
+                        'type': 'frame',
+                        'image': image_data,
+                        'frame_count': self.frame_count,
+                        'reward': float(reward.item()) if hasattr(reward, 'item') else float(reward) if reward is not None else 0.0,
+                        'info': str(info) if info else "",
+                        'ai_fps': info.get('ai_fps', 0) if isinstance(info, dict) else 0,
+                        'is_ai_frame': info.get('ai_inference', False) if isinstance(info, dict) else False,
+                        'web_fps': self.web_fps,  # Add web FPS for monitoring
+                        'ai_target_fps': self.ai_fps  # Add target AI FPS for monitoring
+                    }
+                    
+                    # Send to all connected clients
+                    disconnected = set()
+                    for client in connected_clients.copy():
+                        try:
+                            await client.send_text(json.dumps(frame_data))
+                        except:
+                            disconnected.add(client)
+                    
+                    # Remove disconnected clients
+                    connected_clients.difference_update(disconnected)
+                    
+                    # Update frame send timing
+                    self.last_frame_send_time = current_time
+                
+                self.frame_count += 1
+                await asyncio.sleep(1.0 / self.fps)  # Control FPS
+                
+            except Exception as e:
+                logger.error(f"Error in game loop: {e}")
+                await asyncio.sleep(0.1)
+
+# Global game engine instance
+game_engine = WebGameEngine()
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize models when the app starts"""
+    # Start the game loop immediately (it will handle loading state)
+    asyncio.create_task(game_engine.game_loop())
+    
+    # Initialize models in background (non-blocking)
+    asyncio.create_task(game_engine.initialize_models())
+
+@app.get("/performance")
+async def get_performance_stats():
+    """Get current performance statistics"""
+    current_time = game_engine.time_module.time()
+    elapsed_time = current_time - game_engine.start_time if game_engine.start_time > 0 else 0
+    
+    return {
+        "ai_fps_current": game_engine.ai_frame_count / elapsed_time if elapsed_time > 0 else 0,
+        "ai_fps_target": game_engine.ai_fps,
+        "web_fps_target": game_engine.web_fps,
+        "display_fps_target": game_engine.fps,
+        "models_ready": game_engine.models_ready,
+        "actor_critic_loaded": game_engine.actor_critic_loaded,
+        "game_started": game_engine.game_started,
+        "connected_clients": len(connected_clients),
+        "total_ai_frames": game_engine.ai_frame_count,
+        "total_display_frames": game_engine.frame_count,
+        "elapsed_time": elapsed_time,
+        "torch_compile_enabled": os.environ.get("ENABLE_TORCH_COMPILE", "1") == "1",
+        "device": "cuda" if torch.cuda.is_available() else "cpu"
+    }
+
+@app.get("/", response_class=HTMLResponse)
+async def get_homepage():
+    """Serve the main game interface"""
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Physics-informed BEV World Model</title>
+        <style>
+            body {
+                margin: 0;
+                padding: 20px;
+                background: #1a1a1a;
+                color: white;
+                font-family: 'Courier New', monospace;
+                text-align: center;
+            }
+            #gameCanvas {
+                border: 2px solid #00ff00;
+                background: #000;
+                margin: 20px auto;
+                display: block;
+            }
+            #controls {
+                margin: 20px;
+                display: grid;
+                grid-template-columns: 1fr 1fr;
+                gap: 20px;
+                max-width: 800px;
+                margin: 20px auto;
+            }
+            .control-section {
+                background: #2a2a2a;
+                padding: 15px;
+                border-radius: 8px;
+                border: 1px solid #444;
+            }
+            .key-display {
+                background: #333;
+                border: 1px solid #555;
+                padding: 5px 10px;
+                margin: 2px;
+                border-radius: 4px;
+                display: inline-block;
+                min-width: 30px;
+            }
+            .key-pressed {
+                background: #00ff00;
+                color: #000;
+            }
+            #status {
+                margin: 10px;
+                padding: 10px;
+                background: #2a2a2a;
+                border-radius: 4px;
+            }
+            .info {
+                color: #00ff00;
+                margin: 5px 0;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>🎮 Physics-informed BEV World Model</h1>
+        <p><strong>Click the game canvas to start playing!</strong> Use ESC to pause, Enter to reset environment.</p>
+        <p id="loadingIndicator" style="color: #ffff00; display: none;">🚀 Starting AI inference... This may take 5-15 seconds on first run.</p>
+        
+        <!-- Model Download Progress -->
+        <div id="downloadSection" style="display: none; margin: 20px;">
+            <p id="downloadStatus" style="color: #ffaa00; margin: 10px 0;">📥 Downloading AI model...</p>
+            <div style="background: #333; border-radius: 10px; padding: 3px; width: 100%; max-width: 600px; margin: 0 auto;">
+                <div id="progressBar" style="background: linear-gradient(90deg, #00ff00, #88ff00); height: 20px; border-radius: 7px; width: 0%; transition: width 0.3s;"></div>
+            </div>
+            <p id="progressText" style="color: #aaa; font-size: 14px; margin: 5px 0;">0% - Initializing...</p>
+        </div>
+        
+        <canvas id="gameCanvas" width="600" height="150" tabindex="0"></canvas>
+        
+        <div id="status">
+            <div class="info">Status: <span id="connectionStatus">Connecting...</span></div>
+            <div class="info">Game: <span id="gameStatus">Click to Start</span></div>
+            <div class="info">Frame: <span id="frameCount">0</span> | AI FPS: <span id="aiFps">0</span></div>
+            <div class="info">Reward: <span id="reward">0</span></div>
+        </div>
+        
+        <div id="controls">
+            <div class="control-section">
+                <h3>Movement</h3>
+                <div>
+                    <span class="key-display" id="key-w">W</span> Forward<br>
+                    <span class="key-display" id="key-a">A</span> Left
+                    <span class="key-display" id="key-s">S</span> Back
+                    <span class="key-display" id="key-d">D</span> Right<br>
+                    <span class="key-display" id="key-space">Space</span> Jump
+                    <span class="key-display" id="key-ctrl">Ctrl</span> Crouch
+                    <span class="key-display" id="key-shift">Shift</span> Walk
+                </div>
+            </div>
+            
+            <div class="control-section">
+                <h3>Actions</h3>
+                <div>
+                    <span class="key-display" id="key-1">1</span> Weapon 1<br>
+                    <span class="key-display" id="key-2">2</span> Weapon 2
+                    <span class="key-display" id="key-3">3</span> Weapon 3<br>
+                    <span class="key-display" id="key-r">R</span> Reload<br>
+                    <span class="key-display" id="key-arrows">↑↓←→</span> Camera<br>
+                    <span class="key-display" id="key-enter">Enter</span> Reset Game<br>
+                    <span class="key-display" id="key-esc">Esc</span> Pause/Quit
+                </div>
+            </div>
+        </div>
+        
+        <script>
+            const canvas = document.getElementById('gameCanvas');
+            const ctx = canvas.getContext('2d');
+            const statusEl = document.getElementById('connectionStatus');
+            const gameStatusEl = document.getElementById('gameStatus');
+            const frameEl = document.getElementById('frameCount');
+            const aiFpsEl = document.getElementById('aiFps');
+            const rewardEl = document.getElementById('reward');
+            const loadingEl = document.getElementById('loadingIndicator');
+            const downloadSectionEl = document.getElementById('downloadSection');
+            const downloadStatusEl = document.getElementById('downloadStatus');
+            const progressBarEl = document.getElementById('progressBar');
+            const progressTextEl = document.getElementById('progressText');
+            
+            let ws = null;
+            let pressedKeys = new Set();
+            let gameStarted = false;
+            
+            // Key mapping
+            const keyDisplayMap = {
+                'KeyW': 'key-w',
+                'KeyA': 'key-a', 
+                'KeyS': 'key-s',
+                'KeyD': 'key-d',
+                'Space': 'key-space',
+                'ControlLeft': 'key-ctrl',
+                'ShiftLeft': 'key-shift',
+                'Digit1': 'key-1',
+                'Digit2': 'key-2',
+                'Digit3': 'key-3',
+                'KeyR': 'key-r',
+                'ArrowUp': 'key-arrows',
+                'ArrowDown': 'key-arrows',
+                'ArrowLeft': 'key-arrows',
+                'ArrowRight': 'key-arrows',
+                'Enter': 'key-enter',
+                'Escape': 'key-esc'
+            };
+            
+            function connectWebSocket() {
+                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+                const wsUrl = `${protocol}//${window.location.host}/ws`;
+                
+                ws = new WebSocket(wsUrl);
+                
+                ws.onopen = function(event) {
+                    statusEl.textContent = 'Connected';
+                    statusEl.style.color = '#00ff00';
+                    // If user already clicked to start before WS was ready, send start now
+                    if (gameStarted) {
+                        ws.send(JSON.stringify({ type: 'start' }));
+                    }
+                };
+                
+                ws.onmessage = function(event) {
+                    const data = JSON.parse(event.data);
+                    
+                    if (data.type === 'loading') {
+                        // Handle loading status
+                        downloadSectionEl.style.display = 'block';
+                        downloadStatusEl.textContent = data.status;
+                        
+                        if (data.progress !== undefined) {
+                            progressBarEl.style.width = data.progress + '%';
+                            progressTextEl.textContent = data.progress + '% - ' + data.status;
+                        } else {
+                            progressTextEl.textContent = data.status;
+                        }
+                        
+                        gameStatusEl.textContent = 'Loading Models...';
+                        gameStatusEl.style.color = '#ffaa00';
+                        
+                    } else if (data.type === 'frame') {
+                        // Hide loading indicators once we get frames
+                        downloadSectionEl.style.display = 'none';
+                        // Update frame display
+                        if (data.image) {
+                            const img = new Image();
+                            img.onload = function() {
+                                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                                ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+                            };
+                            img.src = data.image;
+                        }
+                        
+                        frameEl.textContent = data.frame_count;
+                        rewardEl.textContent = data.reward.toFixed(2);
+                        
+                        // Update AI FPS display and hide loading indicator once AI starts
+                        if (data.ai_fps !== undefined && data.ai_fps !== null) {
+                            // Ensure FPS value is reasonable
+                            const aiFps = Math.min(Math.max(data.ai_fps, 0), 100);
+                            aiFpsEl.textContent = aiFps.toFixed(1);
+                            
+                            // Color code AI FPS for performance indication
+                            if (aiFps >= 8) {
+                                aiFpsEl.style.color = '#00ff00';  // Green for good performance
+                            } else if (aiFps >= 5) {
+                                aiFpsEl.style.color = '#ffff00';  // Yellow for moderate performance
+                            } else if (aiFps > 0) {
+                                aiFpsEl.style.color = '#ff0000';  // Red for poor performance
+                            } else {
+                                aiFpsEl.style.color = '#888888';  // Gray for inactive
+                            }
+                            
+                            // Hide loading indicator once AI inference starts working
+                            if (aiFps > 0 && gameStarted) {
+                                loadingEl.style.display = 'none';
+                                gameStatusEl.textContent = 'Playing';
+                                gameStatusEl.style.color = '#00ff00';
+                            }
+                        }
+                    }
+                };
+                
+                ws.onclose = function(event) {
+                    statusEl.textContent = 'Disconnected';
+                    statusEl.style.color = '#ff0000';
+                    setTimeout(connectWebSocket, 1000); // Reconnect after 1 second
+                };
+                
+                ws.onerror = function(event) {
+                    statusEl.textContent = 'Error';
+                    statusEl.style.color = '#ff0000';
+                };
+            }
+            
+            function sendKeyState() {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'keys',
+                        keys: Array.from(pressedKeys)
+                    }));
+                }
+            }
+            
+            function startGame() {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'start'
+                    }));
+                    gameStarted = true;
+                    gameStatusEl.textContent = 'Starting AI...';
+                    gameStatusEl.style.color = '#ffff00';
+                    loadingEl.style.display = 'block';
+                    console.log('Game started');
+                }
+            }
+            
+            function pauseGame() {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'pause'
+                    }));
+                    gameStarted = false;
+                    gameStatusEl.textContent = 'Paused - Click to Resume';
+                    gameStatusEl.style.color = '#ffff00';
+                    console.log('Game paused');
+                }
+            }
+            
+            function updateKeyDisplay() {
+                // Reset all key displays
+                Object.values(keyDisplayMap).forEach(id => {
+                    const el = document.getElementById(id);
+                    if (el) el.classList.remove('key-pressed');
+                });
+                
+                // Highlight pressed keys
+                pressedKeys.forEach(key => {
+                    const displayId = keyDisplayMap[key];
+                    if (displayId) {
+                        const el = document.getElementById(displayId);
+                        if (el) el.classList.add('key-pressed');
+                    }
+                });
+            }
+            
+            // Focus canvas and handle keyboard events
+            canvas.addEventListener('click', () => {
+                canvas.focus();
+                if (!gameStarted) {
+                    // Queue start locally and send immediately if WS is open
+                    gameStarted = true;
+                    gameStatusEl.textContent = 'Starting AI...';
+                    gameStatusEl.style.color = '#ffff00';
+                    loadingEl.style.display = 'block';
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({ type: 'start' }));
+                    }
+                }
+            });
+            
+            canvas.addEventListener('keydown', (event) => {
+                event.preventDefault();
+                
+                // Handle special keys
+                if (event.code === 'Enter') {
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: 'reset'
+                        }));
+                        console.log('Environment reset requested');
+                    }
+                    // Add to pressedKeys for visual feedback
+                    pressedKeys.add(event.code);
+                    updateKeyDisplay();
+                    
+                    // Remove Enter from pressedKeys after a short delay for visual feedback
+                    setTimeout(() => {
+                        pressedKeys.delete(event.code);
+                        updateKeyDisplay();
+                    }, 200);
+                } else if (event.code === 'Escape') {
+                    pauseGame();
+                    // Add to pressedKeys for visual feedback
+                    pressedKeys.add(event.code);
+                    updateKeyDisplay();
+                    
+                    // Remove ESC from pressedKeys after a short delay for visual feedback
+                    setTimeout(() => {
+                        pressedKeys.delete(event.code);
+                        updateKeyDisplay();
+                    }, 200);
+                } else {
+                    // Only send game keys if game is started
+                    if (gameStarted) {
+                        pressedKeys.add(event.code);
+                        updateKeyDisplay();
+                        sendKeyState();
+                    }
+                }
+            });
+            
+            canvas.addEventListener('keyup', (event) => {
+                event.preventDefault();
+                
+                // Don't handle special keys release (handled in keydown with timeout)
+                if (event.code !== 'Enter' && event.code !== 'Escape') {
+                    if (gameStarted) {
+                        pressedKeys.delete(event.code);
+                        updateKeyDisplay();
+                        sendKeyState();
+                    }
+                }
+            });
+            
+            // Handle mouse events for clicks
+            canvas.addEventListener('mousedown', (event) => {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'mouse',
+                        button: event.button,
+                        action: 'down',
+                        x: event.offsetX,
+                        y: event.offsetY
+                    }));
+                }
+            });
+            
+            canvas.addEventListener('mouseup', (event) => {
+                if (ws && ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: 'mouse',
+                        button: event.button,
+                        action: 'up',
+                        x: event.offsetX,
+                        y: event.offsetY
+                    }));
+                }
+            });
+            
+            // Initialize
+            connectWebSocket();
+            canvas.focus();
+        </script>
+    </body>
+    </html>
+    """
+    return html_content
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """Handle WebSocket connections for real-time game communication"""
+    await websocket.accept()
+    connected_clients.add(websocket)
+    
+    try:
+        while True:
+            # Receive messages from client
+            data = await websocket.receive_text()
+            message = json.loads(data)
+            
+            if message['type'] == 'keys':
+                # Update pressed keys
+                game_engine.pressed_keys = set(message['keys'])
+                
+            elif message['type'] == 'reset':
+                # Handle environment reset request
+                game_engine.request_reset()
+                
+            elif message['type'] == 'start':
+                # Handle game start request
+                game_engine.start_game()
+                
+            elif message['type'] == 'pause':
+                # Handle game pause request
+                game_engine.pause_game()
+                
+            elif message['type'] == 'mouse':
+                # Handle mouse events
+                if message['action'] == 'down':
+                    if message['button'] == 0:  # Left click
+                        game_engine.l_click = True
+                    elif message['button'] == 2:  # Right click
+                        game_engine.r_click = True
+                elif message['action'] == 'up':
+                    if message['button'] == 0:  # Left click
+                        game_engine.l_click = False
+                    elif message['button'] == 2:  # Right click
+                        game_engine.r_click = False
+                        
+                # Update mouse position (relative to canvas)
+                game_engine.mouse_x = message.get('x', 0) - 300  # Center at 300px
+                game_engine.mouse_y = message.get('y', 0) - 150  # Center at 150px
+                
+    except WebSocketDisconnect:
+        connected_clients.discard(websocket)
+    except Exception as e:
+        logger.error(f"WebSocket error: {e}")
+        connected_clients.discard(websocket)
+
+if __name__ == "__main__":
+    # For local development
+    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=True)
+

app_config.py

@@ -0,0 +1,37 @@
+"""
+Hugging Face Spaces configuration
+"""
+
+import os
+
+# Hugging Face Spaces configuration
+title = "Diamond CSGO AI Player"
+description = """
+# 🎮 Diamond CSGO AI Player
+
+Experience an AI agent trained with diffusion models playing Counter-Strike: Global Offensive!
+
+## How to Play
+1. Click on the game canvas to focus it
+2. Use keyboard controls:
+   - **WASD** - Movement
+   - **Space** - Jump
+   - **Ctrl** - Crouch  
+   - **1,2,3** - Switch weapons
+   - **R** - Reload
+   - **Arrow Keys** - Camera movement
+   - **Mouse clicks** - Fire
+3. Press **M** to switch between Human/AI control
+
+## Technical Details
+This demo showcases the Diamond framework, which combines:
+- Diffusion models for world modeling
+- Actor-critic reinforcement learning
+- Multi-step planning in imagination
+
+The AI learns to play by predicting future game states and optimizing actions through a learned world model.
+"""
+
+# App settings
+port = int(os.getenv("PORT", 7860))
+host = "0.0.0.0"

copy.sh

@@ -0,0 +1,21 @@
+# Essential files to copy to your HF Space directory:
+cp app.py /home/alienware3/Documents/diamond-ai-player/
+cp requirements.txt /home/alienware3/Documents/diamond-ai-player/
+cp Dockerfile /home/alienware3/Documents/diamond-ai-player/
+cp packages.txt /home/alienware3/Documents/diamond-ai-player/
+cp README.md /home/alienware3/Documents/diamond-ai-player/
+cp config_web.py /home/alienware3/Documents/diamond-ai-player/
+
+# Copy entire directories
+cp -r src/ /home/alienware3/Documents/diamond-ai-player/
+cp -r config/ /home/alienware3/Documents/diamond-ai-player/
+cp -r csgo/ /home/alienware3/Documents/diamond-ai-player/
+
+# Copy your trained model (choose one)
+# cp agent_epoch_00003.pt /home/alienware3/Documents/diamond-ai-player/    # OR
+#cp agent_epoch_00206.pt /home/alienware3/Documents/diamond-ai-player/
+
+cd /home/alienware3/Documents/diamond-ai-player/
+git add .
+git commit -m "Fix initial bugs"
+git push origin main

debug_app.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+"""
+Debug version of the web app to isolate the black screen issue
+"""
+
+import asyncio
+import base64
+import io
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+import numpy as np
+import torch
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from PIL import Image
+
+# Add src to Python path
+src_path = Path(__file__).parent / "src"
+sys.path.insert(0, str(src_path))
+
+# Configure logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Simple debug app
+app = FastAPI(title="Diamond CSGO AI Player - Debug")
+
+class DebugGameEngine:
+    """Simple debug version to test image rendering"""
+    
+    def __init__(self):
+        self.obs = None
+        self.frame_count = 0
+        self.initialized = False
+        
+    def create_test_observation(self):
+        """Create a test observation for debugging"""
+        # Create a test image with some pattern
+        height, width = 150, 600
+        
+        # Create RGB pattern
+        img_array = np.zeros((height, width, 3), dtype=np.uint8)
+        
+        # Add some pattern to make it visible
+        for y in range(height):
+            for x in range(width):
+                img_array[y, x, 0] = (x % 256)  # Red gradient
+                img_array[y, x, 1] = (y % 256)  # Green gradient  
+                img_array[y, x, 2] = ((x + y) % 256)  # Blue pattern
+        
+        # Convert to torch tensor in the expected format [-1, 1]
+        tensor = torch.from_numpy(img_array).float().permute(2, 0, 1)  # CHW format
+        tensor = tensor.div(255).mul(2).sub(1)  # Convert to [-1, 1] range
+        tensor = tensor.unsqueeze(0)  # Add batch dimension
+        
+        logger.info(f"Created test observation: {tensor.shape}, range: {tensor.min():.3f} to {tensor.max():.3f}")
+        return tensor
+    
+    def obs_to_base64(self, obs: torch.Tensor) -> str:
+        """Convert observation tensor to base64 image for web display"""
+        if obs is None:
+            logger.warning("Observation is None")
+            return ""
+            
+        try:
+            logger.debug(f"Converting obs: shape={obs.shape}, dtype={obs.dtype}")
+            
+            # Convert tensor to PIL Image
+            if obs.ndim == 4 and obs.size(0) == 1:
+                img_array = obs[0].add(1).div(2).mul(255).byte().permute(1, 2, 0).cpu().numpy()
+            else:
+                img_array = obs.add(1).div(2).mul(255).byte().permute(1, 2, 0).cpu().numpy()
+            
+            logger.debug(f"Image array: shape={img_array.shape}, range={img_array.min()} to {img_array.max()}")
+            
+            img = Image.fromarray(img_array)
+            
+            # Resize for web display
+            img = img.resize((600, 300), Image.BICUBIC)
+            
+            # Convert to base64
+            buffer = io.BytesIO()
+            img.save(buffer, format='PNG')
+            img_str = base64.b64encode(buffer.getvalue()).decode()
+            
+            logger.debug(f"Successfully converted to base64, length: {len(img_str)}")
+            return f"data:image/png;base64,{img_str}"
+            
+        except Exception as e:
+            logger.error(f"Error converting observation to base64: {e}")
+            import traceback
+            traceback.print_exc()
+            return ""
+    
+    async def initialize(self):
+        """Initialize with test data"""
+        logger.info("Initializing debug game engine...")
+        self.obs = self.create_test_observation()
+        self.initialized = True
+        logger.info("Debug game engine initialized successfully!")
+        return True
+
+# Global debug engine
+debug_engine = DebugGameEngine()
+connected_clients: Set[WebSocket] = set()
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize debug engine"""
+    success = await debug_engine.initialize()
+    if success:
+        # Start a simple game loop
+        asyncio.create_task(debug_game_loop())
+
+async def debug_game_loop():
+    """Simple debug game loop"""
+    while True:
+        try:
+            if debug_engine.initialized and connected_clients:
+                # Send test frame to all connected clients
+                frame_data = {
+                    'type': 'frame',
+                    'image': debug_engine.obs_to_base64(debug_engine.obs),
+                    'frame_count': debug_engine.frame_count,
+                    'reward': 0.0,
+                    'info': f"Debug frame {debug_engine.frame_count}"
+                }
+                
+                logger.debug(f"Sending frame {debug_engine.frame_count}")
+                
+                # Send to all connected clients
+                disconnected = set()
+                for client in connected_clients.copy():
+                    try:
+                        await client.send_text(json.dumps(frame_data))
+                    except Exception as e:
+                        logger.error(f"Error sending to client: {e}")
+                        disconnected.add(client)
+                
+                # Remove disconnected clients
+                connected_clients.difference_update(disconnected)
+                
+                debug_engine.frame_count += 1
+            
+            await asyncio.sleep(1.0 / 15)  # 15 FPS
+            
+        except Exception as e:
+            logger.error(f"Error in debug game loop: {e}")
+            await asyncio.sleep(0.1)
+
+@app.get("/", response_class=HTMLResponse)
+async def get_homepage():
+    """Serve debug interface"""
+    html_content = """
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>Diamond CSGO AI - Debug</title>
+        <style>
+            body {
+                margin: 0;
+                padding: 20px;
+                background: #1a1a1a;
+                color: white;
+                font-family: monospace;
+                text-align: center;
+            }
+            #gameCanvas {
+                border: 2px solid #00ff00;
+                background: #000;
+                margin: 20px auto;
+                display: block;
+            }
+            #status {
+                margin: 10px;
+                padding: 10px;
+                background: #2a2a2a;
+                border-radius: 4px;
+            }
+            .info {
+                color: #00ff00;
+                margin: 5px 0;
+            }
+        </style>
+    </head>
+    <body>
+        <h1>🔧 Diamond CSGO AI - Debug Mode</h1>
+        <p>Testing image rendering and WebSocket communication</p>
+        
+        <canvas id="gameCanvas" width="600" height="300"></canvas>
+        
+        <div id="status">
+            <div class="info">Status: <span id="connectionStatus">Connecting...</span></div>
+            <div class="info">Frame: <span id="frameCount">0</span></div>
+            <div class="info">Info: <span id="info">Waiting...</span></div>
+        </div>
+        
+        <div id="debug">
+            <h3>Debug Information</h3>
+            <p id="lastUpdate">No updates yet</p>
+            <p id="imageInfo">No image data</p>
+        </div>
+        
+        <script>
+            const canvas = document.getElementById('gameCanvas');
+            const ctx = canvas.getContext('2d');
+            const statusEl = document.getElementById('connectionStatus');
+            const frameEl = document.getElementById('frameCount');
+            const infoEl = document.getElementById('info');
+            const lastUpdateEl = document.getElementById('lastUpdate');
+            const imageInfoEl = document.getElementById('imageInfo');
+            
+            let ws = null;
+            
+            function connectWebSocket() {
+                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+                const wsUrl = `${protocol}//${window.location.host}/ws`;
+                console.log('Connecting to:', wsUrl);
+                
+                ws = new WebSocket(wsUrl);
+                
+                ws.onopen = function(event) {
+                    console.log('WebSocket connected');
+                    statusEl.textContent = 'Connected';
+                    statusEl.style.color = '#00ff00';
+                };
+                
+                ws.onmessage = function(event) {
+                    console.log('Received message');
+                    const data = JSON.parse(event.data);
+                    
+                    if (data.type === 'frame') {
+                        console.log('Received frame:', data.frame_count);
+                        lastUpdateEl.textContent = `Last update: ${new Date().toLocaleTimeString()}`;
+                        
+                        // Update frame display
+                        if (data.image && data.image.length > 0) {
+                            console.log('Loading image, length:', data.image.length);
+                            imageInfoEl.textContent = `Image data length: ${data.image.length}`;
+                            
+                            const img = new Image();
+                            img.onload = function() {
+                                console.log('Image loaded successfully');
+                                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                                ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
+                            };
+                            img.onerror = function() {
+                                console.error('Failed to load image');
+                                imageInfoEl.textContent = 'Failed to load image';
+                            };
+                            img.src = data.image;
+                        } else {
+                            console.warn('No image data received');
+                            imageInfoEl.textContent = 'No image data received';
+                        }
+                        
+                        frameEl.textContent = data.frame_count;
+                        infoEl.textContent = data.info || 'No info';
+                    }
+                };
+                
+                ws.onclose = function(event) {
+                    console.log('WebSocket disconnected');
+                    statusEl.textContent = 'Disconnected';
+                    statusEl.style.color = '#ff0000';
+                    setTimeout(connectWebSocket, 1000);
+                };
+                
+                ws.onerror = function(event) {
+                    console.error('WebSocket error:', event);
+                    statusEl.textContent = 'Error';
+                    statusEl.style.color = '#ff0000';
+                };
+            }
+            
+            // Initialize
+            connectWebSocket();
+        </script>
+    </body>
+    </html>
+    """
+    return html_content
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """Handle WebSocket connections"""
+    await websocket.accept()
+    connected_clients.add(websocket)
+    logger.info(f"Client connected. Total clients: {len(connected_clients)}")
+    
+    try:
+        while True:
+            # Just wait for disconnection
+            await websocket.receive_text()
+    except WebSocketDisconnect:
+        connected_clients.discard(websocket)
+        logger.info(f"Client disconnected. Total clients: {len(connected_clients)}")
+    except Exception as e:
+        logger.error(f"WebSocket error: {e}")
+        connected_clients.discard(websocket)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("debug_app:app", host="0.0.0.0", port=7861, reload=False)

download_models.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Script to download models from Hugging Face Hub if not present locally
+"""
+
+import logging
+import os
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def download_checkpoint_if_needed():
+    """Download model checkpoint if not present locally"""
+    # Check if we have any local checkpoints
+    possible_checkpoints = [
+        Path("agent_epoch_00206.pt"),
+        Path("agent_epoch_00003.pt"),
+        Path("checkpoints/agent_epoch_00206.pt"),
+        Path("checkpoints/agent_epoch_00003.pt"),
+    ]
+    
+    for ckpt_path in possible_checkpoints:
+        if ckpt_path.exists():
+            logger.info(f"Found local checkpoint: {ckpt_path}")
+            return True
+    
+    logger.info("No local checkpoint found, attempting to download from Hugging Face Hub...")
+    
+    try:
+        from huggingface_hub import hf_hub_download
+        
+        # This would download from a hypothetical HF model repository
+        # You would need to upload your models to HF Hub first
+        # Example:
+        # checkpoint_path = hf_hub_download(
+        #     repo_id="your-username/diamond-csgo-model",
+        #     filename="agent_epoch_00206.pt",
+        #     cache_dir="./checkpoints"
+        # )
+        
+        logger.warning("Model download not implemented yet.")
+        logger.warning("Please ensure you have model checkpoints available locally.")
+        return False
+        
+    except ImportError:
+        logger.error("huggingface_hub not installed. Cannot download models.")
+        return False
+    except Exception as e:
+        logger.error(f"Failed to download models: {e}")
+        return False
+
+def setup_demo_data():
+    """Set up minimal demo data if models are not available"""
+    spawn_dir = Path("csgo/spawn/0")
+    spawn_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Create minimal dummy files for demo
+    import numpy as np
+    import json
+    
+    files_to_create = {
+        "act.npy": np.zeros((100, 51)),  # 100 timesteps, 51 actions
+        "low_res.npy": np.zeros((100, 3, 150, 600)),  # 100 frames
+        "full_res.npy": np.zeros((100, 3, 300, 1200)),  # 100 high-res frames
+        "next_act.npy": np.zeros((100, 51)),
+    }
+    
+    for filename, data in files_to_create.items():
+        file_path = spawn_dir / filename
+        if not file_path.exists():
+            np.save(file_path, data)
+            logger.info(f"Created dummy file: {file_path}")
+    
+    # Create info.json
+    info_path = spawn_dir / "info.json"
+    if not info_path.exists():
+        info_data = {
+            "episode_length": 100,
+            "total_reward": 0.0,
+            "demo": True
+        }
+        with open(info_path, 'w') as f:
+            json.dump(info_data, f)
+        logger.info(f"Created info file: {info_path}")
+
+if __name__ == "__main__":
+    logger.info("Setting up Diamond CSGO demo...")
+    
+    # Try to download models
+    has_models = download_checkpoint_if_needed()
+    
+    # Set up demo data
+    setup_demo_data()
+    
+    if not has_models:
+        logger.warning("Running in demo mode without trained models.")
+        logger.warning("The AI agent will not function properly without model checkpoints.")
+    
+    logger.info("Setup complete!")

low_res.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50e10ae563ce86e98c58de99c2d3a0a4c0f111f6fde2c87323bd1d5eb5210d1a
+size 20288

npy_reader.py

@@ -0,0 +1,93 @@
+import numpy as np
+import os
+import sys
+
+def read_npy_file(file_path):
+    """
+    Read a .npy file and return the numpy array.
+    
+    Args:
+        file_path (str): Path to the .npy file
+        
+    Returns:
+        numpy.ndarray: The loaded numpy array
+        
+    Raises:
+        FileNotFoundError: If the file doesn't exist
+        ValueError: If the file is not a valid .npy file
+    """
+    try:
+        # Check if file exists
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"File not found: {file_path}")
+        
+        # Check if file has .npy extension
+        if not file_path.lower().endswith('.npy'):
+            print(f"Warning: File {file_path} doesn't have .npy extension")
+        
+        # Load the numpy array
+        array = np.load(file_path)
+        
+        print(f"Successfully loaded {file_path}")
+        print(f"Array shape: {array.shape}")
+        print(f"Array dtype: {array.dtype}")
+        print(f"Array size: {array.size}")
+        
+        return array
+        
+    except Exception as e:
+        raise ValueError(f"Error reading {file_path}: {str(e)}")
+
+def print_array_info(array, show_data=False, max_elements=10):
+    """
+    Print detailed information about a numpy array.
+    
+    Args:
+        array (numpy.ndarray): The numpy array to analyze
+        show_data (bool): Whether to show actual data values
+        max_elements (int): Maximum number of elements to display
+    """
+    print("\n" + "="*50)
+    print("ARRAY INFORMATION")
+    print("="*50)
+    print(f"Shape: {array.shape}")
+    print(f"Dtype: {array.dtype}")
+    print(f"Size: {array.size}")
+    print(f"Dimensions: {array.ndim}")
+    print(f"Memory usage: {array.nbytes} bytes")
+    
+    if array.size > 0:
+        print(f"Min value: {np.min(array)}")
+        print(f"Max value: {np.max(array)}")
+        print(f"Mean value: {np.mean(array)}")
+        print(f"Std deviation: {np.std(array)}")
+    
+    if show_data:
+        print("\nArray data:")
+        if array.size <= max_elements:
+            print(array)
+        else:
+            print(f"First {max_elements} elements:")
+            print(array.flat[:max_elements])
+            print("...")
+
+def main():
+    """
+    Main function to demonstrate usage.
+    """
+    
+    file_path = "/home/alienware3/Documents/diamond/low_res.npy"
+    
+    try:
+        # Read the NPY file
+        array = read_npy_file(file_path)
+        
+        # Print detailed information
+        print_array_info(array, show_data=True, max_elements=20)
+        
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

run_web_demo.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""
+Script to run the web demo locally for testing
+"""
+
+import logging
+import sys
+from pathlib import Path
+
+# Add project root to Python path
+root_path = Path(__file__).parent
+sys.path.insert(0, str(root_path))
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def main():
+    """Run the web demo"""
+    logger.info("Starting Diamond CSGO AI Player web demo...")
+    
+    try:
+        import uvicorn
+        from app import app
+        
+        # Run the server
+        uvicorn.run(
+            app,
+            host="0.0.0.0",
+            port=7860,
+            log_level="info",
+            reload=False  # Disable reload for production
+        )
+        
+    except ImportError as e:
+        logger.error(f"Missing dependencies: {e}")
+        logger.error("Please install requirements: pip install -r requirements.txt")
+        sys.exit(1)
+        
+    except Exception as e:
+        logger.error(f"Failed to start server: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

test_web_app.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the web app can be imported and basic functionality works
+"""
+
+import logging
+import sys
+from pathlib import Path
+
+# Add src to Python path
+src_path = Path(__file__).parent / "src"
+sys.path.insert(0, str(src_path))
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def test_imports():
+    """Test if all required modules can be imported"""
+    logger.info("Testing imports...")
+    
+    try:
+        # Test core modules
+        from config_web import web_config
+        logger.info("Web config imported")
+        
+        from src.csgo.web_action_processing import WebCSGOAction
+        logger.info("Web action processing imported")
+        
+        from src.game.web_play_env import WebPlayEnv
+        logger.info("Web play environment imported")
+        
+        # Test web framework
+        import fastapi
+        import uvicorn
+        logger.info("Web framework imported")
+        
+        # Test app
+        from app import app, WebGameEngine
+        logger.info("Main app imported")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Import failed: {e}")
+        return False
+
+def test_config():
+    """Test configuration setup"""
+    logger.info("Testing configuration...")
+    
+    try:
+        from config_web import web_config
+        
+        # Test path resolution
+        config_path = web_config.get_config_path()
+        logger.info(f"Config path: {config_path}")
+        
+        spawn_dir = web_config.get_spawn_dir()
+        logger.info(f"Spawn directory: {spawn_dir}")
+        
+        checkpoint_path = web_config.get_checkpoint_path()
+        logger.info(f"Checkpoint path: {checkpoint_path}")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Configuration test failed: {e}")
+        return False
+
+def test_action_processing():
+    """Test web action processing"""
+    logger.info("Testing action processing...")
+    
+    try:
+        from src.csgo.web_action_processing import WebCSGOAction, web_keys_to_csgo_action_names
+        
+        # Test key mapping
+        test_keys = {'KeyW', 'KeyA', 'Space'}
+        action_names = web_keys_to_csgo_action_names(test_keys)
+        logger.info(f"Key mapping: {test_keys} -> {action_names}")
+        
+        # Test action creation
+        action = WebCSGOAction(
+            key_names=action_names,
+            mouse_x=10,
+            mouse_y=5,
+            l_click=False,
+            r_click=False
+        )
+        logger.info(f"Action created: {action}")
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"Action processing test failed: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    logger.info("Starting Diamond CSGO web app tests...")
+    
+    tests = [
+        ("Imports", test_imports),
+        ("Configuration", test_config), 
+        ("Action Processing", test_action_processing),
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for name, test_func in tests:
+        logger.info(f"\n--- Testing {name} ---")
+        if test_func():
+            logger.info(f"PASS: {name} test passed")
+            passed += 1
+        else:
+            logger.error(f"FAIL: {name} test failed")
+    
+    logger.info(f"\n=== Test Results ===")
+    logger.info(f"Passed: {passed}/{total}")
+    
+    if passed == total:
+        logger.info("All tests passed! The web app should work correctly.")
+        return True
+    else:
+        logger.error("Some tests failed. Please check the errors above.")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)