Skill UI

Expert assistance for building, modifying, and debugging Minecraft server plugins for the Paper, Spigot, and Bukkit ecosystems. This includes implementing complex gameplay mechanics such as minigames, advanced combat systems, persistent player progression (perks, economy, quests), custom command handling, and robust state management. We handle configuration, listener registration, and adherence to best practices for Java-based server API usage.

This guide teaches how to build robust, event-driven gameplay in Godot 4.x using signals and node groups. It demonstrates how to decouple node communication by emitting custom signals (the observer pattern) and broadcasting actions to multiple nodes simultaneously using groups. Use this when a node needs to notify others of an event (e.g., item collected) or when you need to affect an entire category of nodes (e.g., pausing all enemies), eliminating the need for hard-coded scene references.

This skill provides an engine-neutral, high-level architecture for abstracting raw physical inputs (keys, buttons, touch) into named gameplay actions. It supports advanced features like multi-device binding, conflict detection, analog deadzones, input buffering, and coyote time, ensuring flexible and accessible control schemes for modern games.

A comprehensive guide for structuring and building playable game levels. This skill focuses on the engine-neutral process of blockout (whitebox/greybox), defining player metrics, pacing the experience (tension/rest curve), and mapping the critical path. It ensures that gameplay flow and mechanics are validated long before any final art or details are applied.

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.

This playbook guides the comprehensive design of complex survival and crafting games. It covers the core gameplay loop: resource gathering, managing survival needs (hunger, thirst, temperature), crafting items, building bases, and surviving escalating threats. Essential for developing deep, persistent sandbox experiences.

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.

This guide details the modern, action-based approach to handling player input in Unity using the Input System package. It covers setting up Input Actions, Action Maps, utilizing the PlayerInput component, and advanced coding patterns (callbacks, polling). Use this when building robust, device-agnostic gameplay controls for modern Unity projects.

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.

A comprehensive guide to implementing modern player input in Unreal Engine 5 using the Enhanced Input system. Learn how to set up Input Actions (IA_), Input Mapping Contexts (IMC_), modifiers, and triggers. Covers binding actions in both C++ and Blueprints, providing a data-driven approach to movement, looking, and general gameplay controls, moving beyond legacy input methods.

A comprehensive guide to building and controlling real-time visual effects (VFX) in Unreal Engine 5 using the Niagara system. Learn the System/Emitter/Module hierarchy, how to expose user parameters for game logic control, and methods for spawning and driving complex particle effects at runtime using both C++ and Blueprints. Ideal for gameplay-driven visual assets.