APlayerController

Used in net games so client can acknowledge it possessed a specific pawn.

Currently playing haptic effects for both the left and right hand

The type of async physics data object to use

Component that is used to only override where attenuation calculations are computed from.

Currently overridden vector used to do attenuation calculations for listener.

Component that is currently driving the audio listener position/orientation

Currently overridden location of audio listener

Currently overridden rotation of audio listener

True to allow this player controller to manage the camera target for you, typically by using the possessed pawn as the camera target.

The state of the inputs from cinematic mode

Is this player currently in cinematic mode? Prevents rotation/movement/firing/etc

Whether actor/component click events should be generated.

Whether or not to consider input from motion sources (tilt, acceleration, etc)

Whether actor/component mouse over events should be generated.

Whether the PlayerController should be used as a World Partiton streaming source.

Whether actor/component touch events should be generated.

Whether actor/component touch over events should be generated.

When cinematic mode is true, signifies that this controller's pawn should be hidden

Whether this controller is using streaming volumes.

Smoothed version of TargetViewRotation to remove jerkiness from intermittent replication updates.

Whether to override the attenuation listener position.

Whether to override the normal audio listener positioning method

True if PlayerController is currently waiting for the match to start or to respawn.

Whether to render primitives component.

When true, reduces connect timeout from InitialConnectionTimeOut to ConnectionTimeout.

Whether we fully tick when the game is paused, if our tick function is allowed to do so.

Whether the mouse cursor should be displayed.

Whether the PlayerController streaming source should activate cells after loading.

Whether the PlayerController streaming source should block on slow streaming.

Class of my CheatManager.

Object that manages "cheat" commands.

List of keys that will cause click events to be forwarded, default to left click

Cap set by server on bandwidth from client to server in bytes/sec (only has impact if >=2600)

Clickable object currently under the mouse cursor.

Trace channel currently being used for determining what world object was clicked on.

1. Current stack of InputComponents.

Currently visible mouse cursor

Touchable objects currently under fingers.

The currently set touch interface

Default trace channel used for determining what world object was clicked on.

Type of mouse cursor to show by default

For debugging, shows the last force feeback effects that played

Scale applied to force feedback values

Currently active force feedback weights

The actors which the camera shouldn't see - e.g. used to hide actors which the camera penetrates

Explicit components the camera shouldn't see (helpful for external systems to hide a component from a single player)

Distance to trace when computing click events

InputComponent we use when player is in Inactive state.

The value of SeamlessTravelCount, upon the last call to GameModeBase::HandleSeamlessTravelPlayer; used to detect seamless travel

Last real time (undilated) a hitch was detected in TickActor() when checking for forced client movement updates.

Last real time (undilated) recorded in TickActor() when checking for forced client movement updates.

Used to make sure the client is kept synchronized when in a spectator state

Last location synced on the server for a spectator.

Last rotation synced on the server for a spectator.

Last used FOV based multiplier to distance to an object when determining if it exceeds the object's cull distance

List of muted players in various categories

Heads up display associated with this PlayerController.

The net connection this controller is communicating on, nullptr for local players on server

Index identifying players using the same base connection (splitscreen clients) Used by netcode to match replicated PlayerControllers to the correct splitscreen viewport and child connection replicated via special internal code, not through normal variable replication

If set, then this UPlayerInput class will be used instead of the Input Settings' DefaultPlayerInputClass

List of names of levels the server is in the middle of sending us for a PrepareMapChange() call

This is set on the OLD PlayerController when performing a swap over a network connection so we know what connection we're waiting on acknowledgment from to finish destroying this PC (or when the connection is closed)

UPlayer associated with this PlayerController.

Camera/view related variables Camera manager associated with this Player Controller.

PlayerCamera class should be set for each game, otherwise Engine.PlayerCameraManager is used

Object that manages player input.

Input axes values, accumulated each tick.

Counter for this players seamless travels (used along with the below value, to restrict ServerNotifyLoadedWorld)

Interp speed for blending remote view rotation for smoother client updates

The location used internally when there is no pawn or spectator, to know where to spawn the spectator or focus the camera on death.

Color used for debugging.

