Game engines
Universal AI development toolkit. 74 production-ready skills for every coding agent. Works with Claude Code, Cursor, Codex.
npx -y skills add medy-gribkov/arcana --skill game-enginesAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 1 stars1 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
What its author says it does
Copied from the file, not written here
Master game engines - Unity, Unreal Engine, Godot. Engine-specific workflows, systems architecture, and production best practices.
SKILL.md
17.6 KB, as published. Nobody here has run it
Game Engines & Frameworks
Engine Comparison
┌─────────────────────────────────────────────────────────────┐
│ ENGINE COMPARISON │
├─────────────────────────────────────────────────────────────┤
│ UNITY (C#): │
│ ├─ Best for: 2D/3D, Mobile, Indie, VR/AR │
│ ├─ Learning: Moderate │
│ ├─ Performance: Good (IL2CPP for native) │
│ └─ Market: 70%+ of mobile games │
│ │
│ UNREAL (C++/Blueprints): │
│ ├─ Best for: AAA, High-end graphics, Large teams │
│ ├─ Learning: Steep (C++) / Easy (Blueprints) │
│ ├─ Performance: Excellent │
│ └─ Market: Major console/PC titles │
│ │
│ GODOT (GDScript/C#): │
│ ├─ Best for: 2D games, Learning, Open source │
│ ├─ Learning: Easy │
│ ├─ Performance: Good for 2D, Improving for 3D │
│ └─ Market: Growing indie scene │
└─────────────────────────────────────────────────────────────┘
Unity Architecture
UNITY COMPONENT SYSTEM:
┌─────────────────────────────────────────────────────────────┐
│ GameObject │
│ ├─ Transform (required) │
│ ├─ Renderer (MeshRenderer, SpriteRenderer) │
│ ├─ Collider (BoxCollider, CapsuleCollider) │
│ ├─ Rigidbody (physics simulation) │
│ └─ Custom MonoBehaviour scripts │
│ │
│ LIFECYCLE: │
│ Awake() → OnEnable() → Start() → FixedUpdate() → │
│ Update() → LateUpdate() → OnDisable() → OnDestroy() │
└─────────────────────────────────────────────────────────────┘
// ✅ Production-Ready: Unity Component Pattern
public class PlayerController : MonoBehaviour
{
[Header("Movement Settings")]
[SerializeField] private float moveSpeed = 5f;
[SerializeField] private float jumpForce = 10f;
[Header("Ground Check")]
[SerializeField] private Transform groundCheck;
[SerializeField] private float groundRadius = 0.2f;
[SerializeField] private LayerMask groundLayer;
private Rigidbody2D _rb;
private bool _isGrounded;
private float _horizontalInput;
// Cache components in Awake
private void Awake()
{
_rb = GetComponent<Rigidbody2D>();
}
private void Update()
{
// Input in Update (frame-rate independent)
_horizontalInput = Input.GetAxisRaw("Horizontal");
if (Input.GetButtonDown("Jump") && _isGrounded)
{
Jump();
}
}
private void FixedUpdate()
{
// Physics in FixedUpdate (consistent timing)
CheckGround();
Move();
}
private void CheckGround()
{
_isGrounded = Physics2D.OverlapCircle(
groundCheck.position, groundRadius, groundLayer);
}
private void Move()
{
_rb.velocity = new Vector2(
_horizontalInput * moveSpeed,
_rb.velocity.y);
}
private void Jump()
{
_rb.velocity = new Vector2(_rb.velocity.x, jumpForce);
}
}
Unreal Engine Architecture
UNREAL ACTOR SYSTEM:
┌─────────────────────────────────────────────────────────────┐
│ AActor (Base class for all game objects) │
│ ├─ APawn (Can be possessed by controller) │
│ │ └─ ACharacter (Has CharacterMovementComponent) │
│ ├─ AGameMode (Game rules) │
│ └─ APlayerController (Player input handling) │
│ │
│ COMPONENTS: │
│ ├─ USceneComponent (Transform hierarchy) │
│ ├─ UStaticMeshComponent (3D model) │
│ ├─ UCapsuleComponent (Collision) │
│ └─ UCharacterMovementComponent (Movement logic) │
│ │
│ LIFECYCLE: │
│ Constructor → BeginPlay() → Tick() → EndPlay() │
└─────────────────────────────────────────────────────────────┘
// ✅ Production-Ready: Unreal Character
UCLASS()
class MYGAME_API AMyCharacter : public ACharacter
{
GENERATED_BODY()
public:
AMyCharacter();
virtual void BeginPlay() override;
virtual void Tick(float DeltaTime) override;
virtual void SetupPlayerInputComponent(
UInputComponent* PlayerInputComponent) override;
protected:
UPROPERTY(EditAnywhere, Category = "Movement")
float WalkSpeed = 600.0f;
UPROPERTY(EditAnywhere, Category = "Movement")
float SprintSpeed = 1200.0f;
UPROPERTY(EditAnywhere, Category = "Combat")
float MaxHealth = 100.0f;
private:
UPROPERTY()
float CurrentHealth;
bool bIsSprinting;
void MoveForward(float Value);
void MoveRight(float Value);
void StartSprint();
void StopSprint();
UFUNCTION()
void OnTakeDamage(float Damage, AActor* DamageCauser);
};
// Implementation
void AMyCharacter::BeginPlay()
{
Super::BeginPlay();
CurrentHealth = MaxHealth;
GetCharacterMovement()->MaxWalkSpeed = WalkSpeed;
}
void AMyCharacter::SetupPlayerInputComponent(
UInputComponent* PlayerInputComponent)
{
Super::SetupPlayerInputComponent(PlayerInputComponent);
PlayerInputComponent->BindAxis("MoveForward", this,
&AMyCharacter::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this,
&AMyCharacter::MoveRight);
PlayerInputComponent->BindAction("Sprint", IE_Pressed, this,
&AMyCharacter::StartSprint);
PlayerInputComponent->BindAction("Sprint", IE_Released, this,
&AMyCharacter::StopSprint);
}
Godot Architecture
GODOT NODE SYSTEM:
┌─────────────────────────────────────────────────────────────┐
│ Node (Base class) │
│ ├─ Node2D (2D game objects) │
│ │ ├─ Sprite2D │
│ │ ├─ CharacterBody2D │
│ │ └─ Area2D │
│ ├─ Node3D (3D game objects) │
│ │ ├─ MeshInstance3D │
│ │ ├─ CharacterBody3D │
│ │ └─ Area3D │
│ └─ Control (UI elements) │
│ │
│ LIFECYCLE: │
│ _init() → _ready() → _process() / _physics_process() │
│ │
│ SIGNALS (Event System): │
│ signal hit(damage) │
│ emit_signal("hit", 10) │
│ connect("hit", target, "_on_hit") │
└─────────────────────────────────────────────────────────────┘
# ✅ Production-Ready: Godot 4.x Player Controller (GDScript 2.0)
extends CharacterBody2D
class_name Player
# Signals use typed parameters in GDScript 2.0
signal health_changed(new_health: int, max_health: int)
signal died()
@export var move_speed: float = 200.0
@export var jump_force: float = 400.0
@export var max_health: int = 100
# @onready uses $ shorthand for get_node()
@onready var sprite: Sprite2D = $Sprite2D
@onready var animation: AnimationPlayer = $AnimationPlayer
@onready var coyote_timer: Timer = $CoyoteTimer
# get_setting returns ProjectSettings value
var gravity: float = ProjectSettings.get_setting("physics/2d/default_gravity")
var current_health: int
var can_coyote_jump: bool = false
func _ready() -> void:
current_health = max_health
func _physics_process(delta: float) -> void:
# Apply gravity
if not is_on_floor():
velocity.y += gravity * delta
# Handle coyote time (jump shortly after leaving edge)
if is_on_floor():
can_coyote_jump = true
elif can_coyote_jump and coyote_timer.is_stopped():
coyote_timer.start()
# Jump with Input.is_action_just_pressed (checks input map)
if Input.is_action_just_pressed("jump"):
if is_on_floor() or can_coyote_jump:
velocity.y = -jump_force
can_coyote_jump = false
# Horizontal movement - Input.get_axis returns -1 to 1
var direction := Input.get_axis("move_left", "move_right")
velocity.x = direction * move_speed
# Flip sprite based on direction
if direction != 0:
sprite.flip_h = direction < 0
# Update animation state
_update_animation()
# move_and_slide() is Godot 4.x API (no parameters needed)
move_and_slide()
func _update_animation() -> void:
if not is_on_floor():
animation.play("jump")
elif absf(velocity.x) > 10: # absf for float abs in GDScript 2.0
animation.play("run")
else:
animation.play("idle")
func take_damage(amount: int) -> void:
current_health = maxi(0, current_health - amount) # maxi for int max
health_changed.emit(current_health, max_health)
if current_health <= 0:
die()
func die() -> void:
died.emit()
queue_free()
func _on_coyote_timer_timeout() -> void:
can_coyote_jump = false
Godot 4.x API changes:
move_and_slide()no longer takes parameters (velocity is a property)absf()andmaxi()/maxf()for typed math functions@export,@onready,@toolannotations replaceexport,onready- Typed signals:
signal name(param: Type) is_on_floor()replacesis_on_floor()(same API, verified working)
Engine Feature Comparison
FEATURE MATRIX:
┌─────────────────────────────────────────────────────────────┐
│ Feature │ Unity │ Unreal │ Godot │
├───────────────────┼──────────────┼─────────────┼───────────┤
│ 2D Support │ Excellent │ Basic │ Excellent │
│ 3D Graphics │ Good │ Excellent │ Good │
│ Physics │ PhysX/Box2D │ Chaos/PhysX │ Godot │
│ Animation │ Animator │ AnimGraph │ AnimTree │
│ UI System │ uGUI/UITk │ UMG/Slate │ Control │
│ Networking │ Netcode/MLAPI│ Built-in │ ENet/Nakama│
│ Mobile │ Excellent │ Good │ Good │
│ Console │ Good │ Excellent │ Limited │
│ VR/AR │ Excellent │ Excellent │ Basic │
│ Learning Curve │ Moderate │ Steep │ Easy │
│ License │ Revenue-based│ 5% royalty │ MIT Free │
└───────────────────┴──────────────┴─────────────┴───────────┘
🔧 Troubleshooting
┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Low frame rate in editor │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS: │
│ → Disable unnecessary editor windows │
│ → Reduce scene view quality │
│ → Hide gizmos for complex objects │
│ → Build and test outside editor │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Physics behaving inconsistently │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS: │
│ → Use FixedUpdate/_physics_process for physics │
│ → Check fixed timestep settings │
│ → Avoid moving static colliders │
│ → Use continuous collision for fast objects │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Animations not playing correctly │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS: │
│ → Check animation state machine transitions │
│ → Verify animation clip import settings │
│ → Look for conflicting animation layers │
│ → Ensure root motion settings match │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Build size too large │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS: │
│ → Analyze build report │
│ → Remove unused assets │
│ → Compress textures and audio │
│ → Enable code stripping (Unity) / Shipping (Unreal) │
│ → Split into downloadable content │
└─────────────────────────────────────────────────────────────┘
Learning Paths
| Level | Unity | Unreal | Godot |
|---|---|---|---|
| Beginner (1-2 mo) | Ruby's Adventure | Blueprint Basics | Your First 2D Game |
| Intermediate (2-4 mo) | 3D Platformer | C++ Fundamentals | 3D Game Tutorial |
| Advanced (4-6 mo) | Networking + ECS | Multiplayer Shooter | Multiplayer + Plugins |
Use this skill: When learning game engines, building games, or optimizing engine performance.