+ Adhered to practices of caching, object pooling, physics step, texture optimization, memory usage, behavior trees, garbage collection, and using isDirty flags to gain optimized performance on all projects.
 

+ Used debug overlays and validation scripts to monitor cascade counts, tile indices, and queue states during runtime, preventing soft-locks and ensuring visual consistency.
 

+ Assisted in budgeting performance costs for art assets like Spine skeleton bone count and material count in 2D and similarly for 3d games.
 

+ Led and assisted in the performance handling of all project elements to find efficient ways to load textures and serialize data.
​

+ Collaborated with the Technical Director, Jason Emery, on a 'Slack Report' debug system to send logs and screenshots directly to a Slack channel for faster debugging.
​​

+ Extended existing 'Debug Cheats' menu for faster iteration and analysis of game session logs, payouts, isolated testing and gameboard troubleshooting.​
​

+ Utilized Firebase and UGS for crash exceptions and analytics.
 

General Optimization Checklist to reduce pain and suffering for other devs:

1. Physics Optimizations

• Physics Timestep: Increasing the project's Physics Timestep calculations to be slower (e.g., from 0.2s to 0.4s) gives slower updates on physics, but can be smoothed out with the Rigidbody component's smooth interpolation setting.

• Rigidbody2D Settings: Adjust settings like sleep mode, discrete collision detection, and non-interpolation to optimize physics calculations.

• Collision Matrix Detections: Optimize physics by minimizing unnecessary collision checks through collision layers and masks.

• Reduce Collision Components: Minimize collision components on actors based on distance to reduce unnecessary collision checks. Try distance-based instead, or centralizing things onto the Player for handling collision events if possible.
   

2. Graphics and Rendering Optimizations

• Turning Off Unused Renderers: Disable any graphical settings on a renderer (sprite, spine, 3d mesh) that is not used to reduce overhead.

• GPU Instancing & Batching: Use GPU instancing and batching to reduce draw calls and optimize rendering.

• Fixed DPI: Use fixed DPI settings to reduce graphical load.

• Texture Sizes & Compression: Optimize texture sizes and use compression to save memory and improve rendering performance.

• Transform Calls: Minimize the use of expensive transform calls.

• Culling Graphical Components: Use scripts to cull graphical components based on camera boundaries, both programmatically and through Unity’s settings.

• Minimize multiple sprite components that can create multiple transparencies, requiring more rendering passes.

• Music Compression: Use music compression to save memory and improve loading times.

• Spine Bone Followers and Animation Complexity: Reduce the number of bones and simplify animations in spine to reduce the rendering load.

• Skeleton Bone Count: Optimize the number of bones in skeleton animations to improve performance.

• Use Color32 Instead of Color: Save memory by using Color32 instead of Color.

• Draw Calls: Minimize draw calls by optimizing rendering paths and combining meshes.

• Raycast Targets: Optimize UI components by reducing unnecessary raycast targets.

• UI Raycasting: Reduce UI raycasting to minimize performance overhead.

• TextMeshPro Auto-Sizing: Avoid auto-sizing in TextMeshPro components to reduce performance costs associated with dynamic text resizing.
   

3. Memory Management Optimizations

• Manual Garbage Collection: Implement manual garbage collection to better control when memory is freed, reducing performance hitches.

• Declare Fewer New Variables: Minimize the declaration of new variables in scripts to reduce garbage collection overhead.

• Object Pooling: Use object pooling to reuse objects and avoid frequent instantiation and destruction, which reduces garbage collection overhead.

• Cache Instances: Cache instances to reduce expensive GetComponent and similar calls.
   

4. AI and Behavior Optimizations

• Centralized Scripts: Use centralized scripts like EnemyMovementManager to optimize AI calculations and logic. Register enemies on these movement managers and let the manager handle their update methods.

• Behavior Trees: Use behavior trees to manage complex AI logic more efficiently, can reduce tick to different rates of tick.
   

5. Data Management and Processing Optimizations

• Database Searching and Retrieval: Optimize database searching and retrieval to minimize performance impacts.

• Tokenization: Use tokenization to improve data handling and reduce processing times.

• Batch Processing: Implement batch processing to handle multiple operations in a single, more efficient pass.
   

6. Advanced Optimization Techniques

• Unity Jobs System: Use Unity’s Job System to run code in parallel on multiple CPU cores, improving performance for compute-heavy operations.

• DOTS (Data-Oriented Technology Stack): Use Unity's DOTS system to optimize game performance with a data-oriented approach to game design.
   

7. Miscellaneous Optimizations

• Prefab Variants: Use prefab variants to reduce memory usage and improve asset management.

• FixedDPI: Use fixed DPI settings for consistent visual performance across different devices.