PlayerController streaming source priority.

Optional aggregated shape list used to build a custom shape for the streaming source.

Used to replicate the view rotation of targets not owned/possessed by this PlayerController.

Handle for efficient management of UnFreeze timer

The virtual touch interface

Default Constructor

Called on the client to do local pawn setup after possession, before calling ServerAcknowledgePossession

Activates a new touch interface for this player controller

Called to try and enable cheats for this player, happens during initialization or from AllowCheats command

Add Pitch (look up) input. This value is multiplied by InputPitchScale.

Add Roll input. This value is multiplied by InputRollScale.

Add Yaw (turn) input. This value is multiplied by InputYawScale.

If bAutoManageActiveCameraTarget is true, then automatically manage the active camera target.

Pawn has been possessed, so changing state to NAME_Playing.

Event when spectating begins.

Builds a list of components that are hidden based upon gameplay.

Change Camera mode

*/

Clears out 'left-over' audio components.

Gives the PlayerController an opportunity to cleanup any changes it applied to the game viewport, primarily for the touch interface

Clear any overrides that have been applied to audio listener

Acknowledge received LevelVisibilityTransactionId

Adds a location to the texture streaming system for the specified duration.

Tells client to cancel any pending map change.

Set CurrentNetSpeed to the lower of its current value and Cap.

Removes all Camera Lens Effects.

Actually performs the level transition prepared by PrepareMapChange().

Tell the client to enable or disable voice chat (not muting)

Notify client that the session is about to start

Tells the client to block until all pending level streaming actions are complete happens at the end of the tick primarily used to force update the client ASAP at join time

Forces GC at the end of the tick on the client

Replicated function called by GameHasEnded().

Server uses this to force client into NewState .

Calls IgnoreLookInput on client

Calls IgnoreMoveInput on client

Outputs a message to HUD

Tell the client to mute a player for this controller

Play a force feedback pattern on the player's controller

Play sound client-side (so only the client will hear it)

Play sound client-side at the specified location

Asynchronously loads the given level in preparation for a streaming map transition.

Forces the streaming system to disregard the normal logic for the specified duration and instead always load all mip-levels for all textures used by the specified actor.

Send client localized message id

We call this in ::SendClientAdjustment to tell the client what the last processed input frame was for it and on what local frame number it was processed.

Development RPC for testing object reference replication

Tell client to reset the PlayerController

Tell client to restart the level

Assign Pawn to player, but avoid calling ClientRestart if we have already accepted this pawn

Return the client to the main menu gracefully

Tells the client to block until all pending level streaming actions are complete.

Tell client to fade camera bEnableFading - true if we should apply FadeColor/FadeAmount to the screen FadeColor - Color to fade to FadeAlpha - Contains the start fade (X) and end fade (Y) values to apply.

Replicated function to set camera style on client

Called by the server to synchronize cinematic transitions with the client

Forces the streaming system to disregard the normal logic for the specified duration and instead always load all mip-levels for all textures used by the specified material.

Set the client's class of HUD and spawns a new instance of it.

Indicate that the Spectator is waiting to join/respawn.

Set the view target

Spawn a camera lens effect (e.g. blood).

Play Camera Shake

Play Camera Shake localized to a given source

Notify client that the session is starting

Stop camera shake on client.

Stop camera shake on client.

Stops a playing force feedback pattern

Travel to a different map or IP address.

Internal clientside implementation of ClientTravel - use ClientTravel to call this

Tell the client to unmute a player for this controller

Tell the client to unmute an array of players for this controller

Replicated Update streaming status

Replicated Update streaming status.

Tells the client that the server has all the information it needs and that it is ok to start sending voice packets.

Notify client they were kicked from the server

Executes the Exec() command on the UPlayer object

*/

Create the touch interface, and activate an initial touch interface (if touch interface is desired)

Create virtual touch interface

Default implementation of pausing check for 'CanUnpause' delegates

*/

Convert current mouse 2D position to World Space 3D position and direction.

Convert 2D screen position to World Space 3D position and direction.

Destroys the SpectatorPawn and sets it to nullptr.

Run from the console to try and manually enable cheats which are disabled by default in multiplayer, games can override this

