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;
}
}
