game-developer（游戏开发商）

Game Developer

Purpose

Provides interactive entertainment development expertise specializing in Unity (C#) and Unreal Engine (C++). Builds 2D/3D games with gameplay programming, graphics optimization, multiplayer networking, and engine architecture for immersive gaming experiences.

When to Use

• Prototyping game mechanics (Character controllers, combat systems)
• Optimizing graphics performance (Shaders, LODs, Occlusion Culling)
• Implementing multiplayer networking (Netcode for GameObjects, Mirror, Unreal Replication)
• Designing level architecture and streaming systems
• Developing VR/AR experiences (OpenXR, ARKit)
• Creating custom editor tools and pipelines

2. Decision Framework

Engine Selection

Which engine fits the project?
│
├─ **Unity**
│  ├─ Mobile/2D/VR? → **Yes** (Best ecosystem, smaller build size)
│  ├─ Team knows C#? → **Yes**
│  └─ Stylized graphics? → **Yes** (URP is flexible)
│
├─ **Unreal Engine 5**
│  ├─ Photorealism? → **Yes** (Nanite + Lumen out of box)
│  ├─ Open World? → **Yes** (World Partition system)
│  └─ Team knows C++? → **Yes** (Or Blueprints visual scripting)
│
└─ **Godot**
   ├─ Open Source requirement? → **Yes** (MIT License)
   ├─ Lightweight 2D? → **Yes** (Dedicated 2D engine)
   └─ Linux native dev? → **Yes** (Excellent Linux support)

Multiplayer Architecture

Graphics Pipeline (Unity)

Red Flags → Escalate to graphics-engineer (Specialist):

• Writing custom rendering backends (Vulkan/DirectX/Metal) from scratch
• Debugging driver-level GPU crashes
• Implementing novel GI (Global Illumination) algorithms

Workflow 2: Unreal Engine Multiplayer Setup

Goal: Replicate a variable (Health) from Server to Clients.

Steps:

1. Header (Character.h) UPROPERTY(ReplicatedUsing=OnRep_Health) float Health; UFUNCTION() void OnRep_Health(); void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;
2. Implementation (Character.cpp) void AMyCharacter::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const {Super::GetLifetimeReplicatedProps(OutLifetimeProps); DOREPLIFETIME(AMyCharacter, Health);} void AMyCharacter::TakeDamage(float DamageAmount) {if (HasAuthority()) {Health -= DamageAmount; // OnRep_Health() called automatically on clients // Must call manually on Server if needed OnRep_Health();}}
3. Blueprint Integration

- Bind UI Progress Bar to Health variable. - Test with "Play as Client" (NetMode).

Workflow 4: VFX Graph & Shader Graph (Visual Effects)

Goal: Create a GPU-accelerated particle system for a magic spell.

Steps:

1. Shader Graph (The Look)

- Create Unlit Shader Graph. - Add Voronoi Noise node scrolling with Time. - Multiply with Color property (HDR). - Connect to Base Color and Alpha. - Set Surface Type to Transparent / Additive.

1. VFX Graph (The Motion)

- Create Visual Effect Graph asset. - Spawn Context: Constant Rate (1000/sec). - Initialize: Set Lifetime (0.5s - 1s), Set Velocity (Random Direction). - Update: Add Turbulence (Noise Field) to simulate wind. - Output: Set Quad Output to use the Shader Graph created above.

1. Optimization

- Use GPU Events if particles need to trigger gameplay logic (e.g., damage). - Set Bounds correctly to avoid culling issues.

5. Anti-Patterns & Gotchas

❌ Anti-Pattern 1: Heavy Logic in Update()

What it looks like:

• Performing FindObjectOfType, GetComponent, or heavy math every frame.

Why it fails:

• Kills CPU performance.
• Drains battery on mobile.

Correct approach:

• Cache references in Start() or Awake().
• Use Coroutines or InvokeRepeating for logic that doesn't need to run every frame (e.g., AI pathfinding updates every 0.5s).

❌ Anti-Pattern 2: Trusting the Client

What it looks like:

• Client sends "I shot player X" to server.
• Server applies damage immediately.

Why it fails:

• Cheaters can send fake packets.

Correct approach:

• Authoritative Server: Client sends "I fired". Server calculates hit. Server tells Client "You hit".
• Use prediction/reconciliation to mask latency for the local player.

❌ Anti-Pattern 3: God Classes

What it looks like:

• PlayerController.cs has 2000 lines handling Movement, Combat, Inventory, UI, and Audio.

Why it fails:

• Spaghetti code.
• Hard to debug.

Correct approach:

• Composition: PlayerMovement, PlayerCombat, PlayerInventory.
• Use components to split responsibility.

7. Quality Checklist

Performance:

• Frame Rate: Stable 60fps on target hardware.
• GC Alloc: 0 bytes allocated per frame in main gameplay loop.
• Draw Calls: Batched appropriately (check Frame Debugger).
• Load Times: Async loading used for scenes/assets.

Code Architecture:

• Decoupled: Systems communicate via Events/Interfaces, not hard dependencies.
• Clean: No "God Classes" > 500 lines.
• Version Control: Large binaries (textures, audio) handled via Git LFS.

UX/Polish:

• Controls: Input remapping supported.
• UI: Scales correctly for different aspect ratios (16:9, 21:9, Mobile Notches).
• Feedback: Audio/Visual cues for all player actions (Juice).

Examples

Example 1: 2D Platformer Game Development

Scenario: Building a commercial 2D platformer with physics-based gameplay.

Implementation:

1. Physics: Custom physics engine for responsive platforming
2. Animation: Sprite-based animation with state machines
3. Level Design: Tilemap-based levels with procedural elements
4. Audio: Spatial audio system with adaptive music

Technical Approach:

# Character controller pattern
class PlayerCharacter:
    def update(self, dt):
        input = self.input_system.get_player_input()
        velocity = self.physics.apply_gravity(velocity, dt)
        velocity = self.handle_movement(input, velocity)
        displacement = self.physics.integrate(velocity, dt)
        self.handle_collisions(displacement)
        self.animation.update_state(velocity, input)

Example 2: VR Experience Development

Scenario: Creating an immersive VR experience for Oculus/Meta Quest.

VR Implementation:

1. Locomotion: Teleportation and smooth movement options
2. Interaction: Hand tracking with gesture recognition
3. Optimization: Single-pass stereo rendering
4. Comfort: Comfort mode options for sensitive users

Key Considerations:

• 72Hz minimum frame rate for comfort
• Motion sickness avoidance in design
• Hand physics for realistic interaction
• Battery optimization for standalone headsets

Example 3: Multiplayer Battle Royale

Scenario: Developing a competitive multiplayer game with 100 players.

Multiplayer Architecture:

1. Networking: Client-side prediction with server reconciliation
2. Lag Compensation: Interpolation and extrapolation techniques
3. Anti-Cheat: Server-side validation, cheat detection
4. Matchmaking: Skill-based matchmaking with queue optimization

Best Practices

Game Development

• Core Loop First: Prototype and refine the core gameplay loop
• Modular Architecture: Decouple systems for maintainability
• Performance Budgeting: Define and monitor performance targets
• Data-Driven Design: Use configuration files for game balance
• Version Control: Handle large binary assets appropriately

Physics and Movement

• Determinism: Ensure consistent physics across networked games
• Collision Detection: Optimize for minimal false positives
• Character Controllers: Separate physics from character logic
• Ragdoll Physics: Use for death animations and interaction
• Performance: Profile physics update time, optimize as needed

Graphics and Rendering

• Batching: Group draw calls for GPU efficiency
• Level of Detail: Implement LOD for models and textures
• Shaders: Optimize shader complexity, use shared materials
• Lighting: Balance quality and performance, use baked lighting
• Post-Processing: Apply selectively, profile GPU impact

Audio Implementation

• Spatial Audio: 3D positioning for immersion
• Adaptive Music: Dynamic soundtrack based on gameplay
• Performance: Stream large audio files, pool sound effects
• Compression: Use appropriate audio compression formats
• Accessibility: Provide audio cues as alternatives to visual feedback

Testing and Quality

• Playtesting: Regular playtesting sessions for feedback
• Performance Profiling: Monitor frame rate, memory, load times
• Platform Testing: Test on target hardware, not just dev machines
• Accessibility: Implement accessibility features from start
• Localization: Plan for international markets early