jonka Mike Ton 9 vuotta sitten
1324
Lisää tämän kaltaisia
//A third method would be to get input directly from a controller's buttons and axes. This is generally not a good choice as you will lose all the advantages of the player-centric system including mapping.
public class MyClass : MonoBehaviour {
public int playerId;
private Player player;
void Awake() {
player = ReInput.players.GetPlayer(playerId);
// Add delegates to receive input events from the Player
// This event will be called every frame any input is updated
player.AddInputEventDelegate(OnInputUpdate, UpdateLoopType.FixedUpdate);
// This event will be called every frame the "Fire" action is updated
player.AddInputEventDelegate(OnFireUpdate, UpdateLoopType.FixedUpdate);
// This event will be called when the "Fire" button is first pressed
player.AddInputEventDelegate(OnFireButtonDown, UpdateLoopType.FixedUpdate, InputActionEventType.ButtonJustPressed);
// This event will be called when the "Fire" button is first released
player.AddInputEventDelegate(OnFireButtonUp, UpdateLoopType.FixedUpdate, InputActionEventType.ButtonJustReleased);
// The update loop you choose for the event matters. Make sure your chosen update loop is enabled in
// the Settings page of the Rewired editor or you won't receive any events.
}
void OnInputUpdate(InputActionEventData data) {
switch(data.actionName) { // determine which action this is
case "Move Horizontal":
if(data.GetAxis() != 0.0f) Debug.Log("Move Horizontal!");
break;
case "Fire":
if(data.GetButtonDown()) Debug.Log("Fire!");
break;
}
}
void OnFireUpdate(InputActionEventData data) {
if(data.GetButtonDown()) Debug.Log("Fire!");
}
void OnFireButtonDown(InputActionEventData data) {
Debug.Log("Fire!");
}
void OnFireButtonUp(InputActionEventData data) {
Debug.Log("Fire Released!");
}
}
using UnityEngine;
using Rewired;
public class MyClass : MonoBehaviour {
public int playerId;
private Player player;
void Awake() {
player = ReInput.players.GetPlayer(playerId);
}
void Update() {
if(player.GetAxis("Move Horizontal") != 0.0f) {
Debug.Log("Move Horizontal!");
}
if(player.GetButtonDown("Fire")) {
Debug.Log("Fire!");
}
}
}
private Rewired.Player player;
void Awake() {
player = Rewired.ReInput.players.GetPlayer(0); // get the player by id
}
void Update() {
player.GetButtonDown("Fire");
}
(sys)
Menu
Cancel
Load
Save
(char)
(attack)
Melee
Kick
Punch
Fire
Change Weapon
Reload
(vstate)
Crouch
Jump
(move)
Vertical
Horizontal
Actions are generally how you get input in Rewired. Instead of getting input from a specific button on a specific controller which may change if the user switches controllers, you get input from the Action through the Player class
//The Action Id is displayed in the Rewired Editor under Actions.
//You can also get input based on the Action Id instead of by name if you choose
using UnityEngine;
using Rewired;
public class MyClass : MonoBehaviour {
public int playerId;
private Player player;
void Awake() {
player = ReInput.players.GetPlayer(playerId);
}
}
Players
Joystick Auto-Assignment
Reassign To Previous Owner
When a joystick is disconnected and reconnected, attempt to reassign the joystick to the last player it was assigned to.
Distribute Joysticks Evenly
When auto-assigning joysticks, assign to players with the fewest number of joysticks first. Will assign up to the limit of Max Joysticks Per Player.
Assign To Playing Players Only
Only assign joysticks to players that have isPlaying = true. Non-playing players will not be assigned joysticks.
Max Joysticks Per Player
How many joysticks is a player allowed to be assigned? If enabled, connected joysticks will be assigned to each player up to this limit.
Auto-Assign Joysticks
Automatically assign joysticks to players as they are connected.
Input Sources
Always use Unity Input
Force Unity Input to be the input source. This will disable all external input sources such as Raw Input, Direct Input, XInput, and native OSX.
WARNING: Unity Input does not allow hot-plugging on most platforms. If you need hot-plugging, do not check this box.
Native Mouse Handling
Use native libraries to handle the mouse if available on the current platform. Enabling this will eliminate certain bugs associated with Unity's mouse handling.
NOTE: This setting currently only affects the Windows Standalone platform.
Use XInput
On Windows, use XInput for compatible devices. Otherwise fall back to Raw Input or Direct Input. Installation of DirectX end-user runtimes may be required for XInput support.
Windows Standalone
Direct Input
Use Direct Input for the input source. Installation of DirectX end-user runtimes may be required for Direct Input support.
Raw Input
Use Raw Input for the input source.
Update Loop
OnGUI
Updates input only in the OnGUI loop. Only necessary if you need GetButtonDown to work within the Unity GUI.
FixedUpdate
Updates input only in the FixedUpdate loop
If you try to get input from the Update loop, you will miss some input data
??? DOES THIS MEAN NOT TO USE IN COMBINATION WITH UPDATE LOOP?
Update
Updates input only in the Update loop
Ex: GetButtonDown and GetKeyDown will not always return correctly.
If you try to get input from the FixedUpdate loop, you will miss some input data
??? DOES THIS MEAN NOT TO USE IN COMBINATION WITH FixedUpdate LOOP?
//The Settings page allows you change the options for the current Input Manager.
Identifying joysticks on fallback platforms
Any time a joystick is connected or disconnected, repeat the whole identification process for every joystick.
Repeat the above steps for each joystick in the system.
When the user presses the button, set the joystick id on the joystick so Rewired can identify which joystick it is.
At game start, pop up a GUI asking the user to press a button on each named controller.
Adding a controller to an existing controller template
Creating new controller templates
Creating new controller definitions
Creating on-screen touch controllers
Modifying Input Behaviors during runtime
calibration
private void SaveAllMaps() {
// ... Removed controller map saving code
// Save joystick calibration maps
foreach(Joystick joystick in ReInput.controllers.Joysticks) {
JoystickCalibrationMapSaveData saveData = joystick.GetCalibrationMapSaveData();
string key = GetJoystickCalibrationMapPlayerPrefsKey(saveData);
PlayerPrefs.SetString(key, saveData.map.ToXmlString()); // save the map to player prefs in XML format
}
// Save changes to PlayerPrefs
PlayerPrefs.Save();
}
private void LoadAllMaps() {
// ... Removed controller map loading code
// Load joystick calibration maps
foreach(Joystick joystick in ReInput.controllers.Joysticks) {
joystick.ImportCalibrationMapFromXmlString(GetJoystickCalibrationMapXml(joystick)); // load joystick calibration map if any
}
}
controller
private void SaveAllMaps() {
// This example uses PlayerPrefs because its convenient, though not efficient, but you could use any data storage method you like.
IList<Player> allPlayers = ReInput.players.AllPlayers;
for(int i = 0; i < allPlayers.Count; i++) {
Player player = allPlayers[i];
// Get all savable data from player
PlayerSaveData playerData = player.GetSaveData(true);
// Save Input Behaviors
foreach(InputBehavior behavior in playerData.inputBehaviors) {
string key = GetInputBehaviorPlayerPrefsKey(player, behavior);
PlayerPrefs.SetString(key, behavior.ToXmlString()); // save the behavior to player prefs in XML format
}
// Save controller maps
foreach(ControllerMapSaveData saveData in playerData.AllControllerMapSaveData) {
string key = GetControllerMapPlayerPrefsKey(player, saveData);
PlayerPrefs.SetString(key, saveData.map.ToXmlString()); // save the map to player prefs in XML format
}
}
// Save joystick calibration maps
foreach(Joystick joystick in ReInput.controllers.Joysticks) {
JoystickCalibrationMapSaveData saveData = joystick.GetCalibrationMapSaveData();
string key = GetJoystickCalibrationMapPlayerPrefsKey(saveData);
PlayerPrefs.SetString(key, saveData.map.ToXmlString()); // save the map to player prefs in XML format
}
// Save changes to PlayerPrefs
PlayerPrefs.Save();
}
private void LoadAllMaps() {
// This example uses PlayerPrefs because its convenient, though not efficient, but you could use any data storage method you like.
IList<Player> allPlayers = ReInput.players.AllPlayers;
for(int i = 0; i < allPlayers.Count; i++) {
Player player = allPlayers[i];
// Load Input Behaviors - all players have an instance of each input behavior so it can be modified
IList<InputBehavior> behaviors = ReInput.mapping.GetInputBehaviors(player.id); // get all behaviors from player
for(int j = 0; j < behaviors.Count; j++) {
string xml = GetInputBehaviorXml(player, behaviors[j].id); // try to the behavior for this id
if(xml == null || xml == string.Empty) continue; // no data found for this behavior
behaviors[j].ImportXmlString(xml); // import the data into the behavior
}
// Load the maps first and make sure we have them to load before clearing
// Load Keyboard Maps
List<string> keyboardMaps = GetAllControllerMapsXml(player, true, ControllerType.Keyboard, ReInput.controllers.Keyboard);
// Load Mouse Maps
List<string> mouseMaps = GetAllControllerMapsXml(player, true, ControllerType.Mouse, ReInput.controllers.Mouse); // load mouse controller maps
// Load Joystick Maps
bool foundJoystickMaps = false;
List<List<string>> joystickMaps = new List<List<string>>();
foreach(Joystick joystick in player.controllers.Joysticks) {
List<string> maps = GetAllControllerMapsXml(player, true, ControllerType.Joystick, joystick);
joystickMaps.Add(maps);
if(maps.Count > 0) foundJoystickMaps = true;
}
// Now add the maps to the controller
// Keyboard maps
if(keyboardMaps.Count > 0) player.controllers.maps.ClearMaps(ControllerType.Keyboard, true); // clear only user-assignable maps, but only if we found something to load. Don't _really_ have to clear the maps as adding ones in the same cat/layout will just replace, but let's clear anyway.
player.controllers.maps.AddMapsFromXml(ControllerType.Keyboard, 0, keyboardMaps); // add the maps to the player
// Joystick maps
if(foundJoystickMaps) player.controllers.maps.ClearMaps(ControllerType.Joystick, true); // clear only user-assignable maps, but only if we found something to load. Don't _really_ have to clear the maps as adding ones in the same cat/layout will just replace, but let's clear anyway.
int count = 0;
foreach(Joystick joystick in player.controllers.Joysticks) {
player.controllers.maps.AddMapsFromXml(ControllerType.Joystick, joystick.id, joystickMaps[count]); // add joystick controller maps to player
count++;
}
// Mouse Maps
if(mouseMaps.Count > 0) player.controllers.maps.ClearMaps(ControllerType.Mouse, true); // clear only user-assignable maps, but only if we found something to load. Don't _really_ have to clear the maps as adding ones in the same cat/layout will just replace, but let's clear anyway.
player.controllers.maps.AddMapsFromXml(ControllerType.Mouse, 0, mouseMaps); // add the maps to the player
}
// Load joystick calibration maps
foreach(Joystick joystick in ReInput.controllers.Joysticks) {
joystick.ImportCalibrationMapFromXmlString(GetJoystickCalibrationMapXml(joystick)); // load joystick calibration map if any
}
}
Creating a controller mapping screen
Calibrating controller axes
using Rewired;
public class MyClass {
void SetEnabledStateOnMapsInCategory(Player player, string categoryName, bool state) {
// The quick way
player.controllers.maps.SetMapsEnabled(state, categoryName);
// The manual way
foreach(ControllerMap map in player.controllers.maps.GetAllMapsInCategory(categoryName)) {
map.enabled = state; // set the enabled state on the map
}
}
}
//You can also enable and disable maps one by one by accessing the maps through Playe
player.controllers.maps.GetAllMapsInCategory
player.controllers.maps.GetAllMaps
player.controllers.maps.GetMaps
player.controllers.maps.GetMap
// Disabled maps will not contribute to input.
Once you have the map, enable or disable it by setting controllerMap.enabled = true or controllerMap.enabled = false
player.controllers.maps.SetMapsEnabled
//Set enabled state on a group of maps owned by the Player by controller type, category, and layout
player.controllers.maps.SetAllMapsEnabled
//Set enabled state on all maps owned by the Player or all maps for a specific controller type
//Controller Maps can be enabled or disabled at will via scripting. This can be useful if you want to change game modes and have a different set of controls become active. For example, opening a menu screen. Controller Maps are stored in the Player class.
Joysticks will be assigned to Players automatically if you have enabled and configured joystick auto-assignment in the Rewired Editor under Settings. However, if you wish to manually assign or unassign joysticks, you can do so with the following methods:
ReInput class
ReInput.controllers.RemoveControllerFromAllPlayers
ReInput.controllers.IsControllerAssignedToPlayer
ReInput.controllers.IsControllerAssigned
Player class
player.controllers.ClearAllControllers
player.controllers.ClearControllersOfType
player.controllers.ContainsController
player.controllers.RemoveController
player.controllers.AddController
using UnityEngine;
using Rewired;
public MyClass : MonoBehaviour {
void Awake() {
ReInput.ControllerConnectedEvent += OnControllerConnected;
ReInput.ControllerDisconnectedEvent += OnControllerDisconnected;
ReInput.ControllerPreDisconnectEvent += OnControllerPreDisconnect;
}
void OnControllerConnected(ControllerStatusChangedEventArgs args) {
// This function will be called when a controller is connected
// You can get information about the controller that was connected via the args parameter
Debug.Log("A controller was connected! Name = " + args.name + " Id = " + args.controllerId + " Type = " + controllerType);
}
void OnControllerDisconnected(ControllerStatusChangedEventArgs args) {
// This function will be called when a controller is fully disconnected
// You can get information about the controller that was disconnected via the args parameter
Debug.Log("A controller was disconnected! Name = " + args.name + " Id = " + args.controllerId + " Type = " + controllerType);
}
void OnControllerPreDisconnect(ControllerStatusChangedEventArgs args) {
// This function will be called when a controller is about to be disconnected
// You can get information about the controller that is being disconnected via the args parameter
// You can use this event to save the controller's maps before it's disconnected
Debug.Log("A controller is being disconnected! Name = " + args.name + " Id = " + args.controllerId + " Type = " + controllerType);
}
}
ReInput.ControllerDisconnectedEvent
Receive an event when a controller is fully disconnected, register for
ReInput.ControllerPreDisconnectEvent
Receive an event when a controller is about to be disconnected, register for
ReInput.ControllerConnectedEvent
Receive an event when a controller is connected, register for
(Loop through controllers assigned to a Player)
player.controllers.CustomControllers
player.controllers.Joysticks
(Loop through all controllers)
ReInput.controllers.CustomControllers
ReInput.controllers.Joysticks
ReInput.controllers.Controllers
(To get the keyboard from)
player.controllers.Keyboard
ReInput.controllers.Keyboard
(To get the mouse from)
player.controllers.Mouse
ReInput.controllers.Mouse
(To get a specific controller)
player.controllers.GetControllerWithTag
player.controllers.GetController
ReInput.controllers.GetController
