private void MoveHome() { switch (AxisType) { case (1): cmd = 1; mode = 1; break; case (2): AxisIai.Homing(); bool InPosition = false; StartTimer(); double Time = StepTime(); while (!InPosition && Time < TimeOut) { AxisIai.ReadRegisterBit(AxisIai.HomingCompletationStatus, ref InPosition); State = AxisState.ExecutingHoming; Thread.Sleep(50); Time = StepTime(); } if (InPosition) { State = AxisState.InPosition; ErrorValue = -1; } else { State = AxisState.Error; ErrorValue = 1; } break; } Workthread.Abort(); }
public void InitializeAxes(params string[] axisNames) { for (var i = 0; i < axisNames.Length; i++) { _axisStates[axisNames[i]] = new AxisState(axisNames[i]); } }
private void Start() { cinemachineFreeLook = GetComponent <CinemachineFreeLook>(); defaultAxisState_X = cinemachineFreeLook.m_XAxis; defaultAxisState_Y = cinemachineFreeLook.m_YAxis; // switch (InputManager.Instance.Type) { // case InputManager.Controller.Playstation: // defaultAxisState_X.m_InputAxisName = ps4XAxisName; // defaultAxisState_Y.m_InputAxisName = ps4YAxisName; // break; // case InputManager.Controller.Xbox: // defaultAxisState_X.m_InputAxisName = xboxXAxisName; // defaultAxisState_Y.m_InputAxisName = xboxYAxisName; // // defaultAxisState_X.m_InvertInput = false; // break; // case InputManager.Controller.MouseAndKeyboard: // break; // case InputManager.Controller.None:; // break; // } defaultAxisState_X.m_InputAxisName = xboxXAxisName; defaultAxisState_Y.m_InputAxisName = xboxYAxisName; defaultAxisState_X.m_InvertInput = false; cinemachineFreeLook.m_XAxis = defaultAxisState_X; cinemachineFreeLook.m_YAxis = defaultAxisState_Y; }
protected void GetAxisSettings(ref AxisState axisSettings) { if (!MaxSpeed.IsNone) { MaxSpeed.Value = axisSettings.m_MaxSpeed; } if (!AccelTime.IsNone) { AccelTime.Value = axisSettings.m_AccelTime; } if (!DecelTime.IsNone) { DecelTime.Value = axisSettings.m_DecelTime; } if (!InputAxisName.IsNone) { InputAxisName.Value = axisSettings.m_InputAxisName; } if (!InvertAxis.IsNone) { #if UNITY_2018_1_OR_NEWER InvertAxis.Value = axisSettings.m_InvertInput; #else InvertAxis.Value = axisSettings.m_InvertAxis; #endif } }
public ETCAxis(string axisName) { name = axisName; enable = true; range = AxisRange.Classical; speed = 15; invertedAxis = false; isEnertia = false; inertia = 0; inertiaThreshold = 0.08f; axisValue = 0; axisSpeedValue = 0; gravity = 0; isAutoStab = false; autoStabThreshold = 0.01f; autoStabSpeed = 10; maxAngle = 90; minAngle = 90; axisState = AxisState.None; maxOverTimeValue = 1; overTimeStep = 1; isValueOverTime = false; axisThreshold = 0.5f; deadValue = 0.1f; actionOn = ActionOn.Press; }
/// <summary> /// 读取轴状态 /// </summary> /// <param name="axis">轴号</param> /// <returns>状态字符串</returns> public string ReadAxisStateString(Axis axis) { int indexBoard = (int)axis / MAX_AXIS_CHANNEL; //板卡索引 int indexAxis = (int)axis % MAX_AXIS_CHANNEL; //板卡内轴号索引 if (!IsBoardConnected((Board)indexBoard)) { return(" "); } string retStr = " "; AxisState State = (AxisState)m_AxisState[indexBoard, indexAxis]; switch (State) { case AxisState.Ready: retStr = "轴已准备就绪"; break; case AxisState.ErrorStop: retStr = "出现错误,轴停止"; break; case AxisState.Motion: retStr = "轴正在执行运动..."; break; } return(retStr); }
protected void SetAxisSettings(ref AxisState axisSettings) { if (!MaxSpeed.IsNone) { axisSettings.m_MaxSpeed = MaxSpeed.Value; } if (!AccelTime.IsNone) { axisSettings.m_AccelTime = AccelTime.Value; } if (!DecelTime.IsNone) { axisSettings.m_DecelTime = DecelTime.Value; } if (!InputAxisName.IsNone) { axisSettings.m_InputAxisName = InputAxisName.Value; } if (!InvertAxis.IsNone) { #if UNITY_2018_1_OR_NEWER axisSettings.m_InvertInput = InvertAxis.Value; #else axisSettings.m_InvertAxis = InvertAxis.Value; #endif } }
public void TestGotoStates() { AxisId axis = AxisId.Axis1_RA; string response; int state; _Controller.MCAxisSlewTo(axis, 0.25 * CoreConstants.DEG_RAD, HemisphereOption.Northern); //System.Diagnostics.Debug.WriteLine("Goto Forward Low Speed"); //System.Diagnostics.Debug.WriteLine(_Controller.TalkWithAxis(axis, 'f', null)); response = _Controller.TalkWithAxis(axis, 'f', null); state = Convert.ToInt32(response.Substring(1, response.Length - 2), 16); AxisState axisState = _Controller.MCGetAxisState(axis); while (!axisState.FullStop) { Thread.Sleep(100); axisState = _Controller.MCGetAxisState(axis); } Assert.AreEqual(0x011, state); _Controller.MCAxisSlewTo(axis, 30.0 * CoreConstants.DEG_RAD, HemisphereOption.Northern); System.Diagnostics.Debug.WriteLine("Goto Forward High Speed"); //System.Diagnostics.Debug.WriteLine(_Controller.TalkWithAxis(axis, 'f', null)); response = _Controller.TalkWithAxis(axis, 'f', null); state = Convert.ToInt32(response.Substring(1, response.Length - 2), 16); axisState = _Controller.MCGetAxisState(axis); while (!axisState.FullStop) { Thread.Sleep(100); axisState = _Controller.MCGetAxisState(axis); } Assert.AreEqual(0x411, state); _Controller.MCAxisSlewTo(axis, 0.25 * CoreConstants.DEG_RAD, HemisphereOption.Northern); System.Diagnostics.Debug.WriteLine("Goto Reverse High Speed"); //System.Diagnostics.Debug.WriteLine(_Controller.TalkWithAxis(axis, 'f', null)); response = _Controller.TalkWithAxis(axis, 'f', null); state = Convert.ToInt32(response.Substring(1, response.Length - 2), 16); axisState = _Controller.MCGetAxisState(axis); while (!axisState.FullStop) { Thread.Sleep(100); axisState = _Controller.MCGetAxisState(axis); } Assert.AreEqual(0x611, state); _Controller.MCAxisSlewTo(axis, 0.0 * CoreConstants.DEG_RAD, HemisphereOption.Northern); System.Diagnostics.Debug.WriteLine("Goto Reverse Low Speed"); //System.Diagnostics.Debug.WriteLine(_Controller.TalkWithAxis(axis, 'f', null)); response = _Controller.TalkWithAxis(axis, 'f', null); state = Convert.ToInt32(response.Substring(1, response.Length - 2), 16); axisState = _Controller.MCGetAxisState(axis); while (!axisState.FullStop) { Thread.Sleep(100); axisState = _Controller.MCGetAxisState(axis); } Assert.AreEqual(0x211, state); }
public ETCAxis(string axisName) { name = axisName; enable = true; speed = 15; invertedAxis = false; isEnertia = false; inertia = 0; inertiaThreshold = 0.08f; axisValue = 0; axisSpeedValue = 0; gravity = 0; isAutoStab = false; autoStabThreshold = 0.01f; autoStabSpeed = 10; maxAngle = 90; minAngle = 90; axisState = AxisState.None; maxOverTimeValue = 1; overTimeStep = 1; isValueOverTime = false; axisThreshold = 0.5f; deadValue = 0.1f; actionOn = ActionOn.Press; }
/// <summary> /// Checks a controller axis and gets its state /// </summary> /// <param name="axis">The axis you want</param> /// <param name="player_id">The player you're checking</param> /// <param name="state">Pass a state in by reference and it will tell you how this axis compares to last frame</param> /// <returns>The axis value</returns> public float getAxisAndState(Axis axis, int player_id, ref AxisState state) { float this_frame = controllers[player_id].axes_this_frame[(int)axis]; state = getAxisState(this_frame, axis, player_id); return(this_frame); }
// Update is called once per frame void Update() { AxisState state = AxisState.Null; float vert = iM.getAxisAndState(Axis.D_Vertical, 0, ref state); if (vert > 0 && state == AxisState.Triggered_This_Frame) { changeSelect(1); } if (vert < 0 && state == AxisState.Triggered_This_Frame) { changeSelect(-1); } vert = iM.getAxisAndState(Axis.Left_Vertical, 0, ref state); if (vert < 0 && state == AxisState.Triggered_This_Frame) { changeSelect(1); } if (vert > 0 && state == AxisState.Triggered_This_Frame) { changeSelect(-1); } if (iM.isButtonPressed(XboxButton.A, 0) && selected == 2) { SceneManager.LoadScene("HouseScorer"); } }
protected float GetDefaultHorizontalVelocity(Vector3 velocity) { AxisState horizontalAxis = horizontalAxisOverride == null?_gameManager.inputStateManager.GetAxisState("Horizontal") : horizontalAxisOverride; float normalizedHorizontalSpeed = GetNormalizedHorizontalSpeed(horizontalAxis); return(GetHorizontalVelocityWithDamping(velocity, horizontalAxis.value, normalizedHorizontalSpeed)); }
private void Update() { switch (type) { case TriggerType.Trigger: if (state == AxisState.Idle) { if (Input.GetAxisRaw(axisName) > 0) { state = AxisState.DOWN; } } else if (state > 0) { if (Input.GetAxisRaw(axisName) > 0) { state = AxisState.STAY; } else { state = AxisState.UP; } } else { state = AxisState.Idle; } break; case TriggerType.Axis: if (state == AxisState.Idle) { if (Input.GetAxisRaw(axisName) != 0) { state = AxisState.DOWN; } } else if (state > 0) { if (Input.GetAxisRaw(axisName) != 0) { state = AxisState.STAY; } else { state = AxisState.UP; } } else { state = AxisState.Idle; } break; default: break; } }
public void Reset(float duration, Direction wallDirection, WallJumpSettings wallJumpSettings) { this._overrideEndTime = duration < 0f ? null : (float?)(Time.time + duration); this._hasJumpedFromWall = false; this._wallJumpSettings = wallJumpSettings; this._wallJumpDirectionMultiplier = wallDirection == Direction.Right ? -1f : 1f; _axisOverride = new AxisState(-this._wallJumpDirectionMultiplier); }
private bool TriggeredClimbUp(AxisState verticalAxisState) { return((_gameManager.Player.PlayerState & PlayerState.ClimbingLadder) == 0 && (_gameManager.Player.PlayerState & PlayerState.Locked) == 0 && verticalAxisState.Value > 0f && IsPlayerBetweenVerticalColliders() && IsPlayerTopAboveBottomCollider() && IsPlayerTopBelowTopBoundary()); }
private void CBtnRobotTestTurnOver_Click(object sender, EventArgs e) { AxisState CurState = m_ArmControler.ReadAxisState(Axis.OverTurn); if (CurState == AxisState.Ready) { m_ArmControler.MoveAbs(Axis.OverTurn, ArmControler.m_OverturnAxisMaxStep); } }
private bool TriggeredClimbDownFromEdge(AxisState verticalAxisState) { return((_gameManager.Player.PlayerState & PlayerState.ClimbingLadder) == 0 && (_gameManager.Player.PlayerState & PlayerState.Sliding) == 0 && (_gameManager.Player.PlayerState & PlayerState.Locked) == 0 && _gameManager.Player.CurrentPlatform != null && _gameManager.Player.CurrentPlatform == _topEdge && verticalAxisState.Value < 0f && IsPlayerBetweenVerticalColliders()); }
public static Vector2 getAxisState(string axisName) { AxisState axisState = axisStates.Find(axis => axis.axisName == axisName); if (axisState == null) { throw new Exception("No axisState " + axisName + " Found!"); } return(axisState.state); }
static void setAxisState(string axisName, Vector2 state) { AxisState axisState = axisStates.Find(axis => axis.axisName == axisName); if (axisState == null) { throw new Exception("No axisState " + axisName + " Found!"); } axisState.state = state; axisState.startTime = Time.time; }
/// <summary> /// Does the update. /// </summary> /// <returns></returns> protected override bool DoUpdate() { if (_playerController.characterPhysicsManager.lastMoveCalculationResult.collisionState.below) { _hasDetached = true; Logger.Info("Popped wall jump evaluation because player is grounded."); return(false); // we only want this handler to be active while the player is in mid air } Vector3 velocity = _playerController.characterPhysicsManager.velocity; if (velocity.y < _wallJumpSettings.wallVelocityDownThreshold) { _hasDetached = true; Logger.Info("Popped wall jump evaluation because downward velocity threshold was surpassed: " + velocity.y + " < " + _wallJumpSettings.wallVelocityDownThreshold); return(false); // we can exit as wall jump is not allowed any more after the player accelerated downward beyond threshold } if ((_playerController.characterPhysicsManager.lastMoveCalculationResult.collisionState.characterWallState & CharacterWallState.NotOnWall) != 0) { _hasDetached = true; Logger.Info("Popped wall jump evaluation because character is not on wall any more."); return(false); } AxisState hAxis = _gameManager.inputStateManager.GetAxisState("Horizontal"); if (_wallDirection == Direction.Right) { if (hAxis.value <= 0f || hAxis.value < hAxis.lastValue) { _hasDetached = true; Logger.Info("Popped wall jump evaluation because horizontal axis points to opposite direction. Current and Last axis value: (" + hAxis.value + ", " + hAxis.lastValue + ")"); return(false); } } else if (_wallDirection == Direction.Left) { if (hAxis.value >= 0f || hAxis.value > hAxis.lastValue) { _hasDetached = true; Logger.Info("Popped wall jump evaluation because horizontal axis points to opposite direction. Current and Last axis value: (" + hAxis.value + ", " + hAxis.lastValue + ")"); return(false); } } else { _hasDetached = true; Logger.Info("Popped wall jump evaluation because direction " + _wallDirection + " is not supported."); return(false); } return(base.DoUpdate()); }
float ClampValue(ref AxisState axis, float v) { float r = axis.m_MaxValue - axis.m_MinValue; if (axis.m_Wrap && r > Epsilon) { v = (v - axis.m_MinValue) % r; v += axis.m_MinValue + ((v < 0) ? r : 0); } return(Mathf.Clamp(v, axis.m_MinValue, axis.m_MaxValue)); }
public static void ProcessArmControlerAxisState(Axis axis, AxisState State) //单片机控制板电机轴的状态 { switch (axis) { case Axis.Conveyor_1: //空盘传输线 { } break; default: break; } }
public void TestMCGetAxisState() { lock (_Controller) { AxisState state = _Controller.MCGetAxisState(AxisId.Axis1_RA); Assert.AreEqual(false, state.MeshedForReverse); Assert.AreEqual(false, state.NotInitialized); Assert.AreEqual(false, state.HighSpeed); Assert.AreEqual(false, state.Slewing); Assert.AreEqual(false, state.SlewingTo); } }
private void Reset() { AimDistance = 200; ReticleImage = null; CollideAgainst = 1; IgnoreTag = string.Empty; VerticalAxis = new AxisState(-70, 70, false, false, 10f, 0.1f, 0.1f, "Mouse Y", true); VerticalAxis.m_SpeedMode = AxisState.SpeedMode.InputValueGain; HorizontalAxis = new AxisState(-180, 180, true, false, 10f, 0.1f, 0.1f, "Mouse X", false); HorizontalAxis.m_SpeedMode = AxisState.SpeedMode.InputValueGain; }
public void SetInvertCamYCheckSign(Toggle value) { InvertCamYCheckSign = value; GlobalVariables.IsCamYInverted = value.isOn; if (MainCam) { AxisState temp = MainCam.m_YAxis; temp.m_InvertInput = GlobalVariables.IsCamYInverted; MainCam.m_YAxis = temp; } }
private void Festo() { while (!StopThread) { Thread.Sleep(100); if (AxisCmmt.Connected) { AxisCmmt.Override = 100.0F; AxisCmmt.CmmtControl(mode, cmd); cmd = 0; switch (AxisCmmt.iCmmtStatus) { case 2: ErrorValue = 5; State = AxisState.Error; break; case 1401: ErrorValue = 3; State = AxisState.Error; break; case 11201: ErrorValue = 6; State = AxisState.Error; break; case 11202: ErrorValue = -1; State = AxisState.InPosition; break; case 1102: ErrorValue = -1; State = AxisState.ExecutingHoming; break; case 15303: ErrorValue = -1; State = AxisState.Moving; break; case 40301: ErrorValue = 5; State = AxisState.Idle; break; } } } }
public void TestRecentering(float minValue, float maxValue, bool wrap, float maxSpeed, float accelTime, float decelTime, bool invert, float axisValue, bool enabled, float recenteringTime, float expectedValue) { var axisState = new AxisState(minValue, maxValue, wrap, false, maxSpeed, accelTime, decelTime, null, invert); axisState.SetInputAxisProvider(0, new TestAxisProvider(axisValue)); axisState.Validate(); var success = axisState.Update(1.0f); Assert.IsTrue(success, "Update had no effect"); }
void Start() { playerMovement = gameObject.GetComponent <PlayerMovementManager>(); magicManager = gameObject.GetComponent <MagicManager>(); uiManager = gameObject.GetComponent <UIManager>(); cameraManager = Camera.main.GetComponent <CameraManager>(); cameraPivot = gameObject.GetComponentInChildren <CameraPositionPivotManager>(); playerStatus = gameObject.GetComponent <PlayerStatus>(); lockOn = gameObject.GetComponent <LockOnManager>(); RightTrigger = AxisState.NotHeld; RightDPad = AxisState.NotHeld; LeftDPad = AxisState.NotHeld; UpDPad = AxisState.NotHeld; DownDPad = AxisState.NotHeld; HideCursor(); }
private void CheckAxes() { if (Input.GetAxisRaw("AimTrigger") == 1 && RightTrigger == AxisState.NotHeld) { RightTrigger = AxisState.Pressed; } else if (Input.GetAxisRaw("AimTrigger") == 0 && RightTrigger == AxisState.Held) { RightTrigger = AxisState.Released; } if (Input.GetAxisRaw("SelectSpell1") == 1 && RightDPad == AxisState.NotHeld) { RightDPad = AxisState.Pressed; } else if (Input.GetAxisRaw("SelectSpell1") <= 0 && RightDPad == AxisState.Held) { RightDPad = AxisState.Released; } if (Input.GetAxisRaw("SelectSpell1") == -1 && LeftDPad == AxisState.NotHeld) { LeftDPad = AxisState.Pressed; } else if (Input.GetAxisRaw("SelectSpell1") >= 0 && LeftDPad == AxisState.Held) { LeftDPad = AxisState.Released; } if (Input.GetAxisRaw("SelectSpell2") == 1 && UpDPad == AxisState.NotHeld) { UpDPad = AxisState.Pressed; } else if (Input.GetAxisRaw("SelectSpell2") <= 0 && UpDPad == AxisState.Held) { UpDPad = AxisState.Released; } if (Input.GetAxisRaw("SelectSpell2") == -1 && DownDPad == AxisState.NotHeld) { DownDPad = AxisState.Pressed; } else if (Input.GetAxisRaw("SelectSpell2") >= 0 && DownDPad == AxisState.Held) { DownDPad = AxisState.Released; } }
public bool Update(float deltaTime, ref AxisState axis) { if (!string.IsNullOrEmpty(name)) { try { inputValue = CinemachineCore.GetInputAxis(name); } catch (ArgumentException) { } } //catch (ArgumentException e) { Debug.LogError(e.ToString()); } var inverted = isInverted ? -1 : 1; var input = inputValue * sensitivity * multiplier * inverted; if (deltaTime < Epsilon) { mCurrentSpeed = 0; } else { var speed = input / deltaTime; var dampTime = Mathf.Abs(speed) < Mathf.Abs(mCurrentSpeed) ? decelerationTime : accelerationTime; speed = mCurrentSpeed + Damper.Damp(speed - mCurrentSpeed, dampTime, deltaTime); mCurrentSpeed = speed; // Decelerate to the end points of the range if not wrapping var range = axis.m_MaxValue - axis.m_MinValue; if (!axis.m_Wrap && decelerationTime > Epsilon && range > Epsilon) { var v0 = ClampValue(ref axis, axis.Value); var v = ClampValue(ref axis, v0 + speed * deltaTime); var d = speed > 0 ? axis.m_MaxValue - v : v - axis.m_MinValue; if (d < 0.1f * range && Mathf.Abs(speed) > Epsilon) { speed = Damper.Damp(v - v0, decelerationTime, deltaTime) / deltaTime; } } input = speed * deltaTime; } axis.Value = ClampValue(ref axis, axis.Value + input); return(Mathf.Abs(inputValue) > Epsilon); }
private void SaveAxesStates() { if (RightTrigger == AxisState.Pressed) { RightTrigger = AxisState.Held; } else if (RightTrigger == AxisState.Released) { RightTrigger = AxisState.NotHeld; } if (RightDPad == AxisState.Pressed) { RightDPad = AxisState.Held; } else if (RightDPad == AxisState.Released) { RightDPad = AxisState.NotHeld; } if (LeftDPad == AxisState.Pressed) { LeftDPad = AxisState.Held; } else if (LeftDPad == AxisState.Released) { LeftDPad = AxisState.NotHeld; } if (UpDPad == AxisState.Pressed) { UpDPad = AxisState.Held; } else if (UpDPad == AxisState.Released) { UpDPad = AxisState.NotHeld; } if (DownDPad == AxisState.Pressed) { DownDPad = AxisState.Held; } else if (DownDPad == AxisState.Released) { DownDPad = AxisState.NotHeld; } }