Leave playing state.

Event when no longer spectating.

Enqueues a command to run at the time specified by AsyncPhysicsTimestamp.

Flushes the current key state.

Forces a full replication check of the specified Actor on only the client that owns this PlayerController this function has no effect if this PC is not a remote client or if the Actor is not relevant to that client

Set the field of view to NewFOV

*/

Unmutes all remote players muted due to gameplay rules on the server and then tells the client to unmute

Unmutes a remote player on the server and then tells the client to unmute

Get the async physics data to execute logic off of.

Get the async physics data to write to.

Generates a timestamp for the upcoming physics step (plus any pending time).

Gets the attenuation position override.

Get audio listener position and orientation

Returns the location the PlayerController is focused on.

Returns hit results from doing a collision query at a certain location on the screen

Returns hit results from doing a collision query at a certain location on the screen

Returns hit results from doing a collision query at a certain location on the screen

Returns hit results from doing a collision query at a certain location on the screen

*/

Performs a collision query under the mouse cursor, looking on a trace channel

Performs a collision query under the mouse cursor, looking for object types

Performs a collision query under the finger, looking on a trace channel

Performs a collision query under the finger, looking for object types

Templated version of GetHUD, will return nullptr if cast fails

Gets the HUD currently being used by this player controller

Returns the analog value for the given key/button.

Retrieves the X and Y displacement of the given analog stick.

Returns how long the given key/button has been down.

Retrieves the current motion state of the player's input device

Retrieves how far the mouse moved this frame.

Retrieves the X and Y screen coordinates of the specified touch key.

Returns the vector value for the given key/button.

Returns the ULocalPlayer for this controller if it exists, or null otherwise

Returns the current estimated offset between the local async physics step and the server.

Calculate minimal respawn delay

Returns the current mouse cursor, or None

Retrieves the X and Y screen coordinates of the mouse cursor.

Returns the list of netcondition groups we are part of.

*/

Returns the first of GetPawn() or GetSpectatorPawn() that is not nullptr, or nullptr otherwise.

Returns the platform user that is assigned to this Player Controller's Local Player.

*/

*/

*/

Get the server network address

Get the location used when initially created, or when changing states when there is no pawn or spectator.

Get the Pawn used when spectating. nullptr when not spectating.

Returns the PlayerState associated with the player at the specified index.

Returns the number of split-screen players playing on this player's machine.

Gets the streaming source location and rotation.

Gets the streaming source priority.

Gets the streaming source priority.

Helper to get the size of the HUD canvas for this player controller. Returns 0 if there is no HUD

Returns whether the client has completely loaded the server's current world (valid on server only)

Make this player a member of a netcondition group.

Spawn the appropriate class of PlayerInput.

Handles a key press

Handles motion control

Handles a touch screen action

Returns true if input should be frozen (whether UnFreeze timer is active)

Returns true if the given input component is in this PlayerController's CurrentInputStack

Returns true if the given key/button is pressed on the input of the controller (if present)

Returns true if the player controller is a member of the netcondition group

Returns true if game is currently paused.

Is the specified player muted by this controlling player for any reason (gameplay, system, etc), check voice interface IsMuted() for system mutes

Wrapper for determining whether this player is the first player on their console.

Determines whether this player is playing split-screen.

Whether the PlayerController should be used as a World Partiton streaming source.

Play a force feedback pattern on the player's controller

*/

*/

Causes the client to travel to the given URL

Handles remapping a package name for networking, call on both the client and server when sending package names manually for RPCs

