Input System - local multiplayer

Unity Engine
1

I am creating a game that has the option of local multiplayer, I’ve done it before, but using unity’s standard InputManager, but had several device recognition issues, sometimes forcing the player to restart the game.

So I want to use this new system that looks a lot better, but I’m facing some implementation problems. I will already configure the basic commands of the player, such as shoot, move … but when trying to start configuring the local cooperative mode I came across some problems.

A player may have multiple devices connected, I want to give him the option to choose which device will control his ship in the game and if that device is disconnected or he decides to use the keyboard during multiplayer, the game recognizes the change and changes the device. paired with that particular player.

I know this is possible in this new system, but I have no idea how to get devices connected and pair with a player via code, or how to detect if the player pressed a key from a device not paired with a player and pair. How do I do that?

  • Get a list of connected devices
  • Pick a device and pair with a particular player when he appears in the scene.
  • Detect if an unpaired device is being used and pair with the player.

Already searched in forums, websites and youtube, found nothing.

Note: my english is not very good, sorry if that got confusing.

2

Built-in join behaviors are provided by the PlayerInputManager component. This does not cover all possible scenarios but depending on your use case may work for you. A short demonstration can be found in the Unite Copenhagen talk. It will handle joins such that players are automatically paired to devices they have joined from.

For going from scratch, here’s a couple API pointers.

  • PlayerInput.Instantiate for instantiating players with specific devices paired to them
  • InputUser.PerformPairingWithDevice for manually performing pairing
  • InputSystem.devices to get all connected devices
  • InputUser.GetUnpairedDevices() to get a list of devices not currently paired to any user
  • InputUser.onUnpairedDeviceUsed for listening to activity on unpaired devices
// Listening must be enabled explicitly.
++InputUser.listenForUnpairedDeviceActivity;

// Example of how to spawn a new player automatically when a button
// is pressed on an unpaired device.
InputUser.onUnpairedDeviceUsed +=
    (control, eventPtr) =>
    {
        // Ignore anything but button presses.
        if (!(control is ButtonControl))
            return;

        // Spawn player and pair device. If the player's actions have control schemes
        // defined in them, PlayerInput will look for a compatible scheme automatically.
        PlayerInput.Instantiate(playerPrefab, device: control.device);
    };

If you roll your own joining logic and you have control schemes, make sure to set neverAutoSwitchControlSchemes to true on the players in order to prevent the first player in the game from switching away from paired devices on input.

4 Likes
3

What is the InputUser? I can’t find it UnityEngine.Inputsystem, or when trying to add a component.

nvmd found it under
UnityEngine.InputSystem.Users

4

Any examples of how to create a local multiplayer without PlayerInput? I want to use an existing game object without instantiating prefabs.

5

I will answer my own question :). I had to pair a device with a user and then assign input actions. Below I paste minimal example for assigning a single gamepad to the user.

        _actions = new GameplayInputActions();
        _user = InputUser.PerformPairingWithDevice(Gamepad.all[_gamepadNumber]);
        _user.AssociateActionsWithUser(_actions);
        _user.ActivateControlScheme(_schemeName);
5 Likes
6

Can you paste the whole code?Or github link is also okay thank you

7

I followed Koru’s lead and managed to have local multiplayer without using PlayerInput or PlayerInputManager.
Here is the relevant code for my mutliplayer Tetris clone.
To see the code in context (in a working project) check out the source.
Keep in mind that the Tetris class here basically is the player.

using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.LowLevel;
using UnityEngine.InputSystem.Users;

public class Global : MonoBehaviour
{
  public GameObject Tetrisprefab;
  private bool executingGameplay = false;
  [SerializeField] GameObject GameOverScreen;
  [SerializeField] GameObject JoinScreen;
  [SerializeField] GameObject ReadyScreen;
  [SerializeField] Camera camera;
  Controls Controls;

  [SerializeField] int MaxPlayers = 3;
  private List<Tetris> players;
  private List<Tetris> newplayers;

  void Awake()
  {
    ReadyScreen.SetActive( false );
    GameOverScreen.SetActive( false );
    JoinScreen.SetActive( true );
    players = new List<Tetris>();
    newplayers = new List<Tetris>();
    // my IInputActionCollection
    Controls = new Controls();
    // you must enable
    Controls.Enable();
    // bind controls that any/every device can use
    Controls.Global.StartGame.performed += context => StartGame();
    // assign the callback for listening
    InputUser.onUnpairedDeviceUsed += OnUnpairedDeviceUsed;
    // listening will not start until InputUser.listenForUnpairedDeviceActivity > 0
    BeginJoining();
  }

