Gameplay Framework

Every APawn is an AActor, but a Pawn adds the ability to be possessed by an AController. A Pawn represents an agent — player or AI — that receives input or AI control. A plain Actor is any world object with no possession concept.

An AActor is any UObject that can be placed or spawned into a level. It can hold components, has a transform via its root component, ticks, replicates, and runs the BeginPlay/EndPlay lifecycle. It is the unit of gameplay content in a world.

ACharacter is an APawn specialized for humanoid bipeds. It ships with a UCapsuleComponent, a skeletal mesh, and a UCharacterMovementComponent giving replicated walking, jumping, and falling. A bare Pawn has none and needs custom movement.

A UActorComponent is a reusable piece of behaviour or data owned by an AActor. It encapsulates one responsibility — movement, health, audio — so functionality is composed onto Actors. USceneComponent, a subclass, adds a transform.

The APlayerController handles a player's input, camera, and HUD and is mostly server-and-owner local. The APlayerState holds replicated per-player data — score, name, team — seen by all clients. Controller for control, PlayerState for stats.

Derive from UActorComponent, store MaxHealth and CurrentHealth, expose ApplyDamage/Heal that clamp the value, and broadcast a death event when health hits zero. A multicast delegate lets the owning Actor react without tight coupling.

An APlayerController represents a human player's intent. It receives input, possesses a Pawn, owns the camera and HUD, and is the player's network connection endpoint. It persists across Pawn deaths, so respawn logic and per-player UI live there.

Prefer composition when a behaviour — health, inventory, targeting — is needed by unrelated Actor types. A UActorComponent is reusable across any Actor, avoiding deep brittle hierarchies. Inheritance fits only true "is-a" relationships.

Bind a handler to the collision component's OnComponentHit or OnComponentBeginOverlap delegate, then route damage through UGameplayStatics::ApplyDamage. That fires the target's TakeDamage, keeping damage logic on the receiver.

The handler calls AddMovementInput with a world-axis vector that ignores the controller's yaw, so the character always moves along world X regardless of where it faces. Fix it by deriving the direction from the control rotation's forward vector.

The GameMode owns the rules of play: which classes to spawn, where players spawn, win/loss conditions, score authority, and match flow. It exists only on the server, so it is the authoritative place for rule decisions — never for replicated UI state.

The GameMode is the authoritative rules arbiter; if clients had their own copy they could decide outcomes locally and cheat. Server-only keeps one source of truth for rules. Shared state clients must see lives in the replicated AGameStateBase.

The GameState holds match-wide state every client must see: round timer, team scores, current phase, and the list of connected APlayerStates. It is replicated to all clients, the shared observable counterpart to the server-only GameMode.

The PlayerState holds per-player data that must survive the Pawn and be visible to all clients: name, score, kills, team, ping. One PlayerState exists per player and is replicated, so other clients can read each player's stats.

Call GetWorld()->SpawnActor<T>(Class, Transform, Params). Build an FTransform from the location, pass an FActorSpawnParameters, and always null-check the returned pointer — spawning can fail if the collision test rejects the location.

BeginPlay runs only after the actor and its components are fully spawned and registered and the level has started. Runtime SpawnActor fires it inside the spawn call; level actors get it when the world begins play; on a client it waits for the actor channel and initial replicated state. The constructor and PostInitializeComponents run earlier — never read replicated data there.

Record the world time when an ability fires, then gate the next use by checking elapsed time against the cooldown. Use GetWorld()->GetTimeSeconds() for the timestamp — comparing times avoids a Tick counter and survives variable frame rates.

Subsystems are engine-managed singletons with an automatic lifecycle. Kinds are scoped: UEngineSubsystem, UGameInstanceSubsystem, UWorldSubsystem, ULocalPlayerSubsystem. Each is created and destroyed with its owning scope.

The server is the only authority: it stores the cooldown end time against the replicated GameState's server clock, validates every activation request against it, and rejects calls that arrive too early. Replicate the end timestamp, not a ticking counter — clients derive remaining time locally from the synced clock. The client may predict the cooldown for UI responsiveness, but the server's value stays authoritative and corrects any mismatch.

Never let a client report damage as a number — it would just send a huge value. The client sends only intent ("I fired at this target") via a server RPC; the server validates everything — weapon owned and off cooldown, target in range and line-of-sight on the server's world — then computes and applies the damage. Health lives in a server-owned replicated property; clients receive results, never author them.

APlayerState outlives the Pawn — the Pawn is destroyed and re-spawned on death, but the same PlayerState persists, owned by the APlayerController. So per-player stats like score belong on the PlayerState, not the Pawn. Across seamless travel the engine creates fresh PlayerStates; data you must keep has to be carried forward by overriding CopyProperties, which the engine calls to migrate values onto the new instance.

AGameModeBase exists only on the server, so any property set on it is invisible to clients by design — it never replicates. The fix is to move shared data to AGameStateBase, which replicates to everyone, marking the property Replicated with an entry in GetLifetimeReplicatedProps. Trace it by confirming the value is written on the authority and that clients read it via GetGameState(), not GetGameMode().

Profile first with stat game and Unreal Insights to confirm tick is the hot path. Then cut it: disable tick where unneeded (bCanEverTick = false) and raise TickInterval for slow logic. The structural fix is to stop per-component ticks entirely — move shared logic into one subsystem or manager that iterates the set once per frame, turning thousands of virtual calls into a single tight loop.