using System;
using UnityEngine.Events;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.Users;
using UnityEngine.InputSystem.Utilities;
#if UNITY_EDITOR
using UnityEditor;
#endif
////REVIEW: should we automatically pool/retain up to maxPlayerCount player instances?
////REVIEW: the join/leave messages should probably give a *GameObject* rather than the PlayerInput component (which can be gotten to via a simple GetComponent(InChildren) call)
////TODO: add support for reacting to players missing devices
namespace UnityEngine.InputSystem
{
/// <summary>
/// Manages joining and leaving of players.
/// </summary>
/// <remarks>
/// This is a singleton component. Only one instance is meant to be active in a game
/// at any one time. To retrieve the current instance, use <see cref="instance"/>.
///
/// Note that a PlayerInputManager is not strictly required to have multiple <see cref="PlayerInput"/> components.
/// What PlayerInputManager provides is the implementation of specific player join mechanisms
/// (<see cref="joinBehavior"/>) as well as automatic assignment of split-screen areas (<see cref="splitScreen"/>).
/// However, you can always implement your own custom logic instead and simply instantiate multiple GameObjects with
/// <see cref="PlayerInput"/> yourself.
/// </remarks>
[AddComponentMenu("Input/Player Input Manager")]
[HelpURL(InputSystem.kDocUrl + "/manual/PlayerInputManager.html")]
public class PlayerInputManager : MonoBehaviour
{
/// <summary>
/// Name of the message that is sent when a player joins the game.
/// </summary>
public const string PlayerJoinedMessage = "OnPlayerJoined";
public const string PlayerLeftMessage = "OnPlayerLeft";
/// <summary>
/// If enabled, each player will automatically be assigned a portion of the available screen area.
/// </summary>
/// <remarks>
/// For this to work, each <see cref="PlayerInput"/> component must have an associated <see cref="Camera"/>
/// object through <see cref="PlayerInput.camera"/>.
///
/// Note that as player join, the screen may be increasingly subdivided and players may see their
/// previous screen area getting resized.
/// </remarks>
public bool splitScreen
{
get => m_SplitScreen;
set
{
if (m_SplitScreen == value)
return;
m_SplitScreen = value;
if (!m_SplitScreen)
{
// Reset rects on all player cameras.
foreach (var player in PlayerInput.all)
{
var camera = player.camera;
if (camera != null)
camera.rect = new Rect(0, 0, 1, 1);
}
}
else
{
UpdateSplitScreen();
}
}
}
////REVIEW: we probably need support for filling unused screen areas automatically
/// <summary>
/// If <see cref="splitScreen"/> is enabled, this property determines whether subdividing the screen is allowed to
/// produce screen areas that have an aspect ratio different from the screen resolution.
/// </summary>
/// <remarks>
/// By default, when <see cref="splitScreen"/> is enabled, the manager will add or remove screen subdivisions in
/// steps of two. This means that when, for example, the second player is added, the screen will be subdivided into
/// a left and a right screen area; the left one allocated to the first player and the right one allocated to the
/// second player.
///
/// This behavior makes optimal use of screen real estate but will result in screen areas that have aspect ratios
/// different from the screen resolution. If this is not acceptable, this property can be set to true to enforce
/// split-screen to only create screen areas that have the same aspect ratio of the screen.
///
/// This results in the screen being subdivided more aggressively. When, for example, a second player is added,
/// the screen will immediately be divided into a four-way split-screen setup with the lower two screen areas
/// not being used.
///
/// This property is irrelevant if <see cref="fixedNumberOfSplitScreens"/> is used.
/// </remarks>
public bool maintainAspectRatioInSplitScreen => m_MaintainAspectRatioInSplitScreen;
/// <summary>
/// If <see cref="splitScreen"/> is enabled, this property determines how many screen divisions there will be.
/// </summary>
/// <remarks>
/// This is only used if <see cref="splitScreen"/> is true.
///
/// By default this is set to -1 which means the screen will automatically be divided to best fit the
/// current number of players i.e. the highest player index in <see cref="PlayerInput"/>
/// </remarks>
public int fixedNumberOfSplitScreens => m_FixedNumberOfSplitScreens;
/// <summary>
/// The normalized screen rectangle available for allocating player split-screens into.
/// </summary>
/// <remarks>
/// This is only used if <see cref="splitScreen"/> is true.
///
/// By default it is set to <c>(0,0,1,1)</c>, i.e. the entire screen area will be used for player screens.
/// If, for example, part of the screen should display a UI/information shared by all players, this
/// property can be used to cut off the area and not have it used by PlayerInputManager.
/// </remarks>
public Rect splitScreenArea => m_SplitScreenRect;
/// <summary>
/// The current number of active players.
/// </summary>
/// <remarks>
/// This count corresponds to all <see cref="PlayerInput"/> instances that are currently enabled.
/// </remarks>
public int playerCount => PlayerInput.s_AllActivePlayersCount;
////FIXME: this needs to be settable
/// <summary>
/// Maximum number of players allowed concurrently in the game.
/// </summary>
/// <remarks>
/// If this limit is reached, joining is turned off automatically.
///
/// By default this is set to -1. Any negative value deactivates the player limit and allows
/// arbitrary many players to join.
/// </remarks>
public int maxPlayerCount => m_MaxPlayerCount;
/// <summary>
/// Whether new players can currently join.
/// </summary>
/// <remarks>
/// While this is true, new players can join via the mechanism determined by <see cref="joinBehavior"/>.
/// </remarks>
/// <seealso cref="EnableJoining"/>
/// <seealso cref="DisableJoining"/>
public bool joiningEnabled => m_AllowJoining;
/// <summary>
/// Determines the mechanism by which players can join when joining is enabled (<see cref="joiningEnabled"/>).
/// </summary>
/// <remarks>
/// </remarks>
public PlayerJoinBehavior joinBehavior
{
get => m_JoinBehavior;
set
{
if (m_JoinBehavior == value)
return;
var joiningEnabled = m_AllowJoining;
if (joiningEnabled)
DisableJoining();
m_JoinBehavior = value;
if (joiningEnabled)
EnableJoining();
}
}
/// <summary>
/// The input action that a player must trigger to join the game.
/// </summary>
/// <remarks>
/// If the join action is a reference to an existing input action, it will be cloned when the PlayerInputManager
/// is enabled. This avoids the situation where the join action can become disabled after the first user joins which
/// can happen when the join action is the same as a player in-game action. When a player joins, input bindings from
/// devices other than the device they joined with are disabled. If the join action had a binding for keyboard and one
/// for gamepad for example, and the first player joined using the keyboard, the expectation is that the next player
/// could still join by pressing the gamepad join button. Without the cloning behavior, the gamepad input would have
/// been disabled.
///
/// For more details about joining behavior, see <see cref="PlayerInput"/>.
/// </remarks>
public InputActionProperty joinAction
{
get => m_JoinAction;
set
{
if (m_JoinAction == value)
return;
////REVIEW: should we suppress notifications for temporary disables?
var joinEnabled = m_AllowJoining && m_JoinBehavior == PlayerJoinBehavior.JoinPlayersWhenJoinActionIsTriggered;
if (joinEnabled)
DisableJoining();
m_JoinAction = value;
if (joinEnabled)
EnableJoining();
}
}
public PlayerNotifications notificationBehavior
{
get => m_NotificationBehavior;
set => m_NotificationBehavior = value;
}
public PlayerJoinedEvent playerJoinedEvent
{
get
{
if (m_PlayerJoinedEvent == null)
m_PlayerJoinedEvent = new PlayerJoinedEvent();
return m_PlayerJoinedEvent;
}
}
public PlayerLeftEvent playerLeftEvent
{
get
{
if (m_PlayerLeftEvent == null)
m_PlayerLeftEvent = new PlayerLeftEvent();
return m_PlayerLeftEvent;
}
}
public event Action<PlayerInput> onPlayerJoined
{
add
{
if (value == null)
throw new ArgumentNullException(nameof(value));
m_PlayerJoinedCallbacks.AddCallback(value);
}
remove
{
if (value == null)
throw new ArgumentNullException(nameof(value));
m_PlayerJoinedCallbacks.RemoveCallback(value);
}
}
public event Action<PlayerInput> onPlayerLeft
{
add
{
if (value == null)
throw new ArgumentNullException(nameof(value));
m_PlayerLeftCallbacks.AddCallback(value);
}
remove
{
if (value == null)
throw new ArgumentNullException(nameof(value));
m_PlayerLeftCallbacks.RemoveCallback(value);
}
}
/// <summary>
/// Reference to the prefab that the manager will instantiate when players join.
/// </summary>
/// <value>Prefab to instantiate for new players.</value>
public GameObject playerPrefab
{
get => m_PlayerPrefab;
set => m_PlayerPrefab = value;
}
/// <summary>
/// Singleton instance of the manager.
/// </summary>
/// <value>Singleton instance or null.</value>
public static PlayerInputManager instance { get; private set; }
/// <summary>
/// Allow players to join the game based on <see cref="joinBehavior"/>.
/// </summary>
/// <seealso cref="DisableJoining"/>
/// <seealso cref="joiningEnabled"/>
public void EnableJoining()
{
switch (m_JoinBehavior)
{
case PlayerJoinBehavior.JoinPlayersWhenButtonIsPressed:
ValidateInputActionAsset();
if (!m_UnpairedDeviceUsedDelegateHooked)
{
if (m_UnpairedDeviceUsedDelegate == null)
m_UnpairedDeviceUsedDelegate = OnUnpairedDeviceUsed;
InputUser.onUnpairedDeviceUsed += m_UnpairedDeviceUsedDelegate;
m_UnpairedDeviceUsedDelegateHooked = true;
++InputUser.listenForUnpairedDeviceActivity;
}
break;
case PlayerJoinBehavior.JoinPlayersWhenJoinActionIsTriggered:
// Hook into join action if we have one.
if (m_JoinAction.action != null)
{
if (!m_JoinActionDelegateHooked)
{
if (m_JoinActionDelegate == null)
m_JoinActionDelegate = JoinPlayerFromActionIfNotAlreadyJoined;
m_JoinAction.action.performed += m_JoinActionDelegate;
m_JoinActionDelegateHooked = true;
}
m_JoinAction.action.Enable();
}
else
{
Debug.LogError(
$"No join action configured on PlayerInputManager but join behavior is set to {nameof(PlayerJoinBehavior.JoinPlayersWhenJoinActionIsTriggered)}",
this);
}
break;
}
m_AllowJoining = true;
}
/// <summary>
/// Inhibit players from joining the game.
/// </summary>
/// <seealso cref="EnableJoining"/>
/// <seealso cref="joiningEnabled"/>
public void DisableJoining()
{
switch (m_JoinBehavior)
{
case PlayerJoinBehavior.JoinPlayersWhenButtonIsPressed:
if (m_UnpairedDeviceUsedDelegateHooked)
{
InputUser.onUnpairedDeviceUsed -= m_UnpairedDeviceUsedDelegate;
m_UnpairedDeviceUsedDelegateHooked = false;
--InputUser.listenForUnpairedDeviceActivity;
}
break;
case PlayerJoinBehavior.JoinPlayersWhenJoinActionIsTriggered:
if (m_JoinActionDelegateHooked)
{
var joinAction = m_JoinAction.action;
if (joinAction != null)
m_JoinAction.action.performed -= m_JoinActionDelegate;
m_JoinActionDelegateHooked = false;
}
m_JoinAction.action?.Disable();
break;
}
m_AllowJoining = false;
}
////TODO
/// <summary>
/// Join a new player based on input on a UI element.
/// </summary>
/// <remarks>
/// This should be called directly from a UI callback such as <see cref="Button.onClick"/>. The device
/// that the player joins with is taken from the device that was used to interact with the UI element.
/// </remarks>
internal void JoinPlayerFromUI()
{
if (!CheckIfPlayerCanJoin())
return;
//find used device; InputSystemUIInputModule should probably make that available
throw new NotImplementedException();
}
/// <summary>
/// Join a new player based on input received through an <see cref="InputAction"/>.
/// </summary>
/// <param name="context"></param>
/// <remarks>
/// </remarks>
public void JoinPlayerFromAction(InputAction.CallbackContext context)
{
if (!CheckIfPlayerCanJoin())
return;
var device = context.control.device;
JoinPlayer(pairWithDevice: device);
}
public void JoinPlayerFromActionIfNotAlreadyJoined(InputAction.CallbackContext context)
{
if (!CheckIfPlayerCanJoin())
return;
var device = context.control.device;
if (PlayerInput.FindFirstPairedToDevice(device) != null)
return;
JoinPlayer(pairWithDevice: device);
}
/// <summary>
/// Spawn a new player from <see cref="playerPrefab"/>.
/// </summary>
/// <param name="playerIndex">Optional explicit <see cref="PlayerInput.playerIndex"/> to assign to the player. Must be unique within
/// <see cref="PlayerInput.all"/>. If not supplied, a player index will be assigned automatically (smallest unused index will be used).</param>
/// <param name="splitScreenIndex">Optional <see cref="PlayerInput.splitScreenIndex"/>. If supplied, this assigns a split-screen area to the player. For example,
/// a split-screen index of </param>
/// <param name="controlScheme">Control scheme to activate on the player (optional). If not supplied, a control scheme will
/// be selected based on <paramref name="pairWithDevice"/>. If no device is given either, the first control scheme that matches
/// the currently available unpaired devices (see <see cref="InputUser.GetUnpairedInputDevices()"/>) is used.</param>
/// <param name="pairWithDevice">Device to pair to the player. Also determines which control scheme to use if <paramref name="controlScheme"/>
/// is not given.</param>
/// <returns>The newly instantiated player or <c>null</c> if joining failed.</returns>
/// <remarks>
/// Joining must be enabled (see <see cref="joiningEnabled"/>) or the method will fail.
///
/// To pair multiple devices, use <see cref="JoinPlayer(int,int,string,InputDevice[])"/>.
/// </remarks>
public PlayerInput JoinPlayer(int playerIndex = -1, int splitScreenIndex = -1, string controlScheme = null, InputDevice pairWithDevice = null)
{
if (!CheckIfPlayerCanJoin(playerIndex))
return null;
PlayerInput.s_DestroyIfDeviceSetupUnsuccessful = true;
return PlayerInput.Instantiate(m_PlayerPrefab, playerIndex: playerIndex, splitScreenIndex: splitScreenIndex,
controlScheme: controlScheme, pairWithDevice: pairWithDevice);
}
/// <summary>
/// Spawn a new player from <see cref="playerPrefab"/>.
/// </summary>
/// <param name="playerIndex">Optional explicit <see cref="PlayerInput.playerIndex"/> to assign to the player. Must be unique within
/// <see cref="PlayerInput.all"/>. If not supplied, a player index will be assigned automatically (smallest unused index will be used).</param>
/// <param name="splitScreenIndex">Optional <see cref="PlayerInput.splitScreenIndex"/>. If supplied, this assigns a split-screen area to the player. For example,
/// a split-screen index of </param>
/// <param name="controlScheme">Control scheme to activate on the player (optional). If not supplied, a control scheme will
/// be selected based on <paramref name="pairWithDevices"/>. If no device is given either, the first control scheme that matches
/// the currently available unpaired devices (see <see cref="InputUser.GetUnpairedInputDevices()"/>) is used.</param>
/// <param name="pairWithDevices">Devices to pair to the player. Also determines which control scheme to use if <paramref name="controlScheme"/>
/// is not given.</param>
/// <returns>The newly instantiated player or <c>null</c> if joining failed.</returns>
/// <remarks>
/// Joining must be enabled (see <see cref="joiningEnabled"/>) or the method will fail.
/// </remarks>
public PlayerInput JoinPlayer(int playerIndex = -1, int splitScreenIndex = -1, string controlScheme = null, params InputDevice[] pairWithDevices)
{
if (!CheckIfPlayerCanJoin(playerIndex))
return null;
PlayerInput.s_DestroyIfDeviceSetupUnsuccessful = true;
return PlayerInput.Instantiate(m_PlayerPrefab, playerIndex: playerIndex, splitScreenIndex: splitScreenIndex,
controlScheme: controlScheme, pairWithDevices: pairWithDevices);
}
[SerializeField] internal PlayerNotifications m_NotificationBehavior;
[Tooltip("Set a limit for the maximum number of players who are able to join.")]
[SerializeField] internal int m_MaxPlayerCount = -1;
[SerializeField] internal bool m_AllowJoining = true;
[SerializeField] internal PlayerJoinBehavior m_JoinBehavior;
[SerializeField] internal PlayerJoinedEvent m_PlayerJoinedEvent;
[SerializeField] internal PlayerLeftEvent m_PlayerLeftEvent;
[SerializeField] internal InputActionProperty m_JoinAction;
[SerializeField] internal GameObject m_PlayerPrefab;
[SerializeField] internal bool m_SplitScreen;
[SerializeField] internal bool m_MaintainAspectRatioInSplitScreen;
[Tooltip("Explicitly set a fixed number of screens or otherwise allow the screen to be divided automatically to best fit the number of players.")]
[SerializeField] internal int m_FixedNumberOfSplitScreens = -1;
[SerializeField] internal Rect m_SplitScreenRect = new Rect(0, 0, 1, 1);
[NonSerialized] private bool m_JoinActionDelegateHooked;
[NonSerialized] private bool m_UnpairedDeviceUsedDelegateHooked;
[NonSerialized] private Action<InputAction.CallbackContext> m_JoinActionDelegate;
[NonSerialized] private Action<InputControl, InputEventPtr> m_UnpairedDeviceUsedDelegate;
[NonSerialized] private CallbackArray<Action<PlayerInput>> m_PlayerJoinedCallbacks;
[NonSerialized] private CallbackArray<Action<PlayerInput>> m_PlayerLeftCallbacks;
internal static string[] messages => new[]
{
PlayerJoinedMessage,
PlayerLeftMessage,
};
private bool CheckIfPlayerCanJoin(int playerIndex = -1)
{
if (m_PlayerPrefab == null)
{
Debug.LogError("playerPrefab must be set in order to be able to join new players", this);
return false;
}
if (m_MaxPlayerCount >= 0 && playerCount >= m_MaxPlayerCount)
{
Debug.LogError("Have reached maximum player count of " + maxPlayerCount, this);
return false;
}
// If we have a player index, make sure it's unique.
if (playerIndex != -1)
{
for (var i = 0; i < PlayerInput.s_AllActivePlayersCount; ++i)
if (PlayerInput.s_AllActivePlayers[i].playerIndex == playerIndex)
{
Debug.LogError(
$"Player index #{playerIndex} is already taken by player {PlayerInput.s_AllActivePlayers[i]}",
PlayerInput.s_AllActivePlayers[i]);
return false;
}
}
return true;
}
private void OnUnpairedDeviceUsed(InputControl control, InputEventPtr eventPtr)
{
if (!m_AllowJoining)
return;
if (m_JoinBehavior == PlayerJoinBehavior.JoinPlayersWhenButtonIsPressed)
{
// Make sure it's a button that was actuated.
if (!(control is ButtonControl))
return;
// Make sure it's a device that is usable by the player's actions. We don't want
// to join a player who's then stranded and has no way to actually interact with the game.
if (!IsDeviceUsableWithPlayerActions(control.device))
return;
////REVIEW: should we log a warning or error when the actions for the player do not have control schemes?
JoinPlayer(pairWithDevice: control.device);
}
}
private void OnEnable()
{
if (instance == null)
{
instance = this;
}
else
{
Debug.LogWarning("Multiple PlayerInputManagers in the game. There should only be one PlayerInputManager", this);
return;
}
// if the join action is a reference, clone it so we don't run into problems with the action being disabled by
// PlayerInput when devices are assigned to individual players
if (joinAction.reference != null && joinAction.action?.actionMap?.asset != null)
{
var inputActionAsset = Instantiate(joinAction.action.actionMap.asset);
var inputActionReference = InputActionReference.Create(inputActionAsset.FindAction(joinAction.action.name));
joinAction = new InputActionProperty(inputActionReference);
}
// Join all players already in the game.
for (var i = 0; i < PlayerInput.s_AllActivePlayersCount; ++i)
NotifyPlayerJoined(PlayerInput.s_AllActivePlayers[i]);
if (m_AllowJoining)
EnableJoining();
}
private void OnDisable()
{
if (instance == this)
instance = null;
if (m_AllowJoining)
DisableJoining();
}
/// <summary>
/// If split-screen is enabled, then for each player in the game, adjust the player's <see cref="Camera.rect"/>
/// to fit the player's split screen area according to the number of players currently in the game and the
/// current split-screen configuration.
/// </summary>
private void UpdateSplitScreen()
{
// Nothing to do if split-screen is not enabled.
if (!m_SplitScreen)
return;
// Determine number of split-screens to create based on highest player index we have.
var minSplitScreenCount = 0;
foreach (var player in PlayerInput.all)
{
if (player.playerIndex >= minSplitScreenCount)
minSplitScreenCount = player.playerIndex + 1;
}
// Adjust to fixed number if we have it.
if (m_FixedNumberOfSplitScreens > 0)
{
if (m_FixedNumberOfSplitScreens < minSplitScreenCount)
Debug.LogWarning(
$"Highest playerIndex of {minSplitScreenCount} exceeds fixed number of split-screens of {m_FixedNumberOfSplitScreens}",
this);
minSplitScreenCount = m_FixedNumberOfSplitScreens;
}
// Determine divisions along X and Y. Usually, we have a square grid of split-screens so all we need to
// do is make it large enough to fit all players.
var numDivisionsX = Mathf.CeilToInt(Mathf.Sqrt(minSplitScreenCount));
var numDivisionsY = numDivisionsX;
if (!m_MaintainAspectRatioInSplitScreen && numDivisionsX * (numDivisionsX - 1) >= minSplitScreenCount)
{
// We're allowed to produce split-screens with aspect ratios different from the screen meaning
// that we always add one more column before finally adding an entirely new row.
numDivisionsY -= 1;
}
// Assign split-screen area to each player.
foreach (var player in PlayerInput.all)
{
// Make sure the player's splitScreenIndex isn't out of range.
var splitScreenIndex = player.splitScreenIndex;
if (splitScreenIndex >= numDivisionsX * numDivisionsY)
{
Debug.LogError(
$"Split-screen index of {splitScreenIndex} on player is out of range (have {numDivisionsX * numDivisionsY} screens); resetting to playerIndex",
player);
player.m_SplitScreenIndex = player.playerIndex;
}
// Make sure we have a camera.
var camera = player.camera;
if (camera == null)
{
Debug.LogError(
"Player has no camera associated with it. Cannot set up split-screen. Point PlayerInput.camera to camera for player.",
player);
continue;
}
// Assign split-screen area based on m_SplitScreenRect.
var column = splitScreenIndex % numDivisionsX;
var row = splitScreenIndex / numDivisionsX;
var rect = new Rect
{
width = m_SplitScreenRect.width / numDivisionsX,
height = m_SplitScreenRect.height / numDivisionsY
};
rect.x = m_SplitScreenRect.x + column * rect.width;
// Y is bottom-to-top but we fill from top down.
rect.y = m_SplitScreenRect.y + m_SplitScreenRect.height - (row + 1) * rect.height;
camera.rect = rect;
}
}
private bool IsDeviceUsableWithPlayerActions(InputDevice device)
{
Debug.Assert(device != null);
if (m_PlayerPrefab == null)
return true;
var playerInput = m_PlayerPrefab.GetComponentInChildren<PlayerInput>();
if (playerInput == null)
return true;
var actions = playerInput.actions;
if (actions == null)
return true;
// If the asset has control schemes, see if there's one that works with the device plus
// whatever unpaired devices we have left.
if (actions.controlSchemes.Count > 0)
{
using (var unpairedDevices = InputUser.GetUnpairedInputDevices())
{
if (InputControlScheme.FindControlSchemeForDevices(unpairedDevices, actions.controlSchemes,
mustIncludeDevice: device) == null)
return false;
}
return true;
}
// Otherwise just check whether any of the maps has bindings usable with the device.
foreach (var actionMap in actions.actionMaps)
if (actionMap.IsUsableWithDevice(device))
return true;
return false;
}
private void ValidateInputActionAsset()
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
if (m_PlayerPrefab == null || m_PlayerPrefab.GetComponentInChildren<PlayerInput>() == null)
return;
var actions = m_PlayerPrefab.GetComponentInChildren<PlayerInput>().actions;
if (actions == null)
return;
var isValid = true;
foreach (var controlScheme in actions.controlSchemes)
{
if (controlScheme.deviceRequirements.Count > 0)
break;
isValid = false;
}
if (isValid) return;
var assetInfo = actions.name;
#if UNITY_EDITOR
assetInfo = AssetDatabase.GetAssetPath(actions);
#endif
Debug.LogWarning($"The input action asset '{assetInfo}' in the player prefab assigned to PlayerInputManager has " +
"no control schemes with required devices. The JoinPlayersWhenButtonIsPressed join behavior " +
"will not work unless the expected input devices are listed as requirements in the input " +
"action asset.", m_PlayerPrefab);
#endif
}
/// <summary>
/// Called by <see cref="PlayerInput"/> when it is enabled.
/// </summary>
/// <param name="player"></param>
internal void NotifyPlayerJoined(PlayerInput player)
{
Debug.Assert(player != null);
UpdateSplitScreen();
switch (m_NotificationBehavior)
{
case PlayerNotifications.SendMessages:
SendMessage(PlayerJoinedMessage, player, SendMessageOptions.DontRequireReceiver);
break;
case PlayerNotifications.BroadcastMessages:
BroadcastMessage(PlayerJoinedMessage, player, SendMessageOptions.DontRequireReceiver);
break;
case PlayerNotifications.InvokeUnityEvents:
m_PlayerJoinedEvent?.Invoke(player);
break;
case PlayerNotifications.InvokeCSharpEvents:
DelegateHelpers.InvokeCallbacksSafe(ref m_PlayerJoinedCallbacks, player, "onPlayerJoined");
break;
}
}
/// <summary>
/// Called by <see cref="PlayerInput"/> when it is disabled.
/// </summary>
/// <param name="player"></param>
internal void NotifyPlayerLeft(PlayerInput player)
{
Debug.Assert(player != null);
UpdateSplitScreen();
switch (m_NotificationBehavior)
{
case PlayerNotifications.SendMessages:
SendMessage(PlayerLeftMessage, player, SendMessageOptions.DontRequireReceiver);
break;
case PlayerNotifications.BroadcastMessages:
BroadcastMessage(PlayerLeftMessage, player, SendMessageOptions.DontRequireReceiver);
break;
case PlayerNotifications.InvokeUnityEvents:
m_PlayerLeftEvent?.Invoke(player);
break;
case PlayerNotifications.InvokeCSharpEvents:
DelegateHelpers.InvokeCallbacksSafe(ref m_PlayerLeftCallbacks, player, "onPlayerLeft");
break;
}
}
[Serializable]
public class PlayerJoinedEvent : UnityEvent<PlayerInput>
{
}
[Serializable]
public class PlayerLeftEvent : UnityEvent<PlayerInput>
{
}
}
}