public async Task<ApiResult<Object>> SaveConfiguration(InputConfiguration configuration)
{
var result = await httpClient.PostAsync(Save,
new StringContent(JsonSerializer.Serialize(configuration), Encoding.UTF8, "application/json"));
var content = await result.Content.ReadAsStringAsync();
return JsonSerializer.Deserialize<ApiResult<Object>>(content);
}
public static bool pressingBack(InputConfiguration bindings)
{
switch (bindings.inputMode)
{
case InputConfiguration.PlayerInputType.MOUSE:
return Input.GetKeyDown(KeyCode.Escape) || Input.GetMouseButtonDown(1);
case InputConfiguration.PlayerInputType.JOYSTICK:
//ability axis
float currentAxisValue = Input.GetAxis(bindings.genericAbilityAxis);
bool returnValue = false;
if (currentAxisValue != 0)
{
returnValue = true;
}
//now XY axis
currentAxisValue = Input.GetAxis(bindings.backAbilityAxis);
if (currentAxisValue != 0)
{
returnValue = true;
}
return returnValue;
default:
return false;
}
}
public PlayerComponents(CharacterComponents character, InputConfiguration bindings, int playerID, Vector2 characterVisualsVector)
{
this.character = character;
this.bindings = bindings;
this.playerID = playerID;
this.characterVisualsVector = characterVisualsVector;
}
public void Update(InputConfiguration config)
{
this.Config = config;
// General input
this.HorizontalLook = Input.GetAxisRaw(config.HorizontalInput);
this.VerticalLook = Input.GetAxisRaw(config.VerticalInput);
// Keyboard input
if (this.Config.TControlType == ControlType.Keyboard)
{
this.MoveForward = Input.GetKey(config.MoveForward) ? 1 : 0;
this.MoveForward = Input.GetKey(config.MoveBack) ? -1 : this.MoveForward;
this.StrafeRight = Input.GetKey(config.StrafeRight) ? 1 : 0;
this.StrafeRight = Input.GetKey(config.StrafeLeft) ? -1 : this.StrafeRight;
this.Sprint = !Input.GetKey(config.Sprint);
this.Crouch = Input.GetKey(config.Crouch);
this.Jump = Input.GetKeyDown(config.Jump);
this.Dive = Input.GetKeyDown(config.Dive);
}
// Gamepad input
else
{
this.MoveForward = Input.GetAxisRaw(config.GamepadVerticalInput);
this.StrafeRight = Input.GetAxisRaw(config.GamepadHorizontalInput);
this.Sprint = !Input.GetKey(config.GamepadSprint);
this.Crouch = Input.GetKey(config.GamepadCrouch);
this.Jump = Input.GetKeyDown(config.GamepadJump);
this.Dive = Input.GetKeyDown(config.GamepadDive);
}
}
public static InputConfiguration SetTypeKeyOrMouseButton(
this InputConfiguration inputConfiguration)
{
return(inputConfiguration.Configure(
axisType: AxisType.KeyOrMouseButton,
axisNumber: AxisNumber.AxisX,
joystickNumber: JoystickNumber.AllJoysticks));
}
public static InputConfiguration ConfigureJoystickAxis(
this InputConfiguration inputConfiguration,
JoystickNumber joystickNumber,
AxisNumber axisNumber)
{
return(inputConfiguration
.SetTypeJoystickAxis(joystickNumber, axisNumber));
}
public SelectedItem(MidiInput input, GameObject obj, List <string> components)
{
Item = new InputConfiguration(input);
Object = obj;
Components = components;
Members = obj == null ? new List <string>() : GetMembers(Object.GetComponent(Components[0]));
}
public static InputConfiguration SetAltNegativeButton(
this InputConfiguration inputConfiguration,
JoystickNumber joystickNumber,
JoystickButton?joystickButton)
{
return(inputConfiguration
.SetAltNegativeButton(UnityButtonNameFormat.JoystickButtonName(joystickNumber, joystickButton)));
}
void ChangeButtonBind(string buttonName, KeyCode newButton)
{
InputConfiguration config = InputManager.GetInputConfiguration("P" + newButton.ToString()[8].ToString() + "Controls");
AxisConfiguration button = config.axes.Find(x => x.name == buttonName);
button.positive = newButton;
}
public void Add_NewConfigCanBeAdded()
{
var c = new InputConfiguration();
provider.Add(c);
Assert.AreEqual(1, provider.Configs.Count());
Assert.AreEqual(c, provider.Configs.First());
}
private IInputManipulator BuildInputManipulator()
{
var inputConfig = new InputConfiguration();
_inputConfigurationFactory?.Invoke(inputConfig);
return(inputConfig.Build());
}
public void ClosePanel()
{
mesagePanel.SetActive(false);
GameManager.instance.ventanaAbierta = false;
GameManager.instance.pauseMode = false;
InputConfiguration.SelectFirstFoundButton();
//Time.timeScale = 1;
}
public void AddOrUpdate_AddsWhenNewInstance()
{
var c = new InputConfiguration();
provider.AddOrUpdate(c);
Assert.AreEqual(1, provider.Configs.Count());
Assert.AreEqual(c, provider.Configs.First());
}
public InputDeviceManager(Window window, MainWindow.ToggleOverlayCallback _toggleOverlayCallback)
{
InputConfig = new InputConfiguration();
_directInput = new DirectInput();
var deviceInstances = _directInput.GetDevices();
WindowHelper =
new WindowInteropHelper(window);
this._toggleOverlayCallback = _toggleOverlayCallback;
foreach (var deviceInstance in deviceInstances)
{
//Workaround for Bad Devices that pretend to be joysticks
if (!IsBlackListed(deviceInstance.ProductGuid))
{
Logger.Info("Found " + deviceInstance.ProductGuid + " Instance: " + deviceInstance.InstanceGuid +
" " +
deviceInstance.ProductName.Trim().Replace("\0", "") + " Usage: " +
deviceInstance.UsagePage);
if (deviceInstance.Type == DeviceType.Keyboard)
{
Logger.Info("Adding " + deviceInstance.ProductGuid + " Instance: " + deviceInstance.InstanceGuid +
" " +
deviceInstance.ProductName.Trim().Replace("\0", ""));
var device = new Keyboard(_directInput);
device.SetCooperativeLevel(WindowHelper.Handle,
CooperativeLevel.Background | CooperativeLevel.NonExclusive);
device.Acquire();
_inputDevices.Add(device);
}
else if (deviceInstance.Type >= DeviceType.Joystick && deviceInstance.Type <= DeviceType.FirstPerson || IsWhiteListed(deviceInstance.ProductGuid))
{
var device = new Joystick(_directInput, deviceInstance.InstanceGuid);
Logger.Info("Adding " + deviceInstance.ProductGuid + " Instance: " +
deviceInstance.InstanceGuid + " " +
deviceInstance.ProductName.Trim().Replace("\0", ""));
device.SetCooperativeLevel(WindowHelper.Handle,
CooperativeLevel.Background | CooperativeLevel.NonExclusive);
device.Acquire();
_inputDevices.Add(device);
}
}
else
{
Logger.Info("Found but ignoring " + deviceInstance.ProductGuid + " Instance: " +
deviceInstance.InstanceGuid + " " +
deviceInstance.ProductName.Trim().Replace("\0", "") + " Type: " + deviceInstance.Type);
}
}
}
public async Task <ApiResult <Object> > SaveConfiguration(InputConfiguration configuration)
{
var result = await httpClient.PostAsync(Save,
new StringContent(JsonSerializer.Serialize(configuration), Encoding.UTF8, "application/json"));
var content = await result.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <ApiResult <Object> >(content));
}
private void AddMediaFiles(ZipFile zip, InputConfiguration inputConfig)
{
var path = Path.Combine(appConfigProvider.AppConfig.MediaRoot, inputConfig.Name.RemoveWhitespace());
if (new FileSystemUtils().DirectoryExists(path))
{
zip.AddDirectory(path, "Media\\" + inputConfig.Name.RemoveWhitespace());
}
}
// Called when InputManager is initialized (it's Awake() function).
private void DefaultKeys( )
{
/* original:
* if ( gameStateController.isMenuActive ( ) )
*
* temporary:
*/
inputManager.SetValidKeys(InputConfiguration.GetValidKeys( ));
}
// Use this for initialization
void Start()
{
textoCambio = GetComponent <Text>();
textoCambio.text = "Has completado el trimestre " + (GameManager.instance.trimestre - 1);
dinero.text = "Dinero: " + (GameManager.instance.dinero - 100);
amigos.text = "Amigos: " + GameManager.instance.numFriends;
nota.text = "Nota: " + (GameManager.instance.media);
InputConfiguration.SelectFirstFoundButton();
}
public OverkillConfiguration(IOverkillConfiguration config)
{
System = config.System;
Client = config.Client;
Positioning = config.Positioning;
VehicleConnection = config.VehicleConnection;
Streaming = config.Streaming;
Input = config.Input;
}
public void Remove_RemovesAddedInstance()
{
var c = new InputConfiguration();
provider.AddOrUpdate(c);
Assert.AreEqual(1, provider.Configs.Count());
provider.Remove(c);
Assert.AreEqual(0, provider.Configs.Count());
}
public void Dispose_JustClearsTheList()
{
var c = new InputConfiguration();
provider.Add(c);
Assert.AreEqual(1, provider.Configs.Count());
provider.Dispose();
Assert.AreEqual(0, provider.Configs.Count());
}
public void Remove(InputConfiguration config)
{
lock (configs)
{
if (configs.Contains(config))
{
configs.Remove(config);
}
}
}
public void Add(InputConfiguration config)
{
lock (configs)
{
if (!configs.Contains(config))
{
configs.Add(config);
}
}
}
public void InputConfiguration_CopiesAssemblyFilesSequence()
{
var original = new List <string> {
"1", "2", "3"
};
var inputConfiguration = new InputConfiguration(original);
original.Add("4");
Assert.Equal(3, inputConfiguration.AssemblyFiles.Count());
}
public virtual void SaveInputConfiguration(InputConfiguration c)
{
var path = AppConfigProvider.AppConfig.ConfigFolder;
if (!FileSystemUtils.DirectoryExists(path))
{
throw new Exception("Directory does not exist");
}
FileSystemUtils.SaveObjectToDisk(c, Path.Combine(path, c.FileName));
}
public static InputConfiguration SetTypeMouseMovement(
this InputConfiguration inputConfiguration,
AxisNumber axisNumber)
{
return(inputConfiguration.Configure(
axisType: AxisType.MouseMovement,
joystickNumber: JoystickNumber.AllJoysticks,
axisNumber: axisNumber,
sensitivity: 1));
}
public static InputConfiguration ConfigureButton(
this InputConfiguration inputConfiguration,
MouseButton positiveButton,
MouseButton?altPositiveButton = null)
{
return(inputConfiguration
.SetTypeKeyOrMouseButton()
.SetPositiveButton(positiveButton)
.SetAltPositiveButton(altPositiveButton));
}
public void SaveAndLoadMouseButton_Succeeds()
{
// arrange
var inputConfiguration = new InputConfiguration()
.ConfigureInfo("TestAxis", "DescriptiveName", "DescriptiveNegativeName")
.ConfigureButton(MouseButton.Mouse1, MouseButton.Mouse2);
// act & assert
AssertSaveAndLoadAreEquivalent(inputConfiguration);
}
public void SaveAndLoadKeyboardButton_Succeeds()
{
// arrange
var inputConfiguration = new InputConfiguration()
.ConfigureInfo("TestAxis", "DescriptiveName", "DescriptiveNegativeName")
.ConfigureButton("left", "a");
// act & assert
AssertSaveAndLoadAreEquivalent(inputConfiguration);
}
public void SaveAndLoadMouseMovement_Succeeds()
{
// arrange
var inputConfiguration = new InputConfiguration()
.ConfigureInfo("TestAxis", "DescriptiveName", "DescriptiveNegativeName")
.ConfigureMouseMovement(AxisNumber.Axis3OrScrollwhell);
// act & assert
AssertSaveAndLoadAreEquivalent(inputConfiguration);
}
public void SaveAndLoadJoystickAxis_Succeeds()
{
// arrange
var inputConfiguration = new InputConfiguration()
.ConfigureInfo("TestAxis", "DescriptiveName", "DescriptiveNegativeName")
.ConfigureJoystickAxis(JoystickNumber.Joystick1, AxisNumber.AxisY);
// act & assert
AssertSaveAndLoadAreEquivalent(inputConfiguration);
}
public void RemoveInputConfiguration(InputConfiguration i)
{
var path = AppConfigProvider.AppConfig.ConfigFolder;
if (!FileSystemUtils.DirectoryExists(path))
{
throw new Exception("Directory does not exist");
}
FileSystemUtils.RemoveFile(Path.Combine(path, i.FileName));
}
/// <summary>
/// Constructs a new editor application. Called at editor start-up by the runtime, and any time assembly refresh
/// occurrs.
/// </summary>
internal EditorApplication()
{
instance = this;
codeManager = new ScriptCodeManager();
const string soName = "EditorPersistentData";
SceneObject so = Scene.Root.FindChild(soName);
if (so == null)
{
so = new SceneObject(soName, true);
}
persistentData = so.GetComponent <EditorPersistentData>();
if (persistentData == null)
{
persistentData = so.AddComponent <EditorPersistentData>();
}
// Register controls
InputConfiguration inputConfig = VirtualInput.KeyConfig;
inputConfig.RegisterButton(SceneCamera.MoveForwardBinding, ButtonCode.W);
inputConfig.RegisterButton(SceneCamera.MoveBackBinding, ButtonCode.S);
inputConfig.RegisterButton(SceneCamera.MoveLeftBinding, ButtonCode.A);
inputConfig.RegisterButton(SceneCamera.MoveRightBinding, ButtonCode.D);
inputConfig.RegisterButton(SceneCamera.MoveUpBinding, ButtonCode.E);
inputConfig.RegisterButton(SceneCamera.MoveDownBinding, ButtonCode.Q);
inputConfig.RegisterButton(SceneCamera.MoveForwardBinding, ButtonCode.Up);
inputConfig.RegisterButton(SceneCamera.MoveBackBinding, ButtonCode.Down);
inputConfig.RegisterButton(SceneCamera.MoveLeftBinding, ButtonCode.Left);
inputConfig.RegisterButton(SceneCamera.MoveRightBinding, ButtonCode.Right);
inputConfig.RegisterButton(SceneCamera.FastMoveBinding, ButtonCode.LeftShift);
inputConfig.RegisterButton(SceneCamera.RotateBinding, ButtonCode.MouseRight);
inputConfig.RegisterButton(SceneCamera.PanBinding, ButtonCode.MouseMiddle);
inputConfig.RegisterAxis(SceneCamera.HorizontalAxisBinding, InputAxis.MouseX);
inputConfig.RegisterAxis(SceneCamera.VerticalAxisBinding, InputAxis.MouseY);
inputConfig.RegisterAxis(SceneCamera.ScrollAxisBinding, InputAxis.MouseZ);
inputConfig.RegisterButton(SceneWindow.ToggleProfilerOverlayBinding, ButtonCode.P, ButtonModifier.CtrlAlt);
inputConfig.RegisterButton(SceneWindow.ViewToolBinding, ButtonCode.Q);
inputConfig.RegisterButton(SceneWindow.FrameBinding, ButtonCode.F);
inputConfig.RegisterButton(SceneWindow.MoveToolBinding, ButtonCode.W);
inputConfig.RegisterButton(SceneWindow.RotateToolBinding, ButtonCode.E);
inputConfig.RegisterButton(SceneWindow.ScaleToolBinding, ButtonCode.R);
inputConfig.RegisterButton(SceneWindow.DuplicateBinding, ButtonCode.D, ButtonModifier.Ctrl);
if (IsProjectLoaded)
{
monitor = new FolderMonitor(ProjectLibrary.ResourceFolder);
monitor.OnAdded += OnAssetModified;
monitor.OnRemoved += OnAssetModified;
monitor.OnModified += OnAssetModified;
}
}
public SelectedItem(InputConfiguration config, GameObject obj, List <string> components)
{
Item = config;
Object = obj;
Components = components;
Members = GetMembers(Object.GetComponent(config.Component));
ComponentIndex = components.IndexOf(Item.Component);
MemberIndex = Members.IndexOf(Item.Member);
}
internal Channel(InputConfiguration selection, int id)
{
this.Id = id;
this.InputConfiguration = selection;
}
protected void lblInput_MouseClick(object sender, MouseEventArgs e)
{
int ch_num = int.Parse(((Label)sender).Name.Substring(5, 1));
// Specific to FLX
bool phantom_power = (ch_num <= num_phantom);
InputConfig cached_input = (InputConfig)PROGRAMS[CURRENT_PROGRAM].inputs[ch_num - 1].Clone();
int cached_pregain = PROGRAMS[CURRENT_PROGRAM].pregains[ch_num - 1];
using (InputConfiguration inputForm = new InputConfiguration(this, ch_num, phantom_power))
{
if (!LIVE_MODE)
{
inputForm.Width = 276;
}
else
{
inputForm.Width = 320;
}
inputForm.Height = 221;
DialogResult showBlock = inputForm.ShowDialog(this);
if(showBlock == DialogResult.Cancel)
{
if (!PROGRAMS[CURRENT_PROGRAM].inputs[ch_num - 1].Equals(cached_input))
{
PROGRAMS[CURRENT_PROGRAM].inputs[ch_num - 1] = (InputConfig)cached_input.Clone();
PROGRAMS[CURRENT_PROGRAM].pregains[ch_num - 1] = cached_pregain;
if (LIVE_MODE && FIRMWARE_VERSION > 2.5)
{
UInt32 new_input_gain = DSP_Math.double_to_MN(PROGRAMS[CURRENT_PROGRAM].pregains[ch_num - 1] +
PROGRAMS[CURRENT_PROGRAM].gains[ch_num - 1][0].Gain, 9, 23);
AddItemToQueue(new LiveQueueItem((0 + ch_num - 1), new_input_gain));
AddItemToQueue(new LiveQueueItem((412 + ch_num - 1), PROGRAMS[CURRENT_PROGRAM].inputs[ch_num - 1].TypeToValue()));
AddItemToQueue(new LiveQueueItem(ch_num, PROGRAMS[CURRENT_PROGRAM].inputs[ch_num - 1].Name));
AddItemToQueue(new LiveQueueItem(1000 + (ch_num - 1), PROGRAMS[CURRENT_PROGRAM].inputs[ch_num-1].PhantomAsInt()));
}
}
}
else
{
if (LIVE_MODE && (PROGRAMS[CURRENT_PROGRAM].inputs[ch_num - 1].Name != cached_input.Name))
{
// Check if this has changed
// Don't update this until we hit save since it takes so long.
AddItemToQueue(new LiveQueueItem(ch_num, PROGRAMS[CURRENT_PROGRAM].inputs[ch_num - 1].Name));
}
UpdateTooltips();
}
}
}
public PlayerComponents(CharacterComponents character, InputConfiguration bindings, int playerID)
{
this.character = character;
this.bindings = bindings;
this.playerID = playerID;
}