Called on the server when the client sends a message indicating it was unable to initialize an Actor channel, most commonly because the desired Actor's archetype couldn't be serialized the default is to do nothing (Actor simply won't exist on the client), but this function gives the game code an opportunity to try to correct the problem

Called to notify the server when the client has loaded a new world via seamless traveling

Notify the server that client data was received on the Pawn.

Called when player controller gets added to its owning world player controller list.

Called when player controller gets removed from its owning world player controller list.

Notify from server that Visual Logger is recording, to show that information on client about possible performance issues

Command to try to pause the game.

*/

Allows playing of a dynamic force feedback event from native code Begins playing when Start is called.

Processes player input (immediately after PlayerInput gets ticked) and calls UpdateRotation().

Play a haptic feedback curve on the player's controller

Removes given inputcomponent from the input stack (regardless of if it's the top, actually).

Method called after processing input

After successful world to screen projection, allows custom post-processing of the resulting ScreenLocation.

Called after this player controller has transitioned through seamless travel, but before that player is initialized This is called both when a new player controller is created, and when it is maintained

Called when the local player is about to travel to a new map or IP address.

Method called prior to processing input

Convert a World Space 3D position into a 2D Screen Space position.

Convert a World Space 3D position into a 3D Screen Space position.

Client pushes input data locally. RPC is sent here but also includes redundant data.

Adds an inputcomponent to the top of the input stack.

*/

Called after this PlayerController's viewport/net connection is associated with this player controller.

Called to notify the controller that the spectator class has been received.

Remove this player from a netcondition group.

Reset Camera Mode to default.

Resets the light color of the player's controller to default

Restarts the current level

Call ClientRetryClientRestart, but only if the current pawn is not the currently acknowledged pawn (and throttled to avoid saturating the network).

*/

Calls ServerSetSpectatorLocation but throttles it to reduce bandwidth and only calls it when necessary.

Called when seamless traveling and the specified PC is being replaced by this one copy over data that should persist (not called if PlayerController is the same for the from and to GameModes)

Called when seamless traveling and we are being replaced by the specified PC clean up any persistent state (post process chains on LocalPlayers, for example) (not called if PlayerController is the same for the from and to GameModes)

*/

Sends a command to the console to execute if not shipping version

Acknowledge possession of pawn

Tell the client to block a player for this controller

Change mode of camera

Change name of server

Tells the server to make sure the possessed pawn is in sync with the client.

Reliable version of ServerCheckClientPossession to be used when there is no likely danger of spamming the network.

Executes command on server (non shipping builds only)

RPC used by ServerExec. Not intended to be called directly

Tell the server to mute a player for this controller

Called to notify the server when the client has loaded a new world via seamless traveling

Replicate pause request to the server

Client says "Here is input frame number X" (and then calls other RPCs to deliver InputCmd payload)

Attempts to restart this player, generally called from the client upon respawn request.

When spectating, updates spectator location/rotation and pings the server to make sure spectating should continue.

Indicate that the Spectator is waiting to join/respawn.

Notifies the server that the client has ticked gameplay code, and should no longer get the extended "still loading" timeout grace period

Used by UGameplayDebuggingControllerComponent to replicate messages for AI debugging in network games.

Tell the client to unblock a player for this controller

Tell the server to unmute a player for this controller

• combine pitch/yaw into one int, maybe also send location compressed

Called when the client adds/removes a streamed level.

Called when the client adds/removes a streamed level.

Used by client to request server to confirm current viewtarget (server will respond with ClientSetViewTarget() ).

Move camera to next player on round ended or spectating

Move camera to previous player on round ended or spectating

Move camera to current user

Designate this player controller as local (public for GameModeBase to use, not expected to be called anywhere else)

Used to override the default positioning of the audio listener

*/

Adjust input based on cinematic mode

Server/SP only function for changing whether the player is in cinematic mode.

Sets the light color of the player's controller

Allows the player controller to disable all haptic requests from being fired, e.g. in the case of a level loading

Sets the value of the haptics for the specified hand directly, using frequency and amplitude.

Setup an input mode.

Sets the Widget for the Mouse Cursor to display

Positions the mouse cursor in screen space, in pixels.

*/

*/

Locally try to pause game (call serverpause to pause network game); returns success indicator.

Associate a new UPlayer with this PlayerController.

Set the SpawnLocation for use when changing states or when there is no pawn or spectator.

Set the spectator pawn.

Sets up input bindings for the input component pushed on the stack in the inactive state.

Allows the PlayerController to set up custom input bindings.

Set the view target

Set the view target blending with variable control

Set the virtual joystick visibility.

If true, then the GameViewportClient should call FlushPressedKeys on this controller when it loses focus.

Useful to spectate other pawn without un-possessing the current pawn

*/

Returns true if the mouse cursor should be shown

Called client-side to smoothly interpolate received TargetViewRotation (result is in BlendedTargetViewRotation)

Spawn a HUD (make sure that PlayerController always has valid HUD, even if ClientSetHUD() hasn't been called

*/

Spawn a SpectatorPawn to use as a spectator and initialize it.

*/

Start spectating mode, as the only mode allowed.

*/

Stops a playing haptic feedback curve

Disable voice chat transmission

Whether the PlayerController streaming source should activate cells after loading.

Whether the PlayerController streaming source should block on slow streaming.

*/

Internal.

Toggle voice chat on and off

*/

Update the camera manager; this is called after all actors have been ticked.

Builds a list of actors that are hidden based upon gameplay

Builds a list of components that are hidden based upon gameplay

*/

Updates the rotation of player, based on ControlRotation after RotationInput has been applied.

Refresh state specific input components

View next active player in PlayerArray.

Returns true if the given key/button was up last frame and down this frame.

Returns true if the given key/button was down last frame and up this frame.

State entered when inactive (no possessed pawn, not spectating, etc).

Change the current state to named state

*/

*/

Called when leaving the inactive state

GameMode failed to spawn pawn for me.

Called from game mode upon end of the game, used to transition to proper state.

Returns Player's Point of View For the AI this means the Pawn's 'Eyes' ViewPoint For a Human player, this means the Camera's ViewPoint

Get the actor the controller is looking at

Returns whether this Controller is a local controller.

*/

*/

Reset move and look input ignore flags to defaults

Set the initial location and rotation of the controller, as well as the control rotation.

Setter for Pawn. Normally should only be used internally when possessing/unpossessing a Pawn.

Whether this controller should persist through seamless travel Player controllers should always be included in seamless travel

Overridable native event for when play begins for this actor.

Calculate camera view point, when viewing this actor.

Called when this actor is explicitly being destroyed during gameplay or in the editor, not called during level streaming or gameplay ending

Called by DestroyActor(), gives actors a chance to op out of actor destruction Used by network code to have the net connection timeout/cleanup first

Removes this actor from the stack of input being handled by a PlayerController.

Pushes this actor on to the stack of input being handled by a PlayerController.

Overridable function called whenever this actor is being removed from a level

Called when the actor falls out of the world 'safely' (below KillZ and such)

Returns the point of view of the actor.

Get the owning connection used for communicating between client/server

Return the actor responsible for replication, if any. Typically the player controller

Return the owning UPlayer (if any) of this actor.

Function used to prioritize actors when deciding which to replicate

Overridden to return that player controllers are capable of RPCs

Checks to see if this actor is relevant for a specific network connection

Allows for a specific response from the actor when the actor channel is opened (client side)

Handles cleaning up the associated Actor when killing the connection

SerializeNewActor has just been called on the actor before network replication (server side)

Overridden to create the player replication info and perform other mundane initialization tasks.

Reset actor to initial state - used when restarting level without reloading.

Dispatches the once-per frame Tick() function for this actor

Used by the net connection to determine if a net owning actor should switch to using the shortened timeout value

Returns the properties used for network replication, this needs to be overridden by all actor classes with native replicated properties

Do any object-specific cleanup required immediately after loading an object.

Gets the PlayerController's streaming sources

Client

Frame number exchange.

Server

Pitch input speed scaling

Roll input speed scaling

Yaw input speed scaling

Please use ClientStartCameraShake

Please use ClientStartCameraShakeFromSource

As an FString, the ReturnReason parameter is not easily localized. Please use ClientReturnToMainMenuWithTextReason instead.

GetDeprecatedInputPitchScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.

GetDeprecatedInputRollScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.)

GetDeprecatedInputYawScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.

InputAxis has been deprecated, please use InputKey instead.

This version of InputKey has been deprecated, please use the version that takes FInputKeyParams instead

SetDeprecatedInputPitchScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.

SetDeprecatedInputRollScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.)

SetDeprecatedInputYawScale is deprecated, please use the Enhanced Input plugin Scalar Modifier instead.