3d FPS Game

You are acting as an expert Technical Game Designer, Systems Programmer, and 3D Technical Artist. 

Your objective is to guide and build a complete playable 3D First-Person Shooter (FPS) prototype from scratch. We will automate 3D asset creation, environment modeling, character rigging, and asset exporting by generating headless Python scripts for Blender (`bpy`), which is installed locally on my machine.

---

### Project Parameters & Tech Stack
1. **Target Engine/Framework:** [Select: Godot 4 / Unity / Unreal Engine 5 / Three.js / WebGPU]
2. **Game Core Mechanics:**
   - First-person controller: Smooth movement, mouse look, sprinting, crouching, jumping, and collision detection.
   - Gunplay: Hitscan or projectile raycasting, muzzle flash hook, recoil/spread, ADS (aim down sights), ammo counter, reloading logic.
   - Gameplay Loop: Enemy target dummies/simple AI agents with health pools, hit reaction, and respawn logic.
3. **Asset Pipeline:** Python scripting using Blender's Python API (`bpy`) running headlessly via terminal (`blender -b -P <script.py>`) to export production-ready `.gltf` / `.glb` or `.fbx` formats.

---

### Phase-by-Phase Deliverables

#### Phase 1: Automated Map Generation (Blender Python Script)
Generate a self-contained Python script (`build_map.py`) that executes inside Blender headlessly:
- **Geometry:** Procedurally generate a modular FPS arena (e.g., sci-fi industrial or warehouse layout) containing:
  - Floor grid with distinct zones and boundary walls.
  - Symmetrical cover obstacles (low barricades, high shipping containers, pillars).
  - Elevated catwalks or ramps for vertical gameplay.
- **Colliders & Optimization:**
  - Create simplified low-poly convex collision meshes or assign designated engine collider collision prefixes (e.g., `-col` for Godot, or custom layers).
  - Apply transformations (Location, Rotation, Scale: 1.0).
- **Materials:** Generate procedural, UV-unwrapped PBR materials with clear color coding (walkable floor, walls, obstacles, boundary zones).
- **Export:** Automatically export the entire scene as `map_arena.glb` with transforms baked.

#### Phase 2: Player & Weapon Model Generation & Rigging (Blender Python Script)
Generate a Python script (`build_character_and_arms.py`) that runs in Blender:
- **First-Person Viewmodel (Arms & Gun):**
  - Model low-poly arms and hands positioned in an FPS view perspective.
  - Model a stylized assault rifle / blaster weapon parented to the hand/weapon bone.
  - **Rigging:** Construct a basic FPS viewmodel armature:
    - Root bone, Left Arm chain (Clavicle, UpperArm, Forearm, Hand), Right Arm chain, Weapon root bone, and Magazine bone.
    - Automatically weight paint or bind meshes to vertex groups using automatic weights.
  - **Animations (Action Clips):** Script keyframed basic actions:
    - `Idle` (subtle breathing loop).
    - `Fire` (recoil snap backwards and return).
    - `Reload` (magazine detachment, downward dip, reload click).
- **Third-Person/Dummy Player Skin:**
  - Procedurally generate a stylized bipedal humanoid mesh (head, torso, limbs).
  - Add a standardized 15-bone humanoid armature (Hips, Spine, Chest, Neck, Head, Shoulders, Arms, Legs).
  - Parent mesh to armature with auto-weights and bake a T-pose and simple walk loop.
- **Export:** Export rigged models with embedded skinning weights and NLA animation strips to `viewmodel_arms.glb` and `player_skin.glb`.

#### Phase 3: Engine Architecture & Game Code
Provide the complete, clean source code for the FPS controller in the selected engine:
- **Camera & Weapon Viewmodel:** Viewmodel camera layering (to prevent weapon clipping through geometry).
- **Controller Logic:** Clean input handling with decoupled physics ticks and input polling.
- **Shooting System:** Raycast calculation from screen center, surface impact particle/bullet-hole hook, weapon fire rate limiter, and ammo depletion.
- **Asset Loading:** Code to dynamically or statically load `map_arena.glb` and the animated rigged models.

#### Phase 4: Local Execution Workflow & Command Line Calls
Provide the exact terminal/shell commands to:
1. Locate and run Blender via CLI across platforms (Windows / macOS / Linux).
2. Execute both generation scripts headlessly with output logging.
3. Verify that exported `.glb` files contain correct bone hierarchies and animations before importing into the game engine.

---

### Instructions for Your First Response:
1. State your assumptions regarding the game engine and ask me to confirm or specify the engine and visual theme if desired.
2. Immediately provide the complete code for **Phase 1 (`build_map.py`)** along with the CLI command to run it in Blender.
3. Outline the next steps for Phase 2.