Game Developer

by jeffallan1be15d8064f8MIT11K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 5 days ago

Use when building game systems, implementing Unity/Unreal Engine features, or optimizing game performance. Invoke to implement ECS architecture, configure physics systems and colliders, set up multiplayer networking with lag compensation, optimize frame rates to 60+ FPS targets, develop shaders, or apply game design patterns such as object pooling and state machines. Trigger keywords: Unity, Unreal Engine, game development, ECS architecture, game physics, multiplayer networking, game optimization, shader programming, game AI.

Instructions onlySoftware Development

AI-generated overview

Guides implementation of Unity and Unreal game systems, including ECS, physics, networking, shaders and performance optimization.

What it does: This skill provides implementation guidance for game development in Unity and Unreal Engine. It covers ECS architecture, physics and colliders, multiplayer networking with lag compensation, shader work, and performance optimization toward 60+ FPS targets. It also supplies reference documents on Unity patterns, Unreal C++, ECS patterns, performance optimization and multiplayer networking, and returns code-oriented output such as systems, data structures and optimization notes.
When to use it: Use it when building game systems or implementing Unity or Unreal Engine features. It fits tasks involving ECS architecture, game physics, multiplayer networking, shader programming, game AI, or frame-rate and memory optimization.
Requirements: No scripts are shipped; the skill is instructions and reference documents only. Working in Unity or Unreal Engine is implied by the guidance, and profiling tools such as Unity Profiler or Unreal Insights are referenced for validation.

Game Developer

Core Workflow

Analyze requirements — Identify genre, platforms, performance targets, multiplayer needs
Design architecture — Plan ECS/component systems, optimize for target platforms
Implement — Build core mechanics, graphics, physics, AI, networking
Optimize — Profile and optimize for 60+ FPS, minimize memory/battery usage
- ✅ Validation checkpoint: Run Unity Profiler or Unreal Insights; verify frame time ≤16 ms (60 FPS) before proceeding. Identify and resolve CPU/GPU bottlenecks iteratively.
Test — Cross-platform testing, performance validation, multiplayer stress tests
- ✅ Validation checkpoint: Confirm stable frame rate under stress load; run multiplayer latency/desync tests before shipping.

Reference Guide

Load detailed guidance based on context:

Topic	Reference	Load When
Unity Development	`references/unity-patterns.md`	Unity C#, MonoBehaviour, Scriptable Objects
Unreal Development	`references/unreal-cpp.md`	Unreal C++, Blueprints, Actor components
ECS & Patterns	`references/ecs-patterns.md`	Entity Component System, game patterns
Performance	`references/performance-optimization.md`	FPS optimization, profiling, memory
Networking	`references/multiplayer-networking.md`	Multiplayer, client-server, lag compensation

Constraints

MUST DO

Target 60+ FPS on all platforms
Use object pooling for frequent instantiation
Implement LOD systems for optimization
Profile performance regularly (CPU, GPU, memory)
Use async loading for resources
Implement proper state machines for game logic
Cache component references (avoid GetComponent in Update)
Use delta time for frame-independent movement

MUST NOT DO

Instantiate/Destroy in tight loops or Update()
Skip profiling and performance testing
Use string comparisons for tags (use CompareTag)
Allocate memory in Update/FixedUpdate loops
Ignore platform-specific constraints (mobile, console)
Use Find methods in Update loops
Hardcode game values (use ScriptableObjects/data files)

Output Templates

When implementing game features, provide:

Core system implementation (ECS component, MonoBehaviour, or Actor)
Associated data structures (ScriptableObjects, structs, configs)
Performance considerations and optimizations
Brief explanation of architecture decisions

Key Code Patterns

