Unity: C# scripting, great for 2D/mobile/indie games, asset store ecosystem, faster iteration. Lower hardware requirements.

Unreal: C++ foundation with Blueprint visual scripting, industry-standard for AAA, superior graphics out-of-the-box, built-in multiplayer framework.

The game loop runs continuously: Input → Update → Render → Present

• Input: Process player input and system events
• Update: Game logic, physics, AI, animation updates
• Render: Draw objects, apply effects, lighting calculations
• Present: Display frame buffer to screen

Delta time is the elapsed time between frames. Essential for frame-rate independent movement and animations.

Usage: position += velocity * deltaTime ensures consistent movement regardless of frame rate (30fps vs 60fps vs 144fps).

Entity: Unique identifier for game objects

Component: Data containers (Position, Health, Renderer)

System: Logic that operates on entities with specific components

Benefits: Better performance, modularity, memory locality. Used in Unity DOTS and custom engines.

• Viewport scaling: Scale viewport while maintaining aspect ratio
• UI anchoring: Anchor UI elements to screen edges or safe areas
• Dynamic layouts: Responsive UI that adapts to different sizes
• Asset variants: Different texture sizes for various devices

Shaders are GPU programs that control rendering. Types: Vertex (geometry transformation), Fragment/Pixel (color calculation).

Custom use cases: Unique visual effects, stylized rendering (toon shading), post-processing effects, optimization for specific art style.

Pre-allocate objects and reuse them instead of constant instantiation/destruction. Critical for bullets, enemies, particle effects.

Benefits: Reduces garbage collection, prevents frame drops, more predictable performance. Essential for mobile and VR games.

• Mobile: Lower poly counts, compressed textures, efficient shaders
• Console: Utilize specific hardware features, fixed specs optimization
• PC: Scalable quality settings, multiple resolution support
• VR: Maintain 90fps, reduce motion sickness, optimize for stereoscopic rendering

• AABB: Fast, simple, good for UI and 2D games
• Sphere collision: Very fast distance check, good for rough detection
• Mesh collision: Most accurate but expensive, use for static geometry
• Spatial partitioning: Octrees/quadtrees to reduce collision checks

Interpolation: Smooth movement between network updates

Acceleration/Deceleration: Gradually change velocity instead of instant stops

Physics integration: Use Rigidbody for natural movement, CharacterController for precise control.

Dynamic: Affected by physics forces, gravity, collisions. Used for physics objects, projectiles.

Kinematic: Moved by script, affects others but not affected. Used for player controllers, moving platforms.

Use raycasting from AI to target. Check if ray hits obstacles before reaching target.

Optimization: Use layers to ignore certain objects, cache results, check periodically rather than every frame.

Quaternions represent 3D rotations without gimbal lock. Four components (x, y, z, w) represent axis and angle.

Advantages: No gimbal lock, smooth interpolation (SLERP), compact representation, efficient composition.

Apply gravity to velocity over time: velocity.y += gravity * deltaTime

Advanced: Air resistance, spin effects, trajectory prediction for AI aiming, parabolic motion calculations.

Dividing game world into regions to quickly eliminate objects from expensive operations.

Types: Quadtree (2D), Octree (3D), Grid-based. Reduces collision checks from O(n²) to O(n log n) or better.

1. Vertex processing (transform coordinates)
2. Primitive assembly (triangles from vertices)
3. Rasterization (convert to pixels)
4. Fragment/pixel processing (lighting, textures)
5. Per-pixel operations (depth test, blending)

Draw calls are CPU commands to GPU to render objects. Each call has overhead.

• Batching: Combine similar objects into single draw call
• Atlasing: Pack multiple textures into one
• Instancing: Render many identical objects efficiently

Switch between different mesh/texture quality based on distance or screen size.

Implementation: Pre-generate LOD models, calculate distance/screen percentage, smoothly transition between levels to avoid popping.

Frustum culling: Don't render objects outside camera view

Occlusion culling: Don't render objects blocked by other objects. More complex but greater performance gains in dense scenes.

• Compression: DXT (PC), PVRTC (iOS), ETC (Android), ASTC (modern)
• Mipmapping: Pre-generated smaller versions for distance rendering
• Texture streaming: Load higher quality textures as needed
• Atlas optimization: Pack related textures, minimize wasted space

Render geometry to multiple buffers (G-buffer), then apply lighting in screen space.

Benefits: Efficient with many lights, decouples shading complexity. Drawbacks: Memory intensive, transparency issues.

States represent AI behaviors (Idle, Patrol, Chase, Attack). Transitions based on conditions.

Implementation: Enum for states, switch statement or state classes, transition conditions, enter/exit methods for each state.

A*: Most common, uses heuristic to guide search efficiently

Dijkstra: Guarantees shortest path but slower

Optimizations: Hierarchical pathfinding, jump point search, flow fields for groups, nav mesh for 3D worlds.

Create damage info struct with damage amount, type, source, modifiers. Use events for damage dealt/received.

Features: Damage types (physical, magic), resistances, critical hits, damage over time, area damage.

Decoupled communication between game systems. Publishers send events, subscribers listen.

Unity: UnityEvents, C# events. Custom: Observer pattern, message queues, type-safe delegates.

• Binary: Fast, compact, but version fragile
• JSON/XML: Human-readable, flexible, larger files
• Custom format: Optimized for your data structures
• Considerations: Save game versioning, corrupted save handling, incremental saves

Use interpolation: camera.position = Vector3.Lerp(camera.position, target.position, dampening * deltaTime)

Advanced: Look-ahead based on player velocity, dead zones for small movements, spring-damper systems.

• Client prediction: Show immediate response, reconcile with server
• Lag compensation: Server rewinds time for hit detection
• Interpolation: Smooth movement between network updates
• Delta compression: Send only changes, not full state

• Server authority: Server validates all game state changes
• Sanity checks: Validate player input feasibility (speed, distance)
• Encryption: Secure communication protocols
• Anti-cheat systems: Detect memory modification, packet inspection

• Profilers: Unity Profiler, Unreal Stat commands, custom timing
• Frame time analysis: Identify CPU vs GPU bottlenecks
• Memory profiling: Track allocations, find leaks, optimize GC
• A/B testing: Measure performance impact of optimizations