private static ControllerMap GetMapKB()
{
ControllerMap c = new ControllerMap();
c.ButtonA = "J";
c.ButtonB = "K";
c.ButtonX = "L";
c.ButtonY = "I";
c.ButtonZ = "R";
c.ButtonStart = "SEMICOLON";
c.MainStickUp = "W";
c.MainStickDown = "S";
c.MainStickLeft = "A";
c.MainStickRight = "D";
c.CStickUp = "UP";
c.CStickDown = "DOWN";
c.CStickLeft = "LEFT";
c.CStickRight = "RIGHT";
c.TriggerL = "Q";
c.TriggerR = "E";
c.DPadUp = "``";
c.DPadDown = "``";
c.DPadLeft = "``";
c.DPadRight = "``";
c.Rumble = "``";
return(c);
}
private void <ApplyUserProfileBindingsToRewiredPlayer> g__ApplyUserProfileBindingstoRewiredController | 20_0 (Controller controller)
{
if (this.userProfile == null)
{
return;
}
ControllerMap controllerMap = null;
switch (controller.type)
{
case ControllerType.Keyboard:
controllerMap = this.userProfile.keyboardMap;
break;
case ControllerType.Mouse:
controllerMap = this.userProfile.mouseMap;
break;
case ControllerType.Joystick:
controllerMap = this.userProfile.joystickMap;
break;
}
if (controllerMap != null)
{
this.inputPlayer.controllers.maps.AddMap(controller, controllerMap);
}
}
internal static void RevertRemap()
{
ControllerMap map = Utils.localInputPlayer.controllers.maps.GetMap(vrControllers, vrGameplayMap.id);
int[] originalSkillBindingIDs = new int[]
{
(ModConfig.LeftDominantHand.Value ? 9 : 8),
(ModConfig.LeftDominantHand.Value ? 8 : 9),
(ModConfig.LeftDominantHand.Value ? 11 : 10),
(ModConfig.LeftDominantHand.Value ? 10 : 11)
};
for (int i = 0; i < 4; i++)
{
ActionElementMap elementMap = vrGameplayMap.GetElementMapsWithAction(7 + i)[0];
if (elementMap.elementIdentifierId == originalSkillBindingIDs[i])
{
continue;
}
if (!map.ReplaceElementMap(elementMap.id, elementMap.actionId, elementMap.axisContribution, originalSkillBindingIDs[i], elementMap.elementType, elementMap.axisRange, elementMap.invert))
{
VRMod.StaticLogger.LogError("An error occured while trying to revert skill binding overrides.");
}
}
}
private static ControllerMap GetMapController(int cid, string layout)
{
ControllerMap c = new ControllerMap();
c.ButtonA = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Button {(layout == "Xbox" ? 'A' : 'B')}`";
c.ButtonB = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Button {(layout == "Xbox" ? 'B' : 'A')}`";
c.ButtonX = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Button {(layout == "Xbox" ? 'X' : 'Y')}`";
c.ButtonY = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Button {(layout == "Xbox" ? 'Y' : 'X')}`";
c.ButtonZ = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Bumper R`";
c.ButtonStart = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Start`";
c.MainStickUp = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Left Y+`";
c.MainStickDown = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Left Y-`";
c.MainStickLeft = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Left X-`";
c.MainStickRight = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Left X+`";
c.CStickUp = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Right Y+`";
c.CStickDown = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Right Y-`";
c.CStickLeft = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Right X-`";
c.CStickRight = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Right X+`";
c.TriggerL = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Trigger L`";
c.TriggerR = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Trigger R`";
c.DPadUp = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Pad N`";
c.DPadDown = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Pad S`";
c.DPadLeft = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Pad W`";
c.DPadRight = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Pad E`";
c.Rumble = $"`WGInput/{cid}/Xbox 360 Controller for Windows:Motor L`|`WGInput/{cid}/Xbox 360 Controller for Windows:Motor R`";
return(c);
}
/// <summary>Gets the controller associated with a given content type.</summary>
/// <param name="contentType">The type of content item whose controller to get.</param>
/// <returns>A controller name if a controller was found.</returns>
public string GetControllerName(Type type)
{
string name;
ControllerMap.TryGetValue(type, out name);
return(name);
}
private void handleInput()
{
_inputAngle = Vector2.Angle(Vector2.up, _stickLocation);
// up
if (_inputAngle < 45.0f)
{
ControllerMap.SearchForUp();
}
// left and right
else if (_inputAngle > 45.0f && _inputAngle < 135.0f)
{
// left
if (_stickLocation.x > 0)
{
ControllerMap.SearchForLeft();
}
// right
else
{
ControllerMap.SearchForRight();
}
}
// down
else
{
ControllerMap.SearchForDown();
}
}
private IEnumerator StartListeningDelayed(int index, ControllerMap keyboardMap, ControllerMap mouseMap, int actionElementMapToReplaceId)
{
// Don't allow a binding for a short period of time after input field is activated
// to prevent button bound to UI Submit from binding instantly when input field is activated.
yield return(new WaitForSeconds(0.1f));
// Begin listening for input on both keyboard and mouse at the same time
inputMapper_keyboard.Start(
new InputMapper.Context()
{
actionId = rows[index].action.id,
controllerMap = keyboardMap,
actionRange = rows[index].actionRange,
actionElementMapToReplace = keyboardMap.GetElementMap(actionElementMapToReplaceId)
}
);
inputMapper_mouse.Start(
new InputMapper.Context()
{
actionId = rows[index].action.id,
controllerMap = mouseMap,
actionRange = rows[index].actionRange,
actionElementMapToReplace = mouseMap.GetElementMap(actionElementMapToReplaceId)
}
);
// Disable the UI Controller Maps while listening to prevent UI control and submissions.
player.controllers.maps.SetMapsEnabled(false, uiCategory);
// Update the UI text
statusUIText.text = "Listening...";
}
/// <summary>
/// 激活一个按钮集合
/// </summary>
/// <param name="btns"></param>
protected void EnabledControllers(JoystickController[] btns)
{
for (int i = 0; i < btns.Length; i++)
{
ControllerMap.Find(btns[i].gameObject.name).Enabled = true;
}
}
public static bool InitSections(ControllerMap _controllerMap)
{
InitLocalization();
if (_controllerMap.categoryId == CUSTOM_CATEGORY)
{
return(false);
}
foreach (var keybindInfo in s_customKeyDict.Values)
{
// If the controller map's control type does not match our action
if (!(keybindInfo.controllerType == ControlType.Both ||
keybindInfo.controllerType == ControlType.Keyboard && (_controllerMap is KeyboardMap || _controllerMap is MouseMap) ||
keybindInfo.controllerType == ControlType.Gamepad && (_controllerMap is JoystickMap)))
{
// Then skip to next action
continue;
}
// i dont know but this gets the best results
if (_controllerMap.categoryId != 5)
{
// Skip to next action
continue;
}
//SL.LogWarning("Creating element map for '" + keybindInfo.name + "', id: " + _controllerMap.id + ", categoryId: " + _controllerMap.categoryId);
_controllerMap.CreateElementMap(keybindInfo.actionID, Pole.Positive, KeyCode.None, ModifierKeyFlags.None);
}
// We're done here. Call original implementation
return(true);
}
public void SetInputType(string type)
{
ControllerMap cUIMap = m_RewiredPlayer.controllers.maps.GetMap(ControllerType.Joystick, 0, "Default", "UI");
ControllerMap cDMap = m_RewiredPlayer.controllers.maps.GetMap(ControllerType.Joystick, 0, "Default", "Default");
if (cUIMap != null && cDMap != null)
{
}
else
{
cUIMap = m_RewiredPlayer.controllers.maps.GetMap(ControllerType.Keyboard, 0, "Default", "UI");
cDMap = m_RewiredPlayer.controllers.maps.GetMap(ControllerType.Keyboard, 0, "Default", "Default");
}
switch (type)
{
case "UI":
cUIMap.enabled = true;
cDMap.enabled = false;
break;
case "Default":
cUIMap.enabled = false;
cDMap.enabled = true;
break;
}
}
// Event Handlers
// Called by the input field UI Button when pressed
private void OnInputFieldClicked(int index, int actionElementMapToReplaceId)
{
if (index < 0 || index >= rows.Count)
{
return; // index out of range
}
ControllerMap keyboardMap = player.controllers.maps.GetMap(ControllerType.Keyboard, 0, category, layout);
ControllerMap mouseMap = player.controllers.maps.GetMap(ControllerType.Mouse, 0, category, layout);
// Cannot replace a keyboard binding on a Mouse Map or vice versa
// Replacement cross device has to be done by removing the other
// binding manually after input is mapped.
// Determine which map the replacement binding exists on and store that information.
ControllerMap controllerMapWithReplacement;
// Determine if the replacement is on the keyboard or mouse map
if (keyboardMap.ContainsElementMap(actionElementMapToReplaceId))
{
controllerMapWithReplacement = keyboardMap;
}
else if (mouseMap.ContainsElementMap(actionElementMapToReplaceId))
{
controllerMapWithReplacement = mouseMap;
}
else
{
controllerMapWithReplacement = null; // not a replacement
}
// Store the information about the replacement if any
_replaceTargetMapping = new TargetMapping()
{
actionElementMapId = actionElementMapToReplaceId,
controllerMap = controllerMapWithReplacement
};
// Begin listening for input on both keyboard and mouse at the same time
inputMapper_keyboard.Start(
new InputMapper.Context()
{
actionId = rows[index].action.id,
controllerMap = keyboardMap,
actionRange = rows[index].actionRange,
actionElementMapToReplace = keyboardMap.GetElementMap(actionElementMapToReplaceId)
}
);
inputMapper_mouse.Start(
new InputMapper.Context()
{
actionId = rows[index].action.id,
controllerMap = mouseMap,
actionRange = rows[index].actionRange,
actionElementMapToReplace = mouseMap.GetElementMap(actionElementMapToReplaceId)
}
);
statusUIText.text = "Listening...";
}
public InputMapping(string actionName, InputFieldInfo fieldInfo, ControllerMap map, ActionElementMap aem, ControllerType controllerType, int controllerId)
{
this.actionName = actionName;
this.fieldInfo = fieldInfo;
this.map = map;
this.aem = aem;
this.controllerType = controllerType;
this.controllerId = controllerId;
}
public static bool InitSections(ControllerMap _controllerMap)
{
//MyLogger.LogDebug("InitSections");
// Loop through our custom actions we added via Rewired
foreach (int myActionId in CustomKeybindings.myCustomActionIds.Keys)
{
// The info that the user specified for this action
CustomKeybindings.InputActionDescription myActionDescription = CustomKeybindings.myCustomActionIds[myActionId];
// There are separate keybinding maps for keyboard, mouse, & controllers
// We only add our action-to-element mappings to the keybind maps that make sense
// For example, if you are adding a key that doesn't make sense to have on a controller,
// then skip when _controllerMap is JoystickMap
//
// (Optional)
// You can check if this method is being called for the Keyboard/Mouse bindings panel or
// the Controller bindings panel, but I prefer to check the class of the _controllerMap
// if (self.ControllerType == ControlMappingPanel.ControlType.Keyboard) {
//
bool shouldLog = false;
if (shouldLog)
{
MyLogger.LogDebug("_controllerMap is keyboard or mouse: " + (_controllerMap is KeyboardMap || _controllerMap is MouseMap));
MyLogger.LogDebug("_controllerMap is joystick: " + (_controllerMap is JoystickMap));
MyLogger.LogDebug("_controllerMap.categoryId: " + _controllerMap.categoryId);
MyLogger.LogDebug("action is keyboard: " + (myActionDescription.controlType == ControlType.Keyboard));
MyLogger.LogDebug("action is gamepad: " + (myActionDescription.controlType == ControlType.Gamepad));
MyLogger.LogDebug("action is both: " + (myActionDescription.controlType == ControlType.Both));
MyLogger.LogDebug("action.sectionId: " + myActionDescription.sectionId);
}
// If the controller map's control type does not match our action
if (!(myActionDescription.controlType == ControlType.Keyboard && (_controllerMap is KeyboardMap || _controllerMap is MouseMap) ||
myActionDescription.controlType == ControlType.Gamepad && (_controllerMap is JoystickMap) ||
myActionDescription.controlType == ControlType.Both))
{
// Then skip to next action
continue;
}
// If the categoryId of this controller map does not match our action's
if (_controllerMap.categoryId != myActionDescription.sectionId)
{
// Skip to next action
continue;
}
// If we pass the tests, create & add the action-to-element map for this particular action
_controllerMap.CreateElementMap(myActionId, Pole.Positive, KeyCode.None, ModifierKeyFlags.None);
// Continue the loop...
}
// We're done here. Call original implementation
return(true);
}
public override void Init()
{
base.Init();
if (ControllerMap == null)
{
ControllerMap = JoystickControllerMap.create();
}
ControllerMap.Init(GetComponentsInChildren <JoystickController>());
}
private void AddDefaultMappingsForNewActions(Player player, List <UserDataStore_PlayerPrefs.SavedControllerMapData> savedData, ControllerType controllerType, int controllerId)
{
if (player == null || savedData == null)
{
return;
}
List <int> allActionIds = this.GetAllActionIds();
for (int i = 0; i < savedData.Count; i++)
{
UserDataStore_PlayerPrefs.SavedControllerMapData savedControllerMapData = savedData[i];
if (savedControllerMapData != null)
{
if (savedControllerMapData.knownActionIds != null && savedControllerMapData.knownActionIds.Count != 0)
{
ControllerMap controllerMap = ControllerMap.CreateFromXml(controllerType, savedData[i].xml);
if (controllerMap != null)
{
ControllerMap map = player.controllers.maps.GetMap(controllerType, controllerId, controllerMap.categoryId, controllerMap.layoutId);
if (map != null)
{
ControllerMap controllerMapInstance = ReInput.mapping.GetControllerMapInstance(ReInput.controllers.GetController(controllerType, controllerId), controllerMap.categoryId, controllerMap.layoutId);
if (controllerMapInstance != null)
{
List <int> list = new List <int>();
foreach (int item in allActionIds)
{
if (!savedControllerMapData.knownActionIds.Contains(item))
{
list.Add(item);
}
}
if (list.Count != 0)
{
foreach (ActionElementMap actionElementMap in controllerMapInstance.AllMaps)
{
if (list.Contains(actionElementMap.actionId))
{
if (!map.DoesElementAssignmentConflict(actionElementMap))
{
ElementAssignment elementAssignment = new ElementAssignment(controllerType, actionElementMap.elementType, actionElementMap.elementIdentifierId, actionElementMap.axisRange, actionElementMap.keyCode, actionElementMap.modifierKeyFlags, actionElementMap.actionId, actionElementMap.axisContribution, actionElementMap.invert);
map.CreateElementMap(elementAssignment);
}
}
}
}
}
}
}
}
}
}
}
private void RedrawUI(ControllerMap map)
{
// Update each button label with the currently mapped element identifier
for (int i = 0; i < Buttons.Count; i++)
{
Template.InputButtonTemplate template = Buttons[i];
InputAction action = Buttons[i].InputAction;
string name = string.Empty;
int actionElementMapId = -1;
// Find the first ActionElementMap that maps to this action and is compatible with this field type
foreach (var actionElementMap in map.ElementMapsWithAction(action.id))
{
Debug.Log(actionElementMap.actionDescriptiveName + " | " + actionElementMap.controllerMap.controllerType.ToString());
if (actionElementMap.controllerMap.controllerType == ControllerType.Keyboard)
{
template.IsKeyboard = true;
}
if (actionElementMap.ShowInField(template.AxisRange))
{
name = actionElementMap.elementIdentifierName;
actionElementMapId = actionElementMap.id;
break;
}
}
if (map.controllerType == ControllerType.Keyboard && template.IsKeyboard)
{
// Set the label for the button
template.RemapButtonText.SetText(name);
// Set the field button callback
template.RemapButton.onClick.RemoveAllListeners(); // clear all events
int index = i; // copy the variable for closer
template.RemapButton.onClick.AddListener(() => OnInputFieldClicked(index, actionElementMapId, map));
}
else if (map.controllerType == ControllerType.Mouse && !template.IsKeyboard)
{
template.transform.SetParent(MouseControlContent);
// Set the label for the button
template.RemapButtonText.SetText(name);
// Set the field button callback
template.RemapButton.onClick.RemoveAllListeners(); // clear all events
int index = i; // copy the variable for closer
template.RemapButton.onClick.AddListener(() => OnInputFieldClicked(index, actionElementMapId, map));
}
}
}
// Token: 0x06000255 RID: 597 RVA: 0x00037D08 File Offset: 0x00035F08
public virtual ActionElementMap GetActionElementMapToUse(Controller controller, string theAction, bool positiveAxis)
{
if (!RuntimeServices.EqualityOperator(controller, null))
{
ControllerMap map = this.player.controllers.maps.GetMap(controller.type, controller.id, "Default", "Default");
ActionElementMap[] elementMapsWithAction = map.GetElementMapsWithAction(theAction);
int i = 0;
ActionElementMap[] array = elementMapsWithAction;
int length = array.Length;
while (i < length)
{
if (array[i].axisContribution == ((!positiveAxis) ? Pole.Negative : Pole.Positive))
{
return(array[i]);
}
i++;
}
map = this.player.controllers.maps.GetMap(controller.type, controller.id, "Motorcycle", "Default");
if (!RuntimeServices.EqualityOperator(map, null))
{
elementMapsWithAction = map.GetElementMapsWithAction(theAction);
int j = 0;
ActionElementMap[] array2 = elementMapsWithAction;
int length2 = array2.Length;
while (j < length2)
{
if (array2[j].axisContribution == ((!positiveAxis) ? Pole.Negative : Pole.Positive))
{
return(array2[j]);
}
j++;
}
}
map = this.player.controllers.maps.GetMap(controller.type, controller.id, "UI Nav", "Default");
if (!RuntimeServices.EqualityOperator(map, null))
{
elementMapsWithAction = map.GetElementMapsWithAction(theAction);
int k = 0;
ActionElementMap[] array3 = elementMapsWithAction;
int length3 = array3.Length;
while (k < length3)
{
if (array3[k].axisContribution == ((!positiveAxis) ? Pole.Negative : Pole.Positive))
{
return(array3[k]);
}
k++;
}
}
}
return(null);
}
//Set up a control mapping UI section and bind references
internal static void InitCustomSection(ControlMappingSection mapSection, ControllerMap _controllerMap, IEnumerable <KeybindInfo> keysToAdd)
{
if (_controllerMap == null)
{
return;
}
// Loop through the custom actions we defined
foreach (var customKey in keysToAdd)
{
// add the actual keybind mapping to this controller in Rewired
_controllerMap.CreateElementMap(customKey.actionID, Pole.Positive, KeyCode.None, ModifierKeyFlags.None);
var alreadyKnown = At.GetField(mapSection, "m_actionAlreadyKnown") as List <int>;
// see if the UI has already been set up for this keybind
if (alreadyKnown.Contains(customKey.actionID))
{
continue;
}
// set up the UI for this keybind (same as how game does it)
alreadyKnown.Add(customKey.actionID);
var action = ReInput.mapping.GetAction(customKey.actionID);
var actTemplate = At.GetField(mapSection, "m_actionTemplate") as ControlMappingAction;
actTemplate.gameObject.SetActive(true);
if (action.type == InputActionType.Button)
{
At.Invoke(mapSection, "CreateActionRow", CUSTOM_CATEGORY, action, AxisRange.Positive);
}
else
{
if (mapSection.ControllerType == ControlMappingPanel.ControlType.Keyboard)
{
At.Invoke(mapSection, "CreateActionRow", CUSTOM_CATEGORY, action, AxisRange.Positive);
At.Invoke(mapSection, "CreateActionRow", CUSTOM_CATEGORY, action, AxisRange.Negative);
}
else
{
At.Invoke(mapSection, "CreateActionRow", CUSTOM_CATEGORY, action, AxisRange.Full);
}
}
actTemplate.gameObject.SetActive(false);
// Continue the loop of custom keys...
}
}
internal static void ApplyRemaps(string bodyName)
{
if (!skillBindingOverrides.Exists(x => x.bodyName == bodyName))
{
VRMod.StaticLogger.LogInfo(String.Format("No binding overrides found for \'{0}\'. Using default binding.", bodyName));
RevertRemap();
return;
}
VRMod.StaticLogger.LogInfo(String.Format("Binding overrides were found for \'{0}\'. Applying overrides.", bodyName));
SkillBindingOverride bindingOverride = skillBindingOverrides.FirstOrDefault(x => x.bodyName == bodyName);
if (bindingOverride.bodyName == bodyName)
{
int[] originalSkillBindingIDs = new int[]
{
(ModConfig.LeftDominantHand.Value ? 9 : 8),
(ModConfig.LeftDominantHand.Value ? 8 : 9),
(ModConfig.LeftDominantHand.Value ? 11 : 10),
(ModConfig.LeftDominantHand.Value ? 10 : 11)
};
ActionElementMap[] newMapOrder = new ActionElementMap[]
{
vrGameplayMap.GetElementMapsWithAction(7 + (int)bindingOverride.dominantTrigger)[0],
vrGameplayMap.GetElementMapsWithAction(7 + (int)bindingOverride.nonDominantTrigger)[0],
vrGameplayMap.GetElementMapsWithAction(7 + (int)bindingOverride.nonDominantGrip)[0],
vrGameplayMap.GetElementMapsWithAction(7 + (int)bindingOverride.dominantGrip)[0]
};
ControllerMap controllerMap = Utils.localInputPlayer.controllers.maps.GetMap(vrControllers, vrGameplayMap.id);
for (int i = 0; i < 4; i++)
{
ActionElementMap elementMap = newMapOrder[i];
if (elementMap.elementIdentifierId == originalSkillBindingIDs[i])
{
continue;
}
if (!controllerMap.ReplaceElementMap(elementMap.id, elementMap.actionId, elementMap.axisContribution, originalSkillBindingIDs[i], elementMap.elementType, elementMap.axisRange, elementMap.invert))
{
VRMod.StaticLogger.LogError("An error occured while trying to override skill bindings.");
}
}
}
}
private void RedrawUI()
{
// Update joystick name in UI
controllerNameUIText.text = "Keyboard/Mouse";
// Update each button label with the currently mapped element identifier
for (int i = 0; i < rows.Count; i++)
{
Row row = rows[i];
InputAction action = rows[i].action;
string name = string.Empty;
int actionElementMapId = -1;
// Find the first ActionElementMap that maps to this Action and is compatible with this field type
for (int j = 0; j < 2; j++)
{
// Search the Keyboard Map first, then the Mouse Map
ControllerType controllerType = j == 0 ? ControllerType.Keyboard : ControllerType.Mouse;
ControllerMap controllerMap = player.controllers.maps.GetMap(controllerType, 0, category, layout);
foreach (var actionElementMap in controllerMap.ElementMapsWithAction(action.id))
{
if (actionElementMap.ShowInField(row.actionRange))
{
name = actionElementMap.elementIdentifierName;
actionElementMapId = actionElementMap.id;
break;
}
}
if (actionElementMapId >= 0)
{
break; // found one
}
}
// Set the label in the field button
row.text.text = name;
// Set the field button callback
row.button.onClick.RemoveAllListeners(); // clear the button event listeners first
int index = i; // copy variable for closure
row.button.onClick.AddListener(() => OnInputFieldClicked(index, actionElementMapId));
}
}
private void SetupPadSupport()
{
ControllerMap.InitialiseStandardMappings();
Joystick.Update();
Controllers = new List <Controller>();
for (uint i = 0; i < Joystick.Count; i++)
{
if (Joystick.IsConnected(i))
{
JoystickConnected(null, i);
}
}
Window.JoystickConnected += JoystickConnected;
Window.JoystickDisconnected += JoystickDisconnected;
}
private void OnInputFieldClicked(int index, int actionElementMapToReplaceId, ControllerMap map)
{
if (index < 0 || index >= Buttons.Count)
{
return; // index out of range
}
// Begin listening for input
InputMapper.Start(
new InputMapper.Context()
{
actionId = Buttons[index].InputAction.id,
controllerMap = map,
actionRange = Buttons[index].AxisRange,
actionElementMapToReplace = map.GetElementMap(actionElementMapToReplaceId)
});
// SHOW A UI TO TELL WE'RE LISTENING
}
private void ToggleInverted(ControllerType inputType, bool value)
{
ControllerMap map = rewiredPlayer.controllers.maps.GetMap((int)inputType);
if (map == null)
{
return;
}
ActionElementMap[] action = map.GetElementMaps();
foreach (ActionElementMap actionMap in action)
{
if (actionMap.actionId == (int)ACTIONS.VerticalLook)
{
actionMap.invert = value;
}
}
}
// Initialize Input
private void InitializeInputSettings()
{
playerInput = ReInput.players.GetPlayer(0);
int controllerID = 0;
// Control Type Joystick
if (controlType == ControllerType.Joystick)
{
controllerID = ControllerStatusManager.iGamepadID;
// If there are no controllers connected or no controller selected then set all gamepad fields to 'None'
if (playerInput.controllers.joystickCount == 0 || controllerID == -1)
{
bUnassigned = true;
}
else
{
bUnassigned = false;
}
}
else
{
bUnassigned = false;
}
if (!bUnassigned)
{
controlMap = playerInput.controllers.maps.GetFirstMapInCategory(controlType, controllerID, 3);
altControlMap = playerInput.controllers.maps.GetFirstMapInCategory(controlType, controllerID, 4);
aElementMaps = controlMap.AllMaps.ToArray();
aAltElementMaps = altControlMap.AllMaps.ToArray();
}
if (aUIInputRows == null)
{
InitializeFields();
}
else
{
UpdateFields();
}
}
public void Setup(Rewired.Player player)
{
var iterator = player.controllers.maps.GetAllMaps(ControllerType.Keyboard).GetEnumerator();
iterator.MoveNext();
ControllerMap map = iterator.Current;
ActionElementMap[] buttonMaps = new ActionElementMap[map.buttonMapCount];
map.ButtonMaps.CopyTo(buttonMaps, 0);
ActionElementMap up = Array.Find(buttonMaps, x => x.actionId == 0 && x.axisContribution == Pole.Positive);
ActionElementMap right = Array.Find(buttonMaps, x => x.actionId == 1 && x.axisContribution == Pole.Positive);
ActionElementMap down = Array.Find(buttonMaps, x => x.actionId == 0 && x.axisContribution == Pole.Negative);
ActionElementMap left = Array.Find(buttonMaps, x => x.actionId == 1 && x.axisContribution == Pole.Negative);
ActionElementMap action = Array.Find(buttonMaps, x => x.actionId == 2);
SetText(up.keyCode, upKey);
SetText(right.keyCode, rightKey);
SetText(down.keyCode, downKey);
SetText(left.keyCode, leftKey);
SetText(action.keyCode, regroupKey);
}
// Event Handlers
// Called by the input field UI Button when pressed
private void OnInputFieldClicked(int index, int actionElementMapToReplaceId)
{
if (index < 0 || index >= rows.Count)
{
return; // index out of range
}
ControllerMap keyboardMap = player.controllers.maps.GetMap(ControllerType.Keyboard, 0, category, layout);
ControllerMap mouseMap = player.controllers.maps.GetMap(ControllerType.Mouse, 0, category, layout);
// Cannot replace a keyboard binding on a Mouse Map or vice versa
// Replacement cross device has to be done by removing the other
// binding manually after input is mapped.
// Determine which map the replacement binding exists on and store that information.
ControllerMap controllerMapWithReplacement;
// Determine if the replacement is on the keyboard or mouse map
if (keyboardMap.ContainsElementMap(actionElementMapToReplaceId))
{
controllerMapWithReplacement = keyboardMap;
}
else if (mouseMap.ContainsElementMap(actionElementMapToReplaceId))
{
controllerMapWithReplacement = mouseMap;
}
else
{
controllerMapWithReplacement = null; // not a replacement
}
// Store the information about the replacement if any
_replaceTargetMapping = new TargetMapping()
{
actionElementMapId = actionElementMapToReplaceId,
controllerMap = controllerMapWithReplacement
};
// Begin listening for input, but use a coroutine so it starts only after a short delay to prevent
// the button bound to UI Submit from binding instantly when the input field is activated.
StartCoroutine(StartListeningDelayed(index, keyboardMap, mouseMap, actionElementMapToReplaceId));
}
private static void UpdateActionElementRelationships(Dictionary <int[], List <ActionElementMap> > elementSourceActionLinks, Dictionary <int, ActionElementMap> storedElementMaps, InputMapCategory sourceCategory, Player player)
{
foreach (KeyValuePair <int[], List <ActionElementMap> > keyValuePair in elementSourceActionLinks)
{
if (keyValuePair.Value.SafeCount <ActionElementMap>() != 0)
{
int key = keyValuePair.Key[2];
ActionElementMap oldElementMap = storedElementMaps[key];
KeyboardMap firstMapInCategory = player.controllers.maps.GetFirstMapInCategory <KeyboardMap>(0, sourceCategory.id);
if (firstMapInCategory == null)
{
Debug.LogError("newControllerMap is null!");
}
else
{
ActionElementMap firstElementMapMatch = firstMapInCategory.GetFirstElementMapMatch((ActionElementMap searchMap) => searchMap.actionId == oldElementMap.actionId);
if (firstElementMapMatch == null)
{
Debug.LogError("sourceMap is null!");
}
else
{
foreach (ActionElementMap actionElementMap in keyValuePair.Value)
{
ControllerMap controllerMap = actionElementMap.controllerMap;
ElementAssignment elementAssignment = new ElementAssignment(ControllerType.Keyboard, firstElementMapMatch.elementType, firstElementMapMatch.elementIdentifierId, firstElementMapMatch.axisRange, firstElementMapMatch.keyCode, firstElementMapMatch.modifierKeyFlags, firstElementMapMatch.actionId, firstElementMapMatch.axisContribution, firstElementMapMatch.invert, actionElementMap.id);
bool flag = controllerMap.DeleteElementMap(actionElementMap.id);
ActionElementMap actionElementMap2;
if (!flag || !controllerMap.CreateElementMap(elementAssignment, out actionElementMap2))
{
Debug.Log("Failed to remap secondary actions");
}
}
}
}
}
}
}
private void DrawLabels(Player player, InputAction action)
{
// Lists first Action bound to each Dual Analog Gamepad Template element
// Get the first Controller that implements the Dual Analog Gamepad Template from the Player
Controller controller = player.controllers.GetFirstControllerWithTemplate <IGamepadTemplate>();
if (controller == null)
{
return;
}
// Get the first gamepad assigned to the Player
IGamepadTemplate gamepad = controller.GetTemplate <IGamepadTemplate>();
// Get the Controller Map in the Default category and layout for this Controller from the Player
ControllerMap controllerMap = player.controllers.maps.GetMap(controller, "Default", "Default");
if (controllerMap == null)
{
return;
}
// Go through each Controller Template element displayed in the UI
for (int i = 0; i < _uiElementsArray.Length; i++)
{
ControllerUIElement uiElement = _uiElementsArray[i].element;
int elementId = _uiElementsArray[i].id;
// Get the Controller Template Element from the Controller Template
IControllerTemplateElement element = gamepad.GetElement(elementId);
// Draw the label
DrawLabel(uiElement, action, controllerMap, gamepad, element);
}
}
/// <summary>
/// find a mapping for joystickIndex
/// </summary>
void MapToControllerType()
{
string[] joystickNames = Input.GetJoystickNames();
if (joystickIndex < 0 || joystickIndex >= joystickNames.Length) { return; }
// get the controller's name
string controllerType = joystickNames[joystickIndex].ToUpper();
// get ControllerMap list based on platform
List<ControllerMap> mapList;
if (Application.platform == RuntimePlatform.OSXPlayer ||
Application.platform == RuntimePlatform.OSXEditor ||
Application.platform == RuntimePlatform.OSXWebPlayer)
{
mapList = controllerMapsMac;
}
else
{
mapList = controllerMapsPC;
}
// find controllerMap for the current controller
bool foundController;
foreach (ControllerMap map in mapList)
{
foundController = true;
// look for all tags
foreach (string s in map.controllerTags)
{
if (!controllerType.Contains(s.ToUpper()))
{
foundController = false;
break;
}
}
// if the map contains all the tags
if (foundController)
{
// use the map, setup input polling names
currentMap = map;
SetInputPollNames();
return;
}
}
Debug.LogWarning("no controller mapping found for " + this + ", controller type: " + controllerType + "; defaulting to XBOX 360 (PC)");
currentMap = controllerMapsPC[0];
SetInputPollNames();
}
private void DrawMapCategories()
{
if (this.selectedPlayer == null)
{
return;
}
if (!this.selectedController.hasSelection)
{
return;
}
bool enabled = GUI.enabled;
GUILayout.Space(15f);
GUILayout.Label("Categories:", new GUILayoutOption[0]);
GUILayout.BeginHorizontal(new GUILayoutOption[0]);
foreach (InputMapCategory current in ReInput.mapping.UserAssignableMapCategories)
{
if (!this.selectedPlayer.controllers.maps.ContainsMapInCategory(this.selectedController.type, current.id))
{
GUI.enabled = false;
}
else if (this.selectedMapCategoryId < 0)
{
this.selectedMapCategoryId = current.id;
this.selectedMap = this.selectedPlayer.controllers.maps.GetFirstMapInCategory(this.selectedController.type, this.selectedController.id, current.id);
}
bool flag = current.id == this.selectedMapCategoryId;
bool flag2 = GUILayout.Toggle(flag, (!(current.descriptiveName != string.Empty)) ? current.name : current.descriptiveName, "Button", new GUILayoutOption[]
{
GUILayout.ExpandWidth(false)
});
if (flag2 != flag)
{
this.selectedMapCategoryId = current.id;
this.selectedMap = this.selectedPlayer.controllers.maps.GetFirstMapInCategory(this.selectedController.type, this.selectedController.id, current.id);
}
if (GUI.enabled != enabled)
{
GUI.enabled = enabled;
}
}
GUILayout.EndHorizontal();
if (GUI.enabled != enabled)
{
GUI.enabled = enabled;
}
}
private void AddDefaultMappingsForNewActions(Player player, List <SavedControllerMapData> savedData, ControllerType controllerType, int controllerId)
{
if (player == null || savedData == null)
{
return;
}
// Check for new Actions added to the default mappings that didn't exist when the Controller Map was saved
List <int> allActionIds = GetAllActionIds();
for (int i = 0; i < savedData.Count; i++)
{
SavedControllerMapData data = savedData[i];
if (data == null)
{
continue;
}
if (data.knownActionIds == null || data.knownActionIds.Count == 0)
{
continue;
}
// Create a map from the Xml so we can get information
ControllerMap mapFromXml = ControllerMap.CreateFromXml(controllerType, savedData[i].xml);
if (mapFromXml == null)
{
continue;
}
// Load the map that was added to the Player
ControllerMap mapInPlayer = player.controllers.maps.GetMap(controllerType, controllerId, mapFromXml.categoryId, mapFromXml.layoutId);
if (mapInPlayer == null)
{
continue;
}
// Load default map for comparison
ControllerMap defaultMap = ReInput.mapping.GetControllerMapInstance(ReInput.controllers.GetController(controllerType, controllerId), mapFromXml.categoryId, mapFromXml.layoutId);
if (defaultMap == null)
{
continue;
}
// Find any new Action ids that didn't exist when the Controller Map was saved
List <int> unknownActionIds = new List <int>();
foreach (int id in allActionIds)
{
if (data.knownActionIds.Contains(id))
{
continue;
}
unknownActionIds.Add(id);
}
if (unknownActionIds.Count == 0)
{
continue; // no new Action ids
}
// Add all mappings in the default map for previously unknown Action ids
foreach (ActionElementMap aem in defaultMap.AllMaps)
{
if (!unknownActionIds.Contains(aem.actionId))
{
continue;
}
// Skip this ActionElementMap if there's a conflict within the loaded map
if (mapInPlayer.DoesElementAssignmentConflict(aem))
{
continue;
}
// Create an assignment
ElementAssignment assignment = new ElementAssignment(
controllerType,
aem.elementType,
aem.elementIdentifierId,
aem.axisRange,
aem.keyCode,
aem.modifierKeyFlags,
aem.actionId,
aem.axisContribution,
aem.invert
);
// Assign it
mapInPlayer.CreateElementMap(assignment);
}
}
}
private void DrawLabel(ControllerUIElement uiElement, InputAction action, ControllerMap controllerMap,
IControllerTemplate template, IControllerTemplateElement element)
{
if (element.source == null)
{
return; // this element cannot map to a source
}
ActionElementMap aem;
// A Controller Template Element Source contains Targets that each point to
// a Controller.Element or part of a Controller.Element (such as one pole of an Axis).
// Handle Axis-type Template Element
if (element.source.type == ControllerTemplateElementSourceType.Axis)
{
// Cast the source to an Axis source so we can access the 3 possible Targets
IControllerTemplateAxisSource source = (element.source as IControllerTemplateAxisSource);
// A Template axis source can be either a full-axis binding or a split-axis binding
// Handle split-axis source
if (source.splitAxis)
{
// A split-axis source has a Positive Target and a Negative Target, one for each side of the axis.
// Positive Target
aem = controllerMap.GetFirstElementMapWithElementTarget(source.positiveTarget, action.id, true);
if (aem != null)
{
uiElement.SetLabel(aem.actionDescriptiveName, AxisRange.Positive);
}
// Negative Target
aem = controllerMap.GetFirstElementMapWithElementTarget(source.negativeTarget, action.id, true);
if (aem != null)
{
uiElement.SetLabel(aem.actionDescriptiveName, AxisRange.Negative);
}
// Handle full-axis source
}
else
{
// A full-axis sources has just a single full target.
// Full Target
aem = controllerMap.GetFirstElementMapWithElementTarget(source.fullTarget, action.id, true);
if (aem != null)
{
// a full target was mapped
uiElement.SetLabel(aem.actionDescriptiveName, AxisRange.Full);
}
else
{
// no full mapping was found, look for separate positive/negative mappings
// Positive side
aem = controllerMap.GetFirstElementMapWithElementTarget(
new ControllerElementTarget(source.fullTarget)
{
axisRange = AxisRange.Positive
},
action.id,
true
);
if (aem != null)
{
uiElement.SetLabel(aem.actionDescriptiveName, AxisRange.Positive);
}
// Negative side
aem = controllerMap.GetFirstElementMapWithElementTarget(
new ControllerElementTarget(source.fullTarget)
{
axisRange = AxisRange.Negative
},
action.id,
true
);
if (aem != null)
{
uiElement.SetLabel(aem.actionDescriptiveName, AxisRange.Negative);
}
}
}
// Handle Button-type Template Element
}
else if (element.source.type == ControllerTemplateElementSourceType.Button)
{
// Cast the source to an button source
IControllerTemplateButtonSource source = (element.source as IControllerTemplateButtonSource);
// Target
aem = controllerMap.GetFirstElementMapWithElementTarget(source.target, action.id, true);
if (aem != null)
{
uiElement.SetLabel(aem.actionDescriptiveName, AxisRange.Full);
}
}
}
private void ClearMapSelection()
{
this.selectedMapCategoryId = -1;
this.selectedMap = null;
}
private void DrawAddActionMapButton(int playerId, InputAction action, Pole actionAxisContribution, ControllerSelection controller, ControllerMap controllerMap,
bool assignFullAxis) {
if(GUILayout.Button("Add...", GUILayout.ExpandWidth(false))) {
EnqueueAction(new ElementAssignmentChange(playerId, controller.id, controller.type, controllerMap,
ElementAssignmentChangeType.Add, -1, action.id, actionAxisContribution, action.type, assignFullAxis, false));
}
GUILayout.Space(10);
}
private void DrawActionAssignmentButton(int playerId, InputAction action, Pole actionAxisContribution, ControllerSelection controller, ControllerMap controllerMap,
bool assignFullAxis, ActionElementMap elementMap) {
if(GUILayout.Button(elementMap.elementIdentifierName, GUILayout.ExpandWidth(false), GUILayout.MinWidth(30.0f))) {
EnqueueAction(new ElementAssignmentChange(playerId, controller.id, controller.type, controllerMap,
ElementAssignmentChangeType.ReassignOrRemove, elementMap.id, action.id, actionAxisContribution, action.type, assignFullAxis, elementMap.invert));
}
GUILayout.Space(4);
}
private void DrawInvertButton(int playerId, InputAction action, Pole actionAxisContribution, ControllerSelection controller, ControllerMap controllerMap, ActionElementMap elementMap) {
bool value = elementMap.invert;
bool newValue = GUILayout.Toggle(value, "Invert", GUILayout.ExpandWidth(false));
if(newValue != value) {
elementMap.invert = newValue;
}
GUILayout.Space(10);
}
private void DrawMapCategories() {
if(selectedPlayer == null) return;
if(!selectedController.hasSelection) return;
bool origGuiEnabled = GUI.enabled; // save GUI state
GUILayout.Space(15);
GUILayout.Label("Categories:");
GUILayout.BeginHorizontal();
foreach(InputMapCategory category in ReInput.mapping.UserAssignableMapCategories) {
if(!selectedPlayer.controllers.maps.ContainsMapInCategory(selectedController.type, category.id)) { // if player has no maps in this category for controller don't allow them to select it
GUI.enabled = false;
} else {
// Select first available category if none selected
if(selectedMapCategoryId < 0) {
selectedMapCategoryId = category.id; // if no category selected, select first
selectedMap = selectedPlayer.controllers.maps.GetFirstMapInCategory(selectedController.type, selectedController.id, category.id);
}
}
bool prevValue = category.id == selectedMapCategoryId ? true : false;
bool value = GUILayout.Toggle(prevValue, category.descriptiveName != string.Empty ? category.descriptiveName : category.name, "Button", GUILayout.ExpandWidth(false));
if(value != prevValue) { // category changed
selectedMapCategoryId = category.id;
selectedMap = selectedPlayer.controllers.maps.GetFirstMapInCategory(selectedController.type, selectedController.id, category.id);
}
if(GUI.enabled != origGuiEnabled) GUI.enabled = origGuiEnabled;
}
GUILayout.EndHorizontal();
if(GUI.enabled != origGuiEnabled) GUI.enabled = origGuiEnabled; // restore GUI state
}
public ElementAssignmentChange(
int playerId,
int controllerId,
ControllerType controllerType,
ControllerMap controllerMap,
ElementAssignmentChangeType changeType,
int actionElementMapId,
int actionId,
Pole actionAxisContribution,
InputActionType actionType,
bool assignFullAxis,
bool invert
) : base(QueueActionType.ElementAssignment) {
this.playerId = playerId;
this.controllerId = controllerId;
this.controllerType = controllerType;
this.controllerMap = controllerMap;
this.changeType = changeType;
this.actionElementMapId = actionElementMapId;
this.actionId = actionId;
this.actionAxisContribution = actionAxisContribution;
this.actionType = actionType;
this.assignFullAxis = assignFullAxis;
this.invert = invert;
}
private void DrawInvertButton(int playerId, InputAction action, Pole actionAxisContribution, ControlRemappingDemo1.ControllerSelection controller, ControllerMap controllerMap, ActionElementMap elementMap)
{
bool invert = elementMap.invert;
bool flag = GUILayout.Toggle(invert, "Invert", new GUILayoutOption[]
{
GUILayout.ExpandWidth(false)
});
if (flag != invert)
{
elementMap.invert = flag;
}
GUILayout.Space(10f);
}
/// <summary>
/// reads in universal controller mappings from a file located in Resources/txt/
/// </summary>
/// <param name="fileName"> the file to be read </param>
void ReadMapFile(string fileName)
{
string totalMappings = (Resources.Load("txt/" + fileName) as TextAsset).text;
//Debug.Log(totalMappings);
// intro, pc, and mac split: 0 - intro, 1 - PC, 2 - mac
string[] firstSplit = totalMappings.Split(new string[] { "$$$" + Environment.NewLine }, StringSplitOptions.None);
// pc list
string[] pcSplit = firstSplit[1].Split(new string[] { "***" + Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < pcSplit.Length; i++)
{
ControllerMap newMapping = new ControllerMap();
// the lines that make up the mapping info
string[] lines = pcSplit[i].Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
// fill tags with first element
newMapping.controllerTags = lines[0].Split(' ');
// fill map with mappings
newMapping.map = new string[lines.Length - 1];
for (int j = 0; j < newMapping.map.Length; j++)
{
newMapping.map[j] = lines[j + 1];
}
controllerMapsPC.Add(newMapping);
}
// mac list
string[] macSplit = firstSplit[2].Split(new string[] { "***" + Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < macSplit.Length; i++)
{
ControllerMap newMapping = new ControllerMap();
// the lines that make up the mapping info
string[] lines = macSplit[i].Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
// fill tags with first element
newMapping.controllerTags = lines[0].Split(' ');
// fill map with mappings
newMapping.map = new string[lines.Length - 1];
for (int j = 0; j < newMapping.map.Length; j++)
{
newMapping.map[j] = lines[j + 1];
}
controllerMapsMac.Add(newMapping);
}
}
private void AddActionAssignmentButton(InputActionRow uiRow, int playerId, InputAction action, Pole actionAxisContribution, ControllerMap controllerMap, bool assignFullAxis, ActionElementMap elementMap, bool showInvert = false)
{
InputActionButton uiButton;
if (!showInvert)
{
uiButton = UnityEngine.Object.Instantiate<InputActionButton>(this._inputActionButtonPrefab);
}
else
{
uiButton = UnityEngine.Object.Instantiate<InputActionButton>(this._inputAxisActionButtonPrefab);
}
uiButton._label.text = elementMap.elementIdentifierName;
uiButton._actionElementMap = elementMap;
uiButton._button.onClick.Add(new EventDelegate(delegate
{
if (!this.enabled && this._nextChangeTimer < Time.realtimeSinceStartup)
{
if (UICamera.currentTouchID == -1)
{
this._replaceElementMap = true;
this._entry = new InputMappingAction.ElementAssignmentChange(playerId, InputMappingAction.ElementAssignmentChangeType.ReassignOrRemove, elementMap.id, action.id, actionAxisContribution, action.type, assignFullAxis, elementMap.invert);
this._entry.controllerMap = controllerMap;
this._entry.uiButton = uiButton;
this.StartPollInput();
}
else if (UICamera.currentTouchID == -2)
{
this._entry = new InputMappingAction.ElementAssignmentChange(playerId, InputMappingAction.ElementAssignmentChangeType.Remove, elementMap.id, action.id, actionAxisContribution, action.type, assignFullAxis, elementMap.invert);
controllerMap.DeleteElementMap(this._entry.actionElementMapId);
this._knownActionMaps.Remove(elementMap);
UnityEngine.Object.Destroy(uiButton.gameObject);
uiRow._actionGrid.repositionNow = true;
Dictionary<InputActionRow, int> actionRowMappingCount2;
Dictionary<InputActionRow, int> expr_181 = actionRowMappingCount2 = this._actionRowMappingCount;
InputActionRow uiRow3;
InputActionRow expr_189 = uiRow3 = uiRow;
int num2 = actionRowMappingCount2[uiRow3];
expr_181[expr_189] = num2 - 1;
this.CheckActionMappingCount(uiRow);
this._nextChangeTimer = Time.realtimeSinceStartup + this._interChangeDelay;
}
}
}));
if (showInvert)
{
uiButton._invertAxisToggle.gameObject.SetActive(true);
uiButton._invertAxisToggle.value = uiButton._actionElementMap.invert;
uiButton._invertAxisToggle.onChange.Add(new EventDelegate(delegate
{
if (!this.enabled && this._nextChangeTimer < Time.realtimeSinceStartup)
{
uiButton._actionElementMap.invert = uiButton._invertAxisToggle.value;
}
}));
}
uiButton.transform.parent = uiRow._actionGrid.transform;
uiButton.transform.localPosition = Vector3.zero;
uiButton.transform.localScale = Vector3.one;
this._knownActionMaps.Add(elementMap, uiButton);
Dictionary<InputActionRow, int> actionRowMappingCount;
Dictionary<InputActionRow, int> expr_18C = actionRowMappingCount = this._actionRowMappingCount;
InputActionRow uiRow2;
InputActionRow expr_194 = uiRow2 = uiRow;
int num = actionRowMappingCount[uiRow2];
expr_18C[expr_194] = num + 1;
}
private void ClearMapSelection() {
selectedMapCategoryId = -1; // clear map cat selection
selectedMap = null;
}
private void DrawAddActionMapButton(int playerId, InputAction action, Pole actionAxisContribution, ControlRemappingDemo1.ControllerSelection controller, ControllerMap controllerMap, bool assignFullAxis)
{
if (GUILayout.Button("Add...", new GUILayoutOption[]
{
GUILayout.ExpandWidth(false)
}))
{
this.EnqueueAction(new ControlRemappingDemo1.ElementAssignmentChange(playerId, controller.id, controller.type, controllerMap, ControlRemappingDemo1.ElementAssignmentChangeType.Add, -1, action.id, actionAxisContribution, action.type, assignFullAxis, false));
}
GUILayout.Space(10f);
}