Object Pooling (Unity C#)

csharp

public class ObjectPool<T> where T : Component{    private readonly Queue<T> _pool = new();    private readonly T _prefab;    private readonly Transform _parent;
    public ObjectPool(T prefab, int initialSize, Transform parent = null)    {        _prefab = prefab;        _parent = parent;        for (int i = 0; i < initialSize; i++)            Release(Create());    }
    public T Get()    {        T obj = _pool.Count > 0 ? _pool.Dequeue() : Create();        obj.gameObject.SetActive(true);        return obj;    }
    public void Release(T obj)    {        obj.gameObject.SetActive(false);        _pool.Enqueue(obj);    }
    private T Create() => Object.Instantiate(_prefab, _parent);}

public class ObjectPool<T> where T : Component{    private readonly Queue<T> _pool = new();    private readonly T _prefab;    private readonly Transform _parent;
    public ObjectPool(T prefab, int initialSize, Transform parent = null)    {        _prefab = prefab;        _parent = parent;        for (int i = 0; i < initialSize; i++)            Release(Create());    }
    public T Get()    {        T obj = _pool.Count > 0 ? _pool.Dequeue() : Create();        obj.gameObject.SetActive(true);        return obj;    }
    public void Release(T obj)    {        obj.gameObject.SetActive(false);        _pool.Enqueue(obj);    }
    private T Create() => Object.Instantiate(_prefab, _parent);}

Component Caching (Unity C#)

csharp

public class PlayerController : MonoBehaviour{    // Cache all component references in Awake — never call GetComponent in Update    private Rigidbody _rb;    private Animator _animator;    private PlayerInput _input;
    private void Awake()    {        _rb = GetComponent<Rigidbody>();        _animator = GetComponent<Animator>();        _input = GetComponent<PlayerInput>();    }
    private void FixedUpdate()    {        // Use cached references; use deltaTime for frame-independence        Vector3 move = _input.MoveDirection * (speed * Time.fixedDeltaTime);        _rb.MovePosition(_rb.position + move);    }}

public class PlayerController : MonoBehaviour{    // Cache all component references in Awake — never call GetComponent in Update    private Rigidbody _rb;    private Animator _animator;    private PlayerInput _input;
    private void Awake()    {        _rb = GetComponent<Rigidbody>();        _animator = GetComponent<Animator>();        _input = GetComponent<PlayerInput>();    }
    private void FixedUpdate()    {        // Use cached references; use deltaTime for frame-independence        Vector3 move = _input.MoveDirection * (speed * Time.fixedDeltaTime);        _rb.MovePosition(_rb.position + move);    }}

State Machine (Unity C#)

csharp

public abstract class State{    public abstract void Enter();    public abstract void Tick(float deltaTime);    public abstract void Exit();}
public class StateMachine{    private State _current;
    public void TransitionTo(State next)    {        _current?.Exit();        _current = next;        _current.Enter();    }
    public void Tick(float deltaTime) => _current?.Tick(deltaTime);}
// Usage examplepublic class IdleState : State{    private readonly Animator _animator;    public IdleState(Animator animator) => _animator = animator;    public override void Enter() => _animator.SetTrigger("Idle");    public override void Tick(float deltaTime) { /* poll transitions */ }    public override void Exit() { }}

public abstract class State{    public abstract void Enter();    public abstract void Tick(float deltaTime);    public abstract void Exit();}
public class StateMachine{    private State _current;
    public void TransitionTo(State next)    {        _current?.Exit();        _current = next;        _current.Enter();    }
    public void Tick(float deltaTime) => _current?.Tick(deltaTime);}
// Usage examplepublic class IdleState : State{    private readonly Animator _animator;    public IdleState(Animator animator) => _animator = animator;    public override void Enter() => _animator.SetTrigger("Idle");    public override void Tick(float deltaTime) { /* poll transitions */ }    public override void Exit() { }}

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation

Source and attribution

Source:jeffallan/claude-skillsinskills/game-developerat commit1be15d8

License: MIT

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Game Developer

Game Developer

Core Workflow

Reference Guide

Constraints

MUST DO

MUST NOT DO

Output Templates

Key Code Patterns

Object Pooling (Unity C#)

Component Caching (Unity C#)

State Machine (Unity C#)

Source and attribution

More from jeffallan/claude-skills

Wordpress Pro

Vue Expert Js

The Fool

Swift Expert

Sql Pro

Spring Boot Engineer

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Dpop Adoption

Gemini Live Api

Gemini Api