  private void OnDestroy()
  {
    // Avoid lingering calls after play mode has ended!!!
    InputUser.onUnpairedDeviceUsed -= OnUnpairedDeviceUsed;
  }

  void OnUnpairedDeviceUsed( InputControl control, InputEventPtr eventPtr )
  {
    // Ignore anything but button presses.
    if( !( control is ButtonControl ) )
      return;
    Debug.Log( "Unpaired device detected" + control.device.displayName );

    // get a new InputUser, now paired with the device
    InputUser user = InputUser.PerformPairingWithDevice( control.device );
    // Create a new instance of input actions to prevent InputUser from triggering actions on another InputUser.
    Controls controlsForThisUser = new Controls();
    // you must enable the controls to use them
    controlsForThisUser.Enable();
    // the real work is done for us in InputUser
    user.AssociateActionsWithUser( controlsForThisUser );

    GameObject go = Instantiate( Tetrisprefab );
    Tetris tetris = go.GetComponent<Tetris>();
    // store the InputUser so you can unpair later
    tetris.user = user;
    // initialize your script with the new controls
    tetris.BindControls( controlsForThisUser.Gameplay );

    // You cannot do things like set the parent transform in this callback, so
    // add the game object to a list of new players for processing in Update()
    newplayers.Add( tetris );

    InputUser.listenForUnpairedDeviceActivity--;
    if( InputUser.listenForUnpairedDeviceActivity == 0 )
    {
      EndJoining();
      ReadyScreen.SetActive( true );
    }
  }

  void BeginJoining()
  {
    InputUser.listenForUnpairedDeviceActivity = MaxPlayers;
    JoinScreen.SetActive( true );
  }

  void EndJoining()
  {
    InputUser.listenForUnpairedDeviceActivity = 0;
    JoinScreen.SetActive( false );
  }

  void GameOver( Tetris loser )
  {
    executingGameplay = false;
    GameOverScreen.SetActive( true );
    Controls.Disable();
    // Timer class not shown here, see the full source
    new Timer( this, 3, null, () =>
    {
      Controls.Enable();
      GameOverScreen.SetActive( false );
      foreach( var player in players )
        Destroy( player.gameObject );
      players.Clear();
      BeginJoining();
    } );
  }

  void StartGame()
  {
    if( executingGameplay )
      return;
    EndJoining();
    executingGameplay = true;
    GameOverScreen.SetActive( false );
    ReadyScreen.SetActive( false );
    foreach( var game in players )
      game.Reset();
  }

  void Update()
  {
    // add new players
    foreach( var player in newplayers )
    {
      // this is the reason for the newplayers list. This cannot be called in
      // the onpairedDeviceUsed callback above
      player.transform.parent = transform;
      players.Add( player );
    }
    newplayers.Clear();

    if( executingGameplay )
      for( int i = 0; i < players.Count; i++ )
        players[i].ManualUpdate();
  }
}

using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Users;

// NOT using the callback interface because I couldn't figure out to bind it properly
public class Tetris : MonoBehaviour //, Controls.IGameplayActions
{
  public InputUser user;
  public Controls.GameplayActions gameplayActions;
  // Controls the board with player input or AI using this struct
  public struct InputStruct
  {
    public bool right;
    public bool left;
    public bool down;
    public bool rotCW;
    public bool rotCCW;
  }
  InputStruct inputState;

  private void OnDestroy()
  {
    user.UnpairDevices();
  }

  public void BindControls( Controls.GameplayActions iam )
  {
    gameplayActions = iam;
    // Bind discrete events using C# delegates
    iam.RotateCW.started += ( obj ) => { inputState.rotCW = true; };
    iam.RotateCCW.started += ( obj ) => { inputState.rotCCW = true; };
  }

  public void ManualUpdate()
  {
    // Use polling for continuous player actions if appropriate
    inputState.down = gameplayActions.Down.phase == InputActionPhase.Started;
    inputState.left = gameplayActions.Left.phase == InputActionPhase.Started;
    inputState.right = gameplayActions.Right.phase == InputActionPhase.Started;
    // HandleInput( inputState )
  }

  // NOT using the SendMessage() technique
  //public void OnRight( Context ){}
}
12 Likes
8

Thanks Koru! This helped so much!