public void Run_Update(On.RoR2.Run.orig_Update orig, Run self)
{
orig.Invoke(self);
//Check if player is moving in any Axis
float vert = inputPlayer.GetAxis("MoveVertical");
float horz = inputPlayer.GetAxis("MoveHorizontal");
//Rework so it works better with controller
float move = vert != 0 ? .5f : horz != 0 ? .5f : 0;
float sprint = move == 0 ? 0f : characterBody.isSprinting ? .4f : 0;
//Check if player is litteraly pressing moving button (Jumping, Skills)
float skill = inputPlayer.GetButton("PrimarySkill") ? .75f :
inputPlayer.GetButton("SecondarySkill") ? .75f :
inputPlayer.GetButton("UtilitySkill") ? .75f :
inputPlayer.GetButton("SpecialSkill") ? .75f :
inputPlayer.GetButton("Jump") ? .75f :
inputPlayer.GetButton("Equipment") ? .75f : 0;
float onGround = characterMotor.isGrounded ? 0f : .25f;
//Calculate Time
//Gotta rework this sheit
float time = onGround + skill + move + sprint;
if (time > 1f)
{
time = 1f;
}
ExampleCommandHostCustom.Invoke(x => { x.Write("Time"); x.Write((double)time); });
}
void MovementInput()
{
float x = _player.GetAxis("Move Horizontal");
float z = _player.GetAxis("Move Vertical");
Vector3 movementVec = new Vector3(x, 0f, z);
if (x != 0 && z != 0)
{
_moved = true;
}
_controller.Move(movementVec * _curMoveSpeed * Time.deltaTime);
// Movement Anims
if (_playerAnimator != null)
{
if (movementVec.z >= 0.3f || movementVec.x <= -0.3f || movementVec.x >= 0.3f || movementVec.z <= -0.3f)
{
_playerAnimator.SetFloat("Blend", 1.0f);
_playerAnimator.SetBool("Running", true);
}
else
{
_playerAnimator.SetFloat("Blend", 0.0f);
_playerAnimator.SetBool("Running", false);
}
}
}
// Update is called once per frame
public void FixedUpdate()
{
// basic stick based movement
inputVector = new Vector3(rewiredPlayer.GetAxis("MoveHorizontalX"), 0, rewiredPlayer.GetAxis("MoveHorizontalY"));
//inputVector = player.transform.TransformDirection(inputVector);
// In order to properly get the bumper buttons you MUST set them manually through the inspector, they are next to each other near the joystick 1 definitions
// up and down movement
if (rewiredPlayer.GetButton("RightBumper"))
{
// move up
inputVector.y += 1;
}
if (rewiredPlayer.GetButton("LeftBumper"))
{
// move down
inputVector.y -= 1;
}
if (Input.GetKey(KeyCode.W))
{
// for playtesting without a controller
inputVector.z += 1;
}
inputVector = player.transform.TransformDirection(inputVector);
playerBody.velocity = inputVector * (player.speed * 50) * Time.deltaTime;
}
private void GetInput()
{
upInput = false;
downInput = false;
acceptInput = false;
if (player.GetAxis("Move Depth") == 0)
{
selectingUp = false;
selectingDown = false;
}
if (player.GetAxis("Move Depth") > 0 && !selectingUp)
{
upInput = true;
selectingUp = true;
}
if (player.GetAxis("Move Depth") < 0 && !selectingDown)
{
downInput = true;
selectingDown = true;
}
if (player.GetButtonDown("Action"))
{
acceptInput = true;
}
}
public static bool MenuUpOrLeft(Rewired.Player p)
{
if (p.GetAxis(0) < -.5f || p.GetAxis(1) > .5f)
{
return(true);
}
return(false);
}
public static bool MenuDownOrRight(Rewired.Player p)
{
if (p.GetAxis(0) > .5f || p.GetAxis(1) < -.5f)
{
return(true);
}
return(false);
}
public Vector2 GetInput(float deltaT, Entity entity)
{
if (active)
{
return(new Vector2(player.GetAxis("Move Horizontal"),
player.GetAxis("Move Vertical")));
}
return(new Vector2(0, 0));
}
private void Update()
{
if (!Rewired.ReInput.isReady)
{
return;
}
Rewired.Player player = Rewired.ReInput.players.GetPlayer(0);
if (IsDragging)
{
// If current dragged thing was destroyed, cancel drag
if (_currentDraggable == null)
{
StopDrag();
return;
}
float distanceScale = Vector3.Distance(Camera.main.transform.position, _currentDraggable.position);
float horizontalAxis = player.GetAxis("CursorX") * Time.deltaTime * _handDragSensitivity;
float verticalAxis = player.GetAxis("CursorY") * Time.deltaTime * _handDragSensitivity;
Vector3 cameraMovement = Camera.main.transform.position - _dragStartCameraPos;
_targetHandPos += Camera.main.transform.right.WithY(0).normalized *horizontalAxis *distanceScale;
_targetHandPos += Camera.main.transform.forward.WithY(0).normalized *verticalAxis *distanceScale;
_targetHandPos += cameraMovement;
_targetHandPos.y = _handDragHeight;
_dragStartCameraPos = Camera.main.transform.position;
_isRotating = player.GetButton("Context");
}
else
{
Ray mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
bool hit = Physics.Raycast(mouseRay, out hitInfo, 100.0f, _raycastMask);
if (hit)
{
_targetHandPos = hitInfo.point + hitInfo.normal * _handHoverDistance;
if (player.GetButtonDown("Select"))
{
StartDrag(hitInfo);
}
}
}
if (player.GetButtonUp("Select"))
{
StopDrag();
}
_handObject.transform.position = Mathfx.Damp(_handObject.transform.position, _targetHandPos, 0.5f, Time.deltaTime * _handAnimateSpeed);
}
private void FixedUpdate()
{
Vector3 leftStickInputSpace = new Vector3(input.GetAxis("Left Stick Horizontal"), 0.0f, input.GetAxis("Left Stick Vertical"));
Vector3 rightStickInputSpace = new Vector3(input.GetAxis("Right Stick Horizontal"), 0.0f, input.GetAxis("Right Stick Vertical"));
targetForward = Vector3.ProjectOnPlane(targetForward, transform.up).normalized;
targetForward = Quaternion.AngleAxis(leftStickInputSpace.x * turnSpeedDegrees * Time.fixedDeltaTime, transform.up) * targetForward;
turnDebugTarget.transform.position = transform.position + targetForward * 5.0f;
Camera.TargetForward = targetForward;
Dynamics.DesiredForward = targetForward;
}
public void FixedUpdate()
{
rotAroundX += Input.GetAxis("Mouse Y") * player.Xsensitivity;
rotAroundY += Input.GetAxis("Mouse X") * player.Ysensitivity;
rotAroundX += rewiredPlayer.GetAxis("LookHorizontalX") * -player.Xsensitivity;
rotAroundY += rewiredPlayer.GetAxis("LookHorizontalY") * player.Ysensitivity;
// Clamp rotation values
rotAroundX = Mathf.Clamp(rotAroundX, player.XMinRotation, player.XMaxRotation);
CameraRotation();
}
private void Update()
{
if (!Rewired.ReInput.isReady || _astronaut == null || _rewiredPlayer == null)
{
return;
}
float moveHorizontal = _rewiredPlayer.GetAxis(RewiredConsts.Action.MoveHorizontal);
float moveVertical = _rewiredPlayer.GetAxis(RewiredConsts.Action.MoveVertical);
Vector3 moveVector = new Vector3(moveHorizontal, 0, moveVertical);
_astronaut.MoveVector = moveVector;
UpdateInteraction();
}
void Update()
{
transform.localRotation = originalRotation;
float inputH = player.GetAxis("Rotate Horizontal");
float inputV = player.GetAxis("Rotate Vertical");
if (targetAngles.y > 180)
{
targetAngles.y -= 360;
followAngles.y -= 360;
}
if (targetAngles.x > 180)
{
targetAngles.x -= 360;
followAngles.x -= 360;
}
if (targetAngles.y < -180)
{
targetAngles.y += 360;
followAngles.y += 360;
}
if (targetAngles.x < -180)
{
targetAngles.x += 360;
followAngles.y += 360;
}
bool returning = Mathf.Abs(inputH) > 0.25f || Mathf.Abs(inputV) > 0.25f;
if (returning)
{
targetAngles.y += inputH * rotationSpeed;
targetAngles.x += inputV * rotationSpeed;
}
else
{
targetAngles.y = Mathf.MoveTowardsAngle(targetAngles.y, originalRotation.eulerAngles.y, rotationSpeed);
targetAngles.x = Mathf.MoveTowardsAngle(targetAngles.x, originalRotation.eulerAngles.x, rotationSpeed);
}
targetAngles.y = Mathf.Clamp(targetAngles.y, -rotationRange.y * 0.5f, rotationRange.y * 0.5f);
targetAngles.x = Mathf.Clamp(targetAngles.x, -rotationRange.x * 0.5f, rotationRange.x * 0.5f);
followAngles = Vector3.SmoothDamp(followAngles, targetAngles, ref followVelocity, dampingTime);
transform.localRotation = originalRotation * Quaternion.Euler(-followAngles.x, followAngles.y, 0);
}
protected override void OnUpdate()
{
Rewired.Player[] rewiredPlayers = GameManager.Instance.RewiredPlayers;
for (int i = 0; i < inputFilter.Length; i++)
{
PlayerInput input = inputFilter.Inputs[i];
Player player = inputFilter.Players[i];
Rewired.Player rewiredPlayer = rewiredPlayers[player.Id];
float hMove = rewiredPlayer.GetAxis("Move Horizontally");
float vMove = rewiredPlayer.GetAxis("Move Vertically");
input.Movement = new float2(hMove, vMove);
}
}
private void Poll(InputPlayer player, InputEventPollingType pollingType)
{
InputReceiver receiver = _receivers[player];
if (receiver == null)
{
return;
}
Rewired.Player rePlayer = ReInput.players.GetPlayer((int)receiver.InputPlayer);
foreach (var action in ReInput.mapping.Actions)
{
if (rePlayer.GetButtonDown(action.id))
{
_receivers[player]?.ReceiveButtonEvent(new InputActionEvent(action.id, pollingType, InputEventType.Down));
}
if (rePlayer.GetButtonUp(action.id))
{
_receivers[player]?.ReceiveButtonEvent(new InputActionEvent(action.id, pollingType, InputEventType.Up));
}
if (rePlayer.GetButton(action.id))
{
_receivers[player]?.ReceiveButtonEvent(new InputActionEvent(action.id, pollingType, InputEventType.Hold));
}
_receivers[player]?.ReceiveAxisEvent(rePlayer.GetAxis(action.id), new InputAxisEvent(action.id, pollingType));
}
}
public void OnSelect(BaseEventData evData)
{
// Don't apply skipping unless we are not interactable.
if (m_Selectable.interactable)
{
return;
}
// Check if the user navigated to this selectable.
if (player1.GetAxis("Menu Horizontal") < 0 || gamePadController2.GetAxis("Menu Horizontal") < 0)
{
Selectable select = m_Selectable.FindSelectableOnLeft();
if (select == null || !select.gameObject.activeInHierarchy)
{
select = m_Selectable.FindSelectableOnRight();
}
StartCoroutine(DelaySelect(select));
}
else if (player1.GetAxis("Menu Horizontal") > 0 || gamePadController2.GetAxis("Menu Horizontal") > 0)
{
Selectable select = m_Selectable.FindSelectableOnRight();
if (select == null || !select.gameObject.activeInHierarchy)
{
select = m_Selectable.FindSelectableOnLeft();
}
StartCoroutine(DelaySelect(select));
}
else if (player1.GetAxis("Menu Vertical") < 0 || gamePadController2.GetAxis("Menu Vertical") < 0)
{
Selectable select = m_Selectable.FindSelectableOnDown();
if (select == null || !select.gameObject.activeInHierarchy)
{
select = m_Selectable.FindSelectableOnUp();
}
StartCoroutine(DelaySelect(select));
}
else if (player1.GetAxis("Menu Vertical") > 0 || gamePadController2.GetAxis("Menu Vertical") > 0)
{
Selectable select = m_Selectable.FindSelectableOnUp();
if (select == null || !select.gameObject.activeInHierarchy)
{
select = m_Selectable.FindSelectableOnDown();
}
StartCoroutine(DelaySelect(select));
}
}
private void Update()
{
for (int i = 0; i < RInputs.Count; ++i)
{
Rewired.Player RInput = RInputs[i];
_slider.value += RInput.GetAxis("MoveH") * Time.deltaTime;
}
_slider.value = Mathf.Clamp(_slider.value, _slider.minValue, _slider.maxValue);
SetGamma(_slider.value);
}
private void Update()
{
Vector3 inputDirection = new Vector3(_input.GetAxis(RewiredConsts.Action.Horizontal), 0, _input.GetAxis(RewiredConsts.Action.Vertical));
if (inputDirection.sqrMagnitude > float.Epsilon)
{
_rigidbody.MoveRotation(Quaternion.LookRotation(inputDirection, Vector3.up));
}
_inputMove = _input.GetButton(RewiredConsts.Action.Move);
}
//Reads player input (could be moved to different class altoghether)
private Vector3 ReadMovement()
{
var movementVector = Vector3.zero;
if (player != null)
{
movementVector = new Vector3(player.GetAxis(RewiredConsts.Action.MoveHorizontal), 0, player.GetAxis(RewiredConsts.Action.MoveVertical));
animator.SetFloat("x", movementVector.x);
animator.SetFloat("y", movementVector.z);
}
return(movementVector);
}
// Update is called once per frame
void Update()
{
thrust = maxThrust;
thrust = Mathf.Clamp(thrust, 0, maxThrust);
if (engines.Running)
{
Vector3 movementInput = new Vector3(0, 0, thrust);
movementInput = aimSpace.TransformVector(movementInput);
controller.Pushing = movementInput.sqrMagnitude > 0.25f * 0.25f;
controller.AddForceRelative(movementInput.normalized);
}
Vector3 rotationInput = new Vector3(
player.GetAxis("Pitch"),
player.GetAxis("Yaw"),
player.GetAxis("Roll")
);
controller.Spinning = rotationInput.sqrMagnitude > 0.25f * 0.25f;
controller.AddTorqueRelative(Vector3.Scale(rotationInput, controller.Drifting?driftingRotationFactors:rotationFactors));
if (player.GetButtonDown("Slow Mo") && engines.Running)
{
engines.TurnOff();
}
if (player.GetButtonDown("Start Engine") && !engines.Running)
{
engines.TurnOn();
}
if (player.GetButton("Fire"))
{
Missile m = guns.Fire();
if (m != null)
{
m.SetTarget(targetingSystem.GetLockedTarget());
}
}
}
private void ManageNavigation()
{
for (int i = 0; i < RInputs.Count; ++i)
{
Rewired.Player RInput = RInputs[i];
bool flag = _moveFlags[i];
if (RInput.GetAxis("MoveV") < -0.2f && !flag)
{
_moveFlags[i] = true;
SetSelectedElement(Selected.navigation.selectOnDown);
}
else if (RInput.GetAxis("MoveV") > 0.2f && !flag)
{
_moveFlags[i] = true;
SetSelectedElement(Selected.navigation.selectOnUp);
}
else if (Mathf.Abs(RInput.GetAxis("MoveV")) == 0f && flag)
{
_moveFlags[i] = false;
}
}
}
private void FixedUpdate()
{
xPos = playerController.GetAxis("MoveHorizontal");
yPos = playerController.GetAxis("MoveVertical");
transform.Translate(new Vector2(xPos, yPos) * aimSpeed * Time.fixedDeltaTime);
if (GameManager.instance.IsRacing)
{
if (playerController.GetButton("AButton") && canThrowCoconut)
{
ThrowCoconut();
Hud.instance.cocoFills[player.playerId].gameObject.SetActive(true);
Hud.instance.cocoFills[player.playerId].fillAmount = 0;
}
//if (playerController.GetButton("BButton"))
//{
// Debug.LogError("B !!!");
// GameManager.instance.OctoHorses[0].canBreathAgain = true;
// GameManager.instance.OctoHorses[0].ActiveSecondBreath();
//}
}
}
void Update()
{
for (int i = 0; i < popUps.Length; i++)
{
if (i == popUpIndex)
{
popUps[popUpIndex].SetActive(true);
}
else
{
popUps[popUpIndex].SetActive(false);
}
}
switch (popUpIndex)
{
case 0: // move vertically
vertical1 = Mathf.Abs(playerController1.GetAxis("Move Vertical")) > 0f;
//checkPlayerVerticalMove(playerController1.GetButtonDown("Move Vertical"), isForward1);
break;
case 1: // move horizonally
break;
case 2: // rotate left
break;
case 3: // rotate right
break;
case 4: // jump
player1.GetComponent <PlayerController>().jumpForce = originalJumpForce;
player2.GetComponent <PlayerController>().jumpForce = originalJumpForce;
break;
case 5: // collect fruit
break;
case 6: // shoot light ball
break;
}
if (popUpIndex == 0) /** move forward / back **/
{
bool player1Moved = false;
bool player2Moved = false;
if (player1.GetComponent <PlayerController>().getGamePadController().GetButtonDown("Move Vertical"))
{
player1Moved = true;
}
if (player2.GetComponent <PlayerController>().getGamePadController().GetButtonDown("Move Vertical"))
{
player2Moved = true;
}
if (player1Moved && player2Moved)/**both players have moved**/
{
popUpIndex++;
}
}
else if (popUpIndex == 1) /***jump***/
{
bool player1Jumped = false;
bool player2Jumped = false;
if (player1.GetComponent <PlayerController>().getGamePadController().GetButtonDown("Move Vertical"))
{
player1Jumped = true;
}
if (player2.GetComponent <PlayerController>().getGamePadController().GetButtonDown("Move Vertical"))
{
player2Jumped = true;
}
if (player1Jumped && player2Jumped)/**both players have jumped**/
{
popUpIndex++;
}
}
else if (popUpIndex == 2) /**flip camera**/
{
bool player1CamFlip = false;
bool player2CamFlip = false;
if (player1.GetComponent <PlayerController>().getGamePadController().GetButtonDown("Camera Flip"))
{
player1CamFlip = true;
}
if (player2.GetComponent <PlayerController>().getGamePadController().GetButtonDown("Camera Flip"))
{
player2CamFlip = true;
}
if (player1CamFlip && player2CamFlip)/**both players have flipped camera**/
{
popUpIndex++;
}
}
else if (popUpIndex == 3) /**get fruit**/
{
bool player1GetFruit = false;
bool player2GetFruit = false;
if (player1.GetComponent <PlayerLogic>().getFruitCounter() == 1)
{
player1GetFruit = true;
}
if (player2.GetComponent <PlayerLogic>().getFruitCounter() == 1)
{
player2GetFruit = true;
}
if (player1GetFruit && player2GetFruit)/**both players have gotten 1 fruit**/
{
popUpIndex++;
}
}
else if (popUpIndex == 4) /***shoot light ball***/
{
bool player1ShotBall = false;
bool player2ShotBall = false;
if (player1.GetComponent <SpawnLightOrb>().isShooting())
{
player1ShotBall = true;
}
if (player2.GetComponent <SpawnLightOrb>().isShooting())
{
player2ShotBall = true;
}
if (player1ShotBall && player2ShotBall)/**both players have thrown light ball**/
{
popUpIndex++;
}
}
else if (popUpIndex == 5)
{
if (false)/**shake off the witch**/
{
popUpIndex++;
}
}
}
public float GetAxis(Axis axis)
{
return(_player.GetAxis(axis.ToString()));
}
private void Update()
{
Rewired.Player rewiredPlayer = Rewired.ReInput.players.GetPlayer(kRewiredPlayerId);
if (_scaredTimer > 0)
{
_scaredTimer -= Time.deltaTime;
_characterMovement.MoveVector = Vector3.zero;
_isSneaking = false;
_characterMovement.MoveSpeedMultiplier = 0.0f;
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.Idle;
_playerAnimation.CurrentLocomotionSpeed = 0.0f;
}
else
{
float horizontalAxis = rewiredPlayer.GetAxis(RewiredConsts.Action.MoveHorizontal);
float verticalAxis = rewiredPlayer.GetAxis(RewiredConsts.Action.MoveVertical);
Vector3 horizontalVector = Camera.main.transform.right.WithY(0).normalized *horizontalAxis;
Vector3 verticalVector = Camera.main.transform.forward.WithY(0).normalized *verticalAxis;
_characterMovement.MoveVector = horizontalVector + verticalVector;
_isSneaking = rewiredPlayer.GetButton(RewiredConsts.Action.Sneak);
_characterMovement.MoveSpeedMultiplier = _isSneaking ? 0.5f : 1.0f;
if (_objectHolder.IsHoldingObject)
{
_characterMovement.MoveSpeedMultiplier *= 0.8f;
}
if (_characterMovement.CurrentVelocity.magnitude > 0.01f)
{
if (_isSneaking)
{
if (_objectHolder.IsHoldingObject)
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.SneakCarry;
}
else
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.Sneak;
}
}
else
{
if (_objectHolder.IsHoldingObject)
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.JogCarry;
}
else
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.Jog;
}
}
_playerAnimation.CurrentLocomotionSpeed = _characterMovement.CurrentVelocity.magnitude;
}
else
{
if (_isSneaking)
{
_playerAnimation.CurrentLocomotionSpeed = 0;
if (_objectHolder.IsHoldingObject)
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.SneakCarry;
}
else
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.Sneak;
}
}
else
{
_playerAnimation.CurrentLocomotionSpeed = 1;
if (_objectHolder.IsHoldingObject)
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.IdleCarry;
}
else
{
_playerAnimation.CurrentLocomotionState = PlayerAnimatorController.LocomotionState.Idle;
}
}
}
// Contextual interact
if (rewiredPlayer.GetButtonDown(RewiredConsts.Action.Interact))
{
// Interact with something
if (_interactionController.ClosestInteractable != null)
{
Interactable interactable = _interactionController.ClosestInteractable;
interactable.TriggerInteraction();
InteractWithObject(interactable);
}
// Drop or throw a held object
else if (_objectHolder.HeldObject != null)
{
HoldableObject heldObject = _objectHolder.HeldObject;
_objectHolder.DropObject();
if (_characterMovement.CurrentVelocity.magnitude > 0.5f)
{
Vector3 throwForce = (_characterMovement.CurrentVelocity + Vector3.up * 3) * 3;
heldObject.Rigidbody.AddForce(throwForce, ForceMode.VelocityChange);
heldObject.gameObject.AddComponent <SanityRestoreInWater>();
}
}
}
// Scream into or uncork a held bottle
if (rewiredPlayer.GetButtonDown(RewiredConsts.Action.Scream))
{
if (_objectHolder.IsHoldingObject)
{
ReleaseBottleScream();
}
}
}
}
public override void FixedUpdate()
{
TopActionButton.Press();
LeftActionButton.Press();
Set(input.GetAxis("Horizontal"), input.GetAxis("Vertical"));
}
private void JetPack()
{
jetpackViz.SetActive(true);
if (isFlying)
{
fire1.SetActive(true);
fire2.SetActive(true);
if (rewiredPlayer.GetButton(RewiredConsts.Action.Jump) && jetpackForce > 0)
{
GetComponentInChildren <Animator>().enabled = false;
jetpackForce -= Time.deltaTime;
if (currentJetpackForce < 1)
{
currentJetpackForce += Time.deltaTime * 10.0f;
}
else
{
currentJetpackForce = 1.0f;
}
}
if (jetpackForce < 0 && currentJetpackForce > 0)
{
currentJetpackForce -= Time.deltaTime;
}
if (!rewiredPlayer.GetButton(RewiredConsts.Action.Jump))
{
if (currentJetpackForce > 0)
{
currentJetpackForce -= Time.deltaTime;
}
else
{
currentJetpackForce = 0;
}
if (jetpackForce < delayJetpack)
{
jetpackForce = delayJetpack;
}
else
{
jetpackForce = delayJetpack;
}
isFlying = false;
}
if (currentJetpackForce > 0)
{
moveVec = Vector3.up;
if (CameraManager.Instance.cameraState == CameraState.SIDE_SCROLLER)
{
if (rewiredPlayer.GetAxis(RewiredConsts.Action.MoveRight) > 0)
{
transform.Translate(new Vector3(0, 0, 1) * moveSpeed * Time.deltaTime);
}
else if (rewiredPlayer.GetAxis(RewiredConsts.Action.MoveRight) < 0)
{
transform.Translate(new Vector3(0, 0, 1) * moveSpeed * Time.deltaTime);
}
}
if (CameraManager.Instance.cameraState == CameraState.THIRD_PERSON)
{
moveVec += transform.right * rewiredPlayer.GetAxis(RewiredConsts.Action.MoveRight);
moveVec += transform.forward * rewiredPlayer.GetAxis(RewiredConsts.Action.MoveForward);
}
cc.Move((moveVec * moveSpeed * Time.deltaTime - cc.velocity * Time.deltaTime) * currentJetpackForce);
}
}
else
{
fire1.SetActive(false);
fire2.SetActive(false);
GetComponentInChildren <Animator>().enabled = true;
}
}
public float GetAxis(string Axis)
{
return(player.GetAxis(Axis));
}
public void UpdateKeyboard()
{
if (StopInput)
{
Direction = Vector2.zero;
Jump = false;
Sprint = false;
DodgeLeft = false;
DodgeRight = false;
return;
}
// We get our horizontal/vertical inputs as integers so we don't have to deal with floating point value errors
Direction.x = (int)(Sprint ? 0 : Inputs.GetAxis("Horizontal"));
Direction.y = (int)(Sprint ? 1 : Inputs.GetAxis("Vertical"));
Jump = Inputs.GetButtonDown("Jump");
HoldJump = Inputs.GetButton("Jump");
if (Inputs.GetButtonDoublePressDown("Vertical"))
{
Sprint = true;
}
else if (Inputs.GetButtonUp("Vertical") || Jump || AnyAttack)
{
Sprint = false;
}
// Reset the dodge bools before we use it
DodgeLeft = false;
DodgeRight = false;
if (Settings.GameSettingsManager.Instance.ControlSettings.Save.ControlDoubleTapDodge != 0)
{
DodgeLeft = Inputs.GetNegativeButtonDoublePressDown("Horizontal") && !DodgeRight;
DodgeRight = Inputs.GetButtonDoublePressDown("Horizontal") && !DodgeLeft;
}
else
{
DodgeLeft = Direction.x < 0 && Direction.y == 0 && Jump && !DodgeRight;
DodgeRight = Direction.x > 0 && Direction.y == 0 && Jump && !DodgeLeft;
}
if (Inputs.GetButtonDown("Camera Side"))
{
CameraSide = !CameraSide;
}
// Select Weapon
if (Inputs.GetButtonDown("Weapon 1"))
{
WeaponNumber = 0;
}
if (Inputs.GetButtonDown("Weapon 2"))
{
WeaponNumber = 1;
}
if (Inputs.GetButtonDown("Weapon 3"))
{
WeaponNumber = 2;
}
// Scroll Weapon
if (Inputs.GetAxis("Scroll Weapon") * MouseScrollSpeed >= 1)
{
WeaponNumber--;
}
else if (Inputs.GetAxis("Scroll Weapon") * MouseScrollSpeed <= -1)
{
WeaponNumber++;
}
// Infinite scroll allows us to go to the first weapon if we attempt to scroll down on the last weapon
if (Settings.GameSettingsManager.Instance.ControlSettings.Save.ControlWeaponSwitchInfiniteScroll != 0)
{
// Just reset the number
WeaponNumber = WeaponNumber > 2 ? 0 : WeaponNumber < 0 ? 2 : WeaponNumber;
}
WeaponNumber = Mathf.Clamp(WeaponNumber, 0, 2);
}
private void FixedUpdate()
{
// Default actions.
if (playerInput.GetButton("Jump"))
{
movement.JumpHold();
}
else
{
movement.TryJumpRelease();
}
if (playerInput.GetButton("Accelerate"))
{
movement.DebugMove();
}
if (playerInput.GetButtonDown("Flip Over"))
{
movement.FlipOver();
}
// Switch control scheme
if (playerInput.GetButton("Set Controls 1"))
{
controlMode = ControlMode.SkidAndCarve;
}
else if (playerInput.GetButton("Set Controls 2"))
{
controlMode = ControlMode.FrontBack;
}
else if (playerInput.GetButton("Set Controls 3"))
{
controlMode = ControlMode.TurnAndLean;
}
else if (playerInput.GetButton("Set Controls 4"))
{
controlMode = ControlMode.FrontBackLocal;
}
Vector3 leftStickInputSpace = new Vector3(playerInput.GetAxis("Left Stick Horizontal"), 0.0f, playerInput.GetAxis("Left Stick Vertical"));
Vector3 rightStickInputSpace = new Vector3(playerInput.GetAxis("Right Stick Horizontal"), 0.0f, playerInput.GetAxis("Right Stick Vertical"));
switch (controlMode)
{
case ControlMode.BasicSteer:
UpdateBasicSteer(leftStickInputSpace, rightStickInputSpace);
break;
case ControlMode.SkidAndCarve:
UpdateSkidAndCarve(leftStickInputSpace, rightStickInputSpace);
break;
case ControlMode.SlalomAndCarve:
UpdateSlalomAndCarve(leftStickInputSpace, rightStickInputSpace);
break;
case ControlMode.TurnAndLean:
UpdateTurnAndLean(leftStickInputSpace, rightStickInputSpace);
break;
case ControlMode.Warthog:
UpdateWarthog(leftStickInputSpace, rightStickInputSpace);
break;
case ControlMode.FrontBack:
UpdateFrontBackSteering(leftStickInputSpace, rightStickInputSpace);
break;
case ControlMode.FrontBackLocal:
UpdateFrontBackSteering(leftStickInputSpace, rightStickInputSpace, false);
break;
}
}
void FixedUpdate()
{
if (Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.Escape))
{
startupAnimation.gameObject.SetActive(false);
transform.GetChild(0).gameObject.SetActive(true);
}
if (!transform.GetChild(0).gameObject.activeSelf)
{
return;
}
float currentSpeed = speedCurve.Evaluate(currentSpeedNormalized) * speedMultiplier;
Vector3 targetPosition = transform.position + transform.forward * Time.fixedDeltaTime * currentSpeed;
if (keyboardMode)
{
aimDirection = Vector2.zero;
if (Input.GetKey(KeyCode.W))
{
aimDirection.y += pitchSpeed;
}
if (Input.GetKey(KeyCode.S))
{
aimDirection.y -= pitchSpeed;
}
if (Input.GetKey(KeyCode.D))
{
aimDirection.x += yawSpeed;
}
if (Input.GetKey(KeyCode.A))
{
aimDirection.x -= yawSpeed;
}
}
else
{
aimDirection = Vector2.Lerp(aimDirection, Vector2.zero, Time.deltaTime * 2f);
if (mouseMode)
{
Vector2 mouseDelta = new Vector2(Input.GetAxis("Mouse X") * yawSpeed, -Input.GetAxis("Mouse Y") * pitchSpeed);
aimDirection += mouseDelta * mouseSensitivity;
}
else
{
Vector2 gamepadInput = new Vector2(player.GetAxis("MoveHorizontal") * yawSpeed, player.GetAxis("MoveVertical") * pitchSpeed);
if (transform.position.y > CombatBalancing.yRange)
{
gamepadInput.y = 10 + 5f * Mathf.Abs(transform.position.y - CombatBalancing.yRange);
}
else if (transform.position.y < -CombatBalancing.yRange)
{
gamepadInput.y = -10 - 5f * Mathf.Abs(CombatBalancing.yRange + transform.position.y);
}
aimDirection += gamepadInput * joystickSensitivity;
}
}
EnergySystem.instance.MoveShip(aimDirection.magnitude);
smoothAim = Vector2.Lerp(smoothAim, aimDirection, Time.deltaTime * aimAcceleration);
targetPosition += transform.TransformDirection(smoothAim) * Time.fixedDeltaTime * aimMoveAssistFactor;
ClampAimDirection();
UpdateAimReticle();
HandleBoost();
Vector3 targetRotation = Vector3.Scale(transform.eulerAngles, new Vector3(1, 1, 0)) + new Vector3(smoothAim.y, smoothAim.x, 0f) * Time.fixedDeltaTime;
if (Mathf.DeltaAngle(targetRotation.x, 0) > maxPitchAngle)
{
targetRotation.x = -maxPitchAngle;
}
else if (Mathf.DeltaAngle(targetRotation.x, 0) < -maxPitchAngle)
{
targetRotation.x = maxPitchAngle;
}
// if (transform.position.y > CombatBalancing.yRange)
// {
// targetPosition.y = CombatBalancing.yRange;
// }
// else if(transform.position.y < -CombatBalancing.yRange)
// {
// targetPosition.y = -CombatBalancing.yRange;
// }
// if (transform.position.y > CombatBalancing.yRange)
// {
// Debug.Log(targetRotation.x + " " + (transform.position.y - CombatBalancing.yRange));
// targetRotation.x = Mathf.Min(targetRotation.x, (transform.position.y - CombatBalancing.yRange));
// }
// else if(transform.position.y < -CombatBalancing.yRange && targetRotation.x > 0f)
// {
// targetRotation.x = 0f;
// }
if (dodgeRollTimer < dodgeRollDuration)
{
dodgeRollTimer += Time.fixedDeltaTime;
float dodgeRollTimeValue = dodgeRollCurve.Evaluate(dodgeRollTimer / dodgeRollDuration);
Quaternion dodgeRollRot = Quaternion.Euler(Vector3.forward * Mathf.LerpUnclamped(0f, 360f, dodgeRollTimeValue));
playerModel.localRotation = Quaternion.Lerp(playerModel.localRotation, dodgeRollRot, Time.fixedDeltaTime * (5f + 100f * dodgeRollTimer / dodgeRollDuration));
}
else
{
playerModel.localRotation = Quaternion.Lerp(playerModel.localRotation, Quaternion.Euler(Vector3.forward * smoothAim.x * -0.5f), Time.fixedDeltaTime * 5f);
}
rBody.MoveRotation(Quaternion.Euler(targetRotation));
rBody.MovePosition(targetPosition);
// thruster.rotation = Quaternion.Lerp(thruster.rotation, transform.rotation, Time.deltaTime * 2f);
}
