Skill UI

A comprehensive guide focused on mastering the Entity Component System (ECS) architecture within the Bevy game engine using Rust. Learn best practices for building high-performance, data-oriented game logic. This covers defining components, writing parallel systems, managing global resources, and optimizing queries for efficient, scalable game development.

This skill provides production-grade patterns for Unity's Data-Oriented Technology Stack (DOTS). It covers essential components like Entity Component System (ECS), the Job System, and the Burst Compiler, enabling developers to build high-performance, scalable games. Use this when optimizing CPU-bound logic, managing thousands of entities, or migrating traditional OOP game code to a data-oriented design.

This skill is a comprehensive guide for authors preparing microeconomic theory, game theory, or theoretical IO manuscripts for submission to the American Economic Journal: Microeconomics. It analyzes journal fit, required theoretical rigor, methodological standards, house style, and potential pitfalls (desk-reject heuristics), helping authors refine their work before formal submission.

This guide serves as a comprehensive pre-submission self-check tool for authors targeting the journal Games and Economic Behavior (GEB). It details the journal's scope, required game-theoretic contributions (e.g., new models, equilibrium results, mechanisms), methodological rigor, and adherence to house style. It helps authors assess if their work is genuinely game-theoretic and provides guidance on re-framing strategies and potential alternative venues.

A rigorous self-assessment tool for academic manuscripts in game theory and economic behavior. It guides the identification of core assumptions, tests the logical architecture of proofs, and verifies the generalizability of results. It covers both theoretical proofs (e.g., equilibrium, mechanism design) and experimental designs, ensuring the argument withstands specialist scrutiny.

A comprehensive guide to implementing animation in Godot 4.x using the three core specialized tools: AnimationPlayer for keyframed clips, AnimationTree for complex state machine logic and blending (ideal for character locomotion), and Tween for short, procedural UI or object movements. Learn when and how to drive transitions in a game environment.

This guide details writing Godot game logic using C#/.NET (targeting Godot 4.7 and .NET 8). It covers core concepts like implementing partial classes, overriding lifecycle methods (_Ready, _Process), handling exported properties, treating signals as type-safe C# events, and performing interop with GDScript. It is ideal for developing complex, performance-critical game systems that require strong typing and object-oriented programming paradigms.

A comprehensive pattern for developing board-based puzzle games (e.g., Match-3, Sokoban, Logic Grids). This skill focuses on modeling the board state, move input validation, and the core rule resolution loop. It defines how cascades, scoring, and undo functionality must operate deterministically to ensure fair and bug-free gameplay, separating game logic from visual rendering.

A comprehensive playbook for designing and balancing Tower Defense (TD) games. This skill outlines the core systems required, including enemy pathing, wave spawning, tower targeting logic, and the overarching game economy. It helps developers structure the core loop, manage difficulty curves, and balance resource management against threat escalation.

A comprehensive guide to writing correct and idiomatic gameplay scripts using C# within the Unity engine. Covers the entire MonoBehaviour lifecycle (Awake, Update, FixedUpdate, etc.), efficient component caching, serialization best practices, and implementing time-sequenced logic using coroutines for deterministic and high-performance gaming behavior.

Learn how to build complex, reusable gameplay logic in Unreal Engine 5 using Blueprints. This guide covers Blueprint Classes, Event Graphs, Construction Scripts, and advanced communication methods (Interfaces, Event Dispatchers) to structure decoupled game systems without writing C++. Ideal for designers and developers who prefer visual scripting.

Master the technical foundation of gameplay programming in Unreal Engine 5 using C++. This skill covers essential concepts such as reflection macros (UCLASS, UPROPERTY, UFUNCTION), understanding the core Gameplay Framework roles (Pawn, Character, GameMode), and correctly structuring module dependencies using Build.cs. Use this when writing low-level game logic, exposing C++ features to Blueprints, or integrating custom systems into the Unreal ecosystem.