public void Users_CannotPairSameDeviceToUserMoreThanOnce() { var gamepad = InputSystem.AddDevice <Gamepad>(); var user = InputUser.PerformPairingWithDevice(gamepad); var receivedChanges = new List <UserChange>(); InputUser.onChange += (usr, change, device) => { receivedChanges.Add(new UserChange(usr, change, device)); }; InputUser.PerformPairingWithDevice(gamepad, user: user); Assert.That(receivedChanges, Is.Empty); }
public void Users_CanAssociatedActionsWithUser() { var gamepad = InputSystem.AddDevice <Gamepad>(); InputUser.PerformPairingWithDevice(gamepad); Assert.That(InputUser.all[0].actions, Is.Null); var asset = ScriptableObject.CreateInstance <InputActionAsset>(); InputUser.all[0].AssociateActionsWithUser(asset); Assert.That(InputUser.all[0].actions, Is.SameAs(asset)); }
public void Users_CanFindUserPairedToSpecificDevice() { var gamepad1 = InputSystem.AddDevice <Gamepad>(); var gamepad2 = InputSystem.AddDevice <Gamepad>(); var gamepad3 = InputSystem.AddDevice <Gamepad>(); var user1 = InputUser.PerformPairingWithDevice(gamepad1); var user2 = InputUser.PerformPairingWithDevice(gamepad2); var user3 = InputUser.PerformPairingWithDevice(gamepad2); // Same gamepad on two users. Assert.That(InputUser.FindUserPairedToDevice(gamepad1), Is.EqualTo(user1)); Assert.That(InputUser.FindUserPairedToDevice(gamepad2), Is.EqualTo(user2).Or.EqualTo(user3)); // Either is acceptable. Assert.That(InputUser.FindUserPairedToDevice(gamepad3), Is.Null); }
void AssignControllerToPlayer() { Color[] colors = GameObject.Find("PlayersManager").GetComponent <DebugIcons>().colors; foreach (Player player in playersInfos) { GameObject currentPlayerGO = playersGO.transform.GetChild(player.Id).gameObject; currentPlayerGO.GetComponent <QTE>().id = player.Id; currentPlayerGO.transform.Find("CP").GetComponent <SpriteRenderer>().color = colors[player.Skin]; PlayerInput playerInput = currentPlayerGO.AddComponent <PlayerInput>(); playerInput.actions = Instantiate(dragonsActions); playerInput.actions.Enable(); playerInput.user.UnpairDevices(); InputUser.PerformPairingWithDevice(playersInfos[player.Id].device, playerInput.user); } }
public void TryAssignKeyboard() { GameObject[] players = GameObject.FindGameObjectsWithTag("Player"); PlayerInput[] playerInputs = new PlayerInput[players.Length]; for (int i = 0; i < players.Length; i++) { playerInputs[i] = players[i].GetComponent <PlayerInput>(); if (playerInputs[i] != null && !playerInputs[i].Equals(null) && playerInputs[i].currentControlScheme == secondKeyboardControlScheme) { InputUser.PerformPairingWithDevice(Keyboard.current, playerInputs[i].user); break; } } }
public static RemoteInput Create() { InputUser user = InputUser.CreateUserWithoutPairedDevices(); user = InputUser.PerformPairingWithDevice(InputSystem.AddDevice <Mouse>(), user); user = InputUser.PerformPairingWithDevice(InputSystem.AddDevice <Keyboard>(), user); user = InputUser.PerformPairingWithDevice(InputSystem.AddDevice <Gamepad>(), user); user = InputUser.PerformPairingWithDevice(InputSystem.AddDevice <Touchscreen>(), user); RemoteInput remoteInput = new RemoteInput(ref user); s_mapRemoteInputAndInputUserId.Add(remoteInput, user.id); s_listRemoteInput.Add(remoteInput); return(remoteInput); }
// Start is called before the first frame update void Awake() { playerInput = GetComponent <PlayerInput>(); inputUser = playerInput.user; inputUser.UnpairDevices(); Debug.Log(inputUser.controlScheme.ToString()); foreach (var js in Joystick.all) { InputUser.PerformPairingWithDevice(js, inputUser); } foreach (var gp in Gamepad.all) { InputUser.PerformPairingWithDevice(gp, inputUser); ProGamepad = gp; } }
private void setplayers() { for (int i = 0; i < Players.Count; i++) { try { portrats[i].sprite = possablePortrats[Settings.Instance.playerData[i].SelectedChar]; Debug.Log("setting player " + i + " with device " + Settings.Instance.Devices[i]); Players[i].user.UnpairDevices(); InputUser.PerformPairingWithDevice(Settings.Instance.Devices[i],Players[i].user); } catch { Debug.Log("own no youw nowt supposed tuwu see thiws scween"); } } }
InputUser SetupNewUser() { unpairedDevices = InputUser.GetUnpairedInputDevices(); if (unpairedDevices.Count == 0) { return(new InputUser()); } InputUser newUser = new InputUser(); newUser = InputUser.PerformPairingWithDevice(unpairedDevices[0], newUser); Debug.Log($"Paired device to new user: {newUser.pairedDevices[0].displayName}"); unpairedDevices = InputUser.GetUnpairedInputDevices(); return(newUser); }
private void AddPlayer(InputDevice device) { if (_currPlayerIndex.Equals(-1)) { return; } // Don't execute if not a gamepad or keyboard if (!device.displayName.Contains("Controller") && !device.displayName.Contains("Gamepad") && !device.displayName.Contains("Keyboard")) { return; } if (PlayerInput.all.SelectMany(player => player.devices) .Any(playerDevice => device == playerDevice && !device.displayName.Contains("Keyboard"))) { return; } var playerInput = _playerInstances[_currPlayerIndex].GetComponent <PlayerInput>(); if (device.displayName.Contains("Keyboard")) { keyboardScheme[_currPlayerIndex].SetActive(true); var scheme = _currPlayerIndex == 0 ? "KeyboardLeft" : "KeyboardRight"; playerInput.SwitchCurrentControlScheme(scheme); InputUser.PerformPairingWithDevice(Keyboard.current, playerInput.user, InputUserPairingOptions.UnpairCurrentDevicesFromUser); DeviceMap.PlayerDevices[_currPlayerIndex] = (device, scheme); } else { keyboardScheme[_currPlayerIndex].SetActive(false); playerInput.SwitchCurrentControlScheme("Gamepad"); InputUser.PerformPairingWithDevice(device, playerInput.user, InputUserPairingOptions.UnpairCurrentDevicesFromUser); DeviceMap.PlayerDevices[_currPlayerIndex] = (device, "Gamepad"); } devicesText[_currPlayerIndex].text = device.displayName; bindButton[_currPlayerIndex].interactable = true; OnControllerChange?.Invoke(); CheckValidScheme(); _currPlayerIndex = -1; }
public void Users_CanActivateControlScheme_AndAutomaticallyPairRemainingDevices() { var gamepad1 = InputSystem.AddDevice <Gamepad>(); var gamepad2 = InputSystem.AddDevice <Gamepad>(); InputSystem.AddDevice <Mouse>(); // Noise. var gamepadScheme = new InputControlScheme("Gamepad") .WithRequiredDevice("<Gamepad>") .WithRequiredDevice("<Gamepad>") .WithOptionalDevice("<Gamepad>"); var user1 = InputUser.PerformPairingWithDevice(gamepad1); InputUser.PerformPairingWithDevice(gamepad2); // Should not get picked as already used. var actions = new InputActionMap(); user1.AssociateActionsWithUser(actions); // First try it without having the devices we need. user1.ActivateControlScheme(gamepadScheme) .AndPairRemainingDevices(); Assert.That(user1.pairedDevices, Is.EquivalentTo(new[] { gamepad1 })); Assert.That(actions.devices, Is.EquivalentTo(new[] { gamepad1 })); Assert.That(user1.hasMissingDevices, Is.True); Assert.That(user1.controlSchemeMatch.isSuccessfulMatch, Is.False); Assert.That(user1.controlSchemeMatch[0].control, Is.SameAs(gamepad1)); Assert.That(user1.controlSchemeMatch[1].control, Is.Null); Assert.That(user1.controlSchemeMatch[2].control, Is.Null); // Now add another gamepad and try again. var gamepad3 = InputSystem.AddDevice <Gamepad>(); user1.ActivateControlScheme(gamepadScheme) .AndPairRemainingDevices(); Assert.That(user1.pairedDevices, Is.EquivalentTo(new[] { gamepad1, gamepad3 })); Assert.That(actions.devices, Is.EquivalentTo(new[] { gamepad1, gamepad3 })); Assert.That(user1.hasMissingDevices, Is.False); Assert.That(user1.controlSchemeMatch.isSuccessfulMatch, Is.True); Assert.That(user1.controlSchemeMatch[0].control, Is.SameAs(gamepad1)); Assert.That(user1.controlSchemeMatch[1].control, Is.SameAs(gamepad3)); Assert.That(user1.controlSchemeMatch[2].control, Is.Null); // Still don't have the optional one. }
public void Users_CanPairDevice_WhenDeviceHasPairedUserAccountAtPlatformLevel() { // Report a gamepad paired to a user at the platform level. runtime.ReportNewInputDevice <Gamepad>(userHandle: 1, userName: "******", userId: "TestId"); InputSystem.Update(); var gamepad = InputSystem.GetDevice <Gamepad>(); var user = InputUser.PerformPairingWithDevice(gamepad); Assert.That(user.valid, Is.True); Assert.That(user.platformUserAccountHandle, Is.EqualTo(new InputUserAccountHandle("Test", 1))); Assert.That(user.platformUserAccountName, Is.EqualTo("TestUser")); Assert.That(user.platformUserAccountId, Is.EqualTo("TestId")); var receivedChanges = new List <UserChange>(); InputUser.onChange += (usr, change, device) => { receivedChanges.Add(new UserChange(usr, change, device)); }; // Change the user account on the device. runtime.AssociateInputDeviceWithUser(gamepad, userHandle: 2, userName: "******", userId: "OtherId"); InputSystem.QueueConfigChangeEvent(gamepad); InputSystem.Update(); Assert.That(user.platformUserAccountHandle, Is.EqualTo(new InputUserAccountHandle("Test", 2))); Assert.That(user.platformUserAccountName, Is.EqualTo("OtherUser")); Assert.That(user.platformUserAccountId, Is.EqualTo("OtherId")); Assert.That(receivedChanges, Is.EquivalentTo(new[] { new UserChange(user, InputUserChange.AccountChanged, gamepad) })); receivedChanges.Clear(); // Send config change event but do *NOT* change user account. Make sure // the system won't claim the account has changed. InputSystem.QueueConfigChangeEvent(gamepad); InputSystem.Update(); Assert.That(user.platformUserAccountHandle, Is.EqualTo(new InputUserAccountHandle("Test", 2))); Assert.That(user.platformUserAccountName, Is.EqualTo("OtherUser")); Assert.That(user.platformUserAccountId, Is.EqualTo("OtherId")); Assert.That(receivedChanges, Is.Empty); }
void SetupInGameDevices() { if (inputDevice is Gamepad) { gamepad = inputDevice as Gamepad; inputType = InputType.GP; } else { keyboard = inputDevice as Keyboard; mouse = InputSystem.GetDevice <Mouse>(); inputType = InputType.KB; inputUser = InputUser.PerformPairingWithDevice(mouse, inputUser); } inputUser = InputUser.PerformPairingWithDevice(inputDevice, inputUser); inputUser.AssociateActionsWithUser(controls); }
private void Start() { // Link controller input to specific single device if (playerControllerID != -1) { PlayerInput playerInput = GetComponent <PlayerInput>(); foreach (InputDevice input in InputDevice.all) { if (input.deviceId == playerControllerID) { InputUser.PerformPairingWithDevice(input, playerInput.user, InputUserPairingOptions.UnpairCurrentDevicesFromUser); break; } } } }
public void Awake() { playerCommands = new List <Command>(); playerControls = new PlayerControls(); //Must Generate a C# Class from controls playerInput = GetComponent <PlayerInput>(); string deviceName = playerInput.devices[0].name; if (deviceName.Contains("Mouse") || deviceName.Contains("Keyboard")) { if (deviceName.Contains("Mouse")) { InputUser.PerformPairingWithDevice(Keyboard.current, playerInput.user); } if (deviceName.Contains("Keyboard")) { InputUser.PerformPairingWithDevice(Mouse.current, playerInput.user); } // playerInput.user.AssociateActionsWithUser((InputActionMap)playerControls.asset.actionMaps[0]); // var scheme = InputControlScheme.FindControlSchemeForDevice(playerInput.user.pairedDevices[1], playerInput.user.actions.controlSchemes); //// print(scheme.ToString()); // playerInput.user.ActivateControlScheme(scheme.ToString()); } //Add all device names to "list" deviceNames = new string[playerInput.user.pairedDevices.Count]; for (int i = 0; i < deviceNames.Length; i++) { deviceNames[i] = playerInput.user.pairedDevices[i].name; } actionMap = (InputActionMap)playerControls.asset.actionMaps[0]; commandNames = new Dictionary <string, Command>(); for (int i = 0; i < actionMap.actions.Count; i++) { Command newCommand = new Command(); newCommand.AddInput(actionMap.actions[i], deviceNames); commandNames.Add(actionMap.actions[i].name, newCommand); playerCommands.Add(newCommand); // print(actionMap.actions[i].name); } }
public void Users_HaveIndices() { var gamepad1 = InputSystem.AddDevice <Gamepad>(); var gamepad2 = InputSystem.AddDevice <Gamepad>(); var user1 = InputUser.PerformPairingWithDevice(gamepad1); var user2 = InputUser.PerformPairingWithDevice(gamepad2); Assert.That(user1.index, Is.EqualTo(0)); Assert.That(user2.index, Is.EqualTo(1)); Assert.That(InputUser.all, Is.EquivalentTo(new[] { user1, user2 })); // Remove first user. user1.UnpairDevicesAndRemoveUser(); Assert.That(InputUser.all, Is.EquivalentTo(new[] { user2 })); Assert.That(user2.index, Is.EqualTo(0)); }
public void PairToDevice(InputDevice device) { if (!hasAuthority) { return; } print("PairToDevice called" + device); this.device = device; playerInput.user.UnpairDevices(); print("Input user: "******"Paired devices: " + playerInput.user.pairedDevices.Count); print("Lost Devices: " + playerInput.user.lostDevices.Count); print("Switch Control Scheme: " + playerInput.SwitchCurrentControlScheme(new InputDevice[] { device })); }
void AssignControllerToPlayer() { Color[] colors = GameObject.Find("PlayersManager").GetComponent <DebugIcons>().colors; foreach (Player player in playersInfos) { GameObject currentPlayerGO = players.Single(x => x.playerNumber == player.Id).gameObject; ApplySkin(currentPlayerGO, skinToUse[player.Id]); PlayerInput playerInput = currentPlayerGO.AddComponent <PlayerInput>(); playerInput.actions = Instantiate(actions); playerInput.actions.Enable(); playerInput.SwitchCurrentActionMap("Dead"); playerInput.currentActionMap.Disable(); playerInput.SwitchCurrentActionMap("Alive"); playerInput.user.UnpairDevices(); playerInput.GetComponent <KTB_Player>().playerInput = playerInput; InputUser.PerformPairingWithDevice(playersInfos[player.Id].device, playerInput.user); } }
void Assign() { var gamepads = Gamepad.all; int limit = Math.Min(players.Length, gamepads.Count); int start = gamepadassigned; for (int i = 0; i < limit; i++) { InputUser.PerformPairingWithDevice(gamepads[i], InputUser.all[players[i].playerIndex], InputUserPairingOptions.UnpairCurrentDevicesFromUser); InputUser.PerformPairingWithDevice(Keyboard.current, InputUser.all[players[i].playerIndex]); players[i].SwitchCurrentControlScheme("Gamepad", gamepads[i], Keyboard.current); players[i].defaultActionMap = "Player" + (i + 1); UnityEngine.Debug.Log("Assign " + gamepads[i].name + " to " + players[i].name + " with " + "Player" + (i + 1)); gamepadassigned++; } }
public void Users_CanActivateAndDeactivateControlScheme() { var gamepad = InputSystem.AddDevice <Gamepad>(); var user = InputUser.PerformPairingWithDevice(gamepad); var actions = new InputActionMap(); user.AssociateActionsWithUser(actions); var gamepadScheme = new InputControlScheme("Gamepad") .WithRequiredDevice("<Gamepad>"); var receivedChanges = new List <UserChange>(); InputUser.onChange += (usr, change, device) => { receivedChanges.Add(new UserChange(usr, change, device)); }; Assert.That(user.controlScheme, Is.Null); user.ActivateControlScheme(gamepadScheme); Assert.That(user.controlScheme, Is.EqualTo(gamepadScheme)); Assert.That(actions.bindingMask, Is.EqualTo(new InputBinding { groups = "Gamepad" })); Assert.That(actions.devices, Is.EquivalentTo(new[] { gamepad })); Assert.That(receivedChanges, Is.EquivalentTo(new[] { new UserChange(user, InputUserChange.ControlSchemeChanged) })); receivedChanges.Clear(); user.ActivateControlScheme(null); Assert.That(user.controlScheme, Is.Null); Assert.That(user.pairedDevices, Is.EquivalentTo(new[] { gamepad })); Assert.That(actions.bindingMask, Is.Null); Assert.That(actions.devices, Is.EquivalentTo(new[] { gamepad })); // Devices should be unaffected by control scheme; should be affected by paired devices only. Assert.That(receivedChanges, Is.EquivalentTo(new[] { new UserChange(user, InputUserChange.ControlSchemeChanged) })); }
void OnUnpairedDeviceUsed(InputControl c, InputEventPtr e) { if (!(c.device.GetType() == Keyboard.current.GetType() || c.device.GetType() == Gamepad.current.GetType())) { return; } if (!player1.InputUser.valid) { player1.InputUser = InputUser.PerformPairingWithDevice(c.device); player1.InputUser.AssociateActionsWithUser(player1.PlayerControl); Debug.Log("Pairing player1 with " + c.device.name); } else if (!player2.InputUser.valid) { player2.InputUser = InputUser.PerformPairingWithDevice(c.device); player2.InputUser.AssociateActionsWithUser(player2.PlayerControl); Debug.Log("Pairing player2 with " + c.device.name); } }
// Start is called before the first frame update void Start() { playerInput = GetComponent <PlayerInput>(); user = playerInput.user; controller = GetComponent <CharacterController>(); stickVector = new Vector2(); movementVector = new Vector3(); rStickVector = new Vector2(); cameraVector = new Vector3(); //InputUser.PerformPairingWithDevice(InputSystem.devices[2], user); //InputUser.PerformPairingWithDevice(InputSystem.devices[3], user); //jcLeft = user.pairedDevices[1]; //jcRight = user.pairedDevices[0]; InputUser.PerformPairingWithDevice(InputSystem.devices[5], user); }
public void Users_CanQueryUnpairedDevices() { var gamepad = InputSystem.AddDevice <Gamepad>(); var keyboard = InputSystem.AddDevice <Keyboard>(); var mouse = InputSystem.AddDevice <Mouse>(); var touch = InputSystem.AddDevice <Touchscreen>(); var gyro = InputSystem.AddDevice <Gyroscope>(); InputUser.PerformPairingWithDevice(gamepad); InputUser.PerformPairingWithDevice(keyboard); InputUser.PerformPairingWithDevice(mouse, user: InputUser.all[1]); using (var unusedDevices = InputUser.GetUnpairedInputDevices()) { Assert.That(unusedDevices, Has.Count.EqualTo(2)); Assert.That(unusedDevices, Has.Exactly(1).SameAs(touch)); Assert.That(unusedDevices, Has.Exactly(1).SameAs(gyro)); } }
private void OnInputUserOnOnUnpairedDeviceUsed(InputControl control) { if (control.device is Gamepad gamepad) { Debug.LogFormat("new unpaired device activity: {0}", gamepad.name); for (var i = 0; i < _users.Length; i++) { var user = _users[i]; var pairedGamepads = user.pairedDevices.Count(d => d is Gamepad); if (pairedGamepads == 0) { _users[i] = InputUser.PerformPairingWithDevice(gamepad, _users[i], InputUserPairingOptions.None); return; } } } }
void SetupTestingDevices() { if (testingController) { inputDevice = InputSystem.GetDevice <Gamepad>(); gamepad = inputDevice as Gamepad; inputType = InputType.GP; } else if (testingMouseAndKeyboard) { inputDevice = InputSystem.GetDevice <Keyboard>(); keyboard = inputDevice as Keyboard; mouse = InputSystem.GetDevice <Mouse>(); inputType = InputType.KB; inputUser = InputUser.PerformPairingWithDevice(mouse, inputUser); } inputUser = InputUser.PerformPairingWithDevice(inputDevice, inputUser); inputUser.AssociateActionsWithUser(controls); }
public void Users_HaveUniqueIds() { var gamepad1 = InputSystem.AddDevice <Gamepad>(); var gamepad2 = InputSystem.AddDevice <Gamepad>(); var user1 = InputUser.PerformPairingWithDevice(gamepad1); var user2 = InputUser.PerformPairingWithDevice(gamepad2); Assert.That(user1.id, Is.Not.EqualTo(InputUser.kInvalidId)); Assert.That(user2.id, Is.Not.EqualTo(InputUser.kInvalidId)); Assert.That(user1.id, Is.Not.EqualTo(user2.id)); user1.UnpairDevicesAndRemoveUser(); var user3 = InputUser.PerformPairingWithDevice(gamepad1); Assert.That(user3.id, Is.Not.EqualTo(user1.id)); Assert.That(user3.id, Is.Not.EqualTo(user2.id)); }
private void SpawnSelectedPlayers() { foreach (var player in PlayerObjectHandler.playerControllers) { var playerController = PlayerObjectHandler.playerControllers[player.Key]; var playerObjectName = PlayerObjectHandler.playerSelectionNames[player.Key]; var playerControlScheme = PlayerObjectHandler.playerControlSchemes[player.Key]; GameObject parentPlayerObject = new GameObject(); for (int i = 0; i < playerObjectName.Count; i++) { var currentObject = Resources.Load <GameObject>(playerObjectName[i]); // Only activate PlayerInput component on the first object (it defines the "player" if (i == 0) { parentPlayerObject = currentObject; PlayerInput playerInput = PlayerInput.Instantiate(currentObject, player.Key, playerControlScheme, -1, playerController); // Activates the player input component on the prefab we just instantiated // We have the component disabled by default, otherwise it could not be a "selectable object" independent of the PlayerInput component on the cursor // in the selection screen currentObject.GetComponent <PlayerControls>().SetPlayerInputActive(true, playerInput); // *** It seems...that the above Instantiation doesn't exactly work... I'm assuming, because the PlayerInput component on the prefab is starting off // disabled, that it...doesn't work. This code here will force it to keep the device/scheme/etc... that we tried to assign the wretch above! var inputUser = playerInput.user; playerInput.SwitchCurrentControlScheme(playerControlScheme); InputUser.PerformPairingWithDevice(playerController, inputUser, InputUserPairingOptions.UnpairCurrentDevicesFromUser); } // If not the first object (sword/vehicle/etc...) just instantiate, don't associate a PlayerInput else { Instantiate(currentObject, parentPlayerObject.transform); } } } }
public void Users_CanPairDevice_WithGivenUser_AndUnpairCurrentDevices() { var gamepad1 = InputSystem.AddDevice <Gamepad>(); var gamepad2 = InputSystem.AddDevice <Gamepad>(); var user = InputUser.PerformPairingWithDevice(gamepad1); var receivedChanges = new List <UserChange>(); InputUser.onChange += (usr, change, device) => { receivedChanges.Add(new UserChange(usr, change, device)); }; InputUser.PerformPairingWithDevice(gamepad2, user: user, options: InputUserPairingOptions.UnpairCurrentDevicesFromUser); Assert.That(user.pairedDevices, Is.EquivalentTo(new[] { gamepad2 })); Assert.That(receivedChanges, Is.EquivalentTo(new[] { new UserChange(user, InputUserChange.DeviceUnpaired, gamepad1), new UserChange(user, InputUserChange.DevicePaired, gamepad2), })); }
// This will Spawn a player prefab, And then assign an available device to a newly created input user private GameObject SpawnPlayer(int playerIndex, InputDevice deviceToPair) { GameObject newPlayer = Instantiate(playerPrefab, spawnPoint.position, Quaternion.identity, this.transform); PlayerInputHandler newPlayerInputHandler = newPlayer.GetComponent <PlayerInputHandler>(); newPlayerInputHandler.playerIndex = playerIndex; newPlayerInputHandler.deviceBeingUsed = deviceToPair; InputUser newInputUser; // Clear the list of devices for the player that are automatically registered. newPlayerInputHandler.playerControls.devices = new InputDevice[] { }; newInputUser = InputUser.PerformPairingWithDevice(deviceToPair); newInputUser.AssociateActionsWithUser(newPlayerInputHandler.playerControls.asset); newPlayerInputHandler.inputUser = newInputUser; currentPlayerIndex++; return(newPlayer); }
// Start is called before the first frame update void Start() { playerInput = GetComponent <PlayerInput>(); user = playerInput.user; rb = GetComponent <Rigidbody>(); stickVector = new Vector2(); movementVector = new Vector3(); rStickVector = new Vector2(); cameraVector = new Vector3(); heading = 0f; oldHeading = 0f; InputUser.PerformPairingWithDevice(InputSystem.devices[2], user); InputUser.PerformPairingWithDevice(InputSystem.devices[3], user); /// TODO: jcLeft = user.pairedDevices[0]; jcRight = user.pairedDevices[1]; }