private Vector2 GetGroundMovement(PlayerInputState inputs)
{
float x = inputs.x;
float y = inputs.y;
return(new Vector2(x * World.instance.GroundMovementSpeed, y * World.instance.AirMovementSpeed));
}
public void Construct(Selection selection, Image pointer, PlayerInputState iS, MenuItemFactory menuItemFactory)
{
_pointer = pointer;
_selection = selection;
_inputState = iS;
_actionMenuFactory = menuItemFactory;
}
public void OnPlayer2Move(InputAction.CallbackContext context)
{
Entity player = player2Entity;
PlayerInputState playerInputState = EntityManager.GetComponentData <PlayerInputState>(player);
playerInputState.Move = context.ReadValue <Vector2>();
EntityManager.SetComponentData(player, playerInputState);
}
private void CheckChanges(PlayerInputState type)
{
if (_clickState != type)
{
_clickState = type;
OnChangeClickState?.Invoke(_clickState);
}
}
public PlayerInputHandler(IActionMenu aM, PlayerInputState inputState, GameState g)
{
_actionMenu = aM;
_gameState = g;
_inputState = inputState;
_inputState.IsEscapeAction = _gameState.NextPlayer;
}
ActionMenuState(IActionMenu aM, BaseUnit unit, PlayerInputState iS)
{
_actionMenu = aM;
_unit = unit;
_inputState = iS;
_inputState.IsCancelAction = Cancel;
_inputState.IsConfirmedAction = Confirm;
}
public void OnPlayer2Shoot(InputAction.CallbackContext context)
{
Entity player = player2Entity;
PlayerInputState playerInputState = EntityManager.GetComponentData <PlayerInputState>(player);
playerInputState.Firing = context.ReadValue <float>();
EntityManager.SetComponentData(player, playerInputState);
}
FireState(CanFire cf, Selection selection, PlayerInputState iS, MapEntetiesManager entetiesManager)
{
_selection = selection;
_fireComponent = cf;
_entetiesManager = entetiesManager;
iS.IsCancelAction = Cancel;
iS.IsConfirmedAction = Confirm;
}
protected override void DoAwake()
{
titleScreenState = this.stateMachine.GetState <PlayerInputTitleScreenState>();
defaultState = this.stateMachine.GetState <PlayerInputDefaultState>();
pauseMenuState = this.stateMachine.GetState <PlayerInputPauseMenuState>();
player = player ?? ReInput.players.GetPlayer(playerId);
gameStateMachine = gameStateMachine ?? FindObjectOfType <GameStateTitleScreen>().GetComponent <StateMachine>();
}
bool ReadFire(ref PlayerInputState result)
{
if (Input.GetKeyDown(KeyCode.Mouse0))
{
result.buttonPressedFire = true;
return(true);
}
return(false);
}
bool ReadJump(ref PlayerInputState result)
{
if (Input.GetKeyDown(KeyCode.Space))
{
result.buttonPressedJump = true;
return(true);
}
return(false);
}
bool ReadPlayerInputStateInto(ref PlayerInputState result)
{
bool didReadAny = false;
didReadAny |= ReadJump(ref result);
didReadAny |= ReadFire(ref result);
didReadAny |= ReadMoveAxes(ref result);
didReadAny |= ReadMouseMoveAxes(ref result);
return(didReadAny);
}
private void HandleControllerProcessing()
{
PlayerInputState inputState = new PlayerInputState();
Vector2 _moveVector = moveAction.ReadValue <Vector2>();
inputState.MoveAxisRight = _moveVector.x;
inputState.MoveAxisForward = _moveVector.y;
inputState.CameraRotation = cameraController.GetCameraRotation();
kinController.SetPlayerInput(ref inputState);
}
bool ReadMoveAxes(ref PlayerInputState result)
{
var moveAxes = InputHelper.GetMoveAxes();
if (moveAxes != Vector2.zero)
{
result.moveAxes = moveAxes;
return(true);
}
return(false);
}
public void HandleRecall(PlayerInputState input, bool recalling)
{
if (!recalling)
{
return;
}
Receiver foreignReceiver = null;
if (CanRecall(TransmissionType.Jump, input.JumpDown))
{
foreignReceiver = foreignReceivers[TransmissionType.Jump];
}
if (CanRecall(TransmissionType.Move, input.TransmitMove))
{
foreignReceiver = foreignReceivers[TransmissionType.Move];
}
if (foreignReceiver)
{
if (foreignReceiver.ActionBank.Count() > 0)
{
//Pull the transmission from the foreign receiver
TransmissionType type = foreignReceiver.ActionBank.GetFirst();
if (MyReceiver.CanReceive(type) && MyReceiver.ReceiveTransmission(type))
{
foreignReceiver.ActionBank.RemoveAction(type);
foreignReceivers.Remove(type);
Animator anim = foreignReceiver.GetComponentInParent <Animator>();
if (anim)
{
anim.speed /= 3f;
}
//Grant the appropriate action controller of the receive to the sender.
if (type == TransmissionType.Jump)
{
GameController.S.jumpText.color = Color.green;
InputManager.JumpingController = InputManager.PlayerMovementController;
}
if (type == TransmissionType.Move)
{
GameController.S.moveText.color = Color.green;
InputManager.MovingController.StopMovement();
InputManager.MovingController = InputManager.PlayerMovementController;
}
}
}
}
}
public PlayerState(PlayerState playerState, PlayerInputState inputs)
{
stateData = new PlayerStateData();
stateData.Collisions = playerState.stateData.Collisions;
stateData.FrameState = playerState.stateData.FrameState;
stateData.velocity = playerState.stateData.velocity;
_currentDirection = playerState.GetDirection();
HP = playerState.HP;
nextActionDelay = playerState.nextActionDelay;
inputState = inputs;
}
void Constructor(TileEntity.Factory factory, GameState gS, MapEntetiesManager me, PlayerInputState ps, MapManager mp, PathDrower pathDrower)
{
_facTest = factory;
_gameState = gS;
_entetieManager = me;
_playerInputState = ps;
_pathDrower = pathDrower;
_currentMap = mp;
ReAddActions();
}
void ApplyInput(PlayerInputState input)
{
transform.Rotate(Vector3.up, input.lookHorizontalValue * horizontalRotateSpeed * Time.fixedDeltaTime, Space.Self);
cameraPosition.transform.Rotate(Vector3.right, input.lookVerticalValue * -verticalRotateSpeed * Time.fixedDeltaTime, Space.Self);
float frictionFactor;
if (_controller.isGrounded)
{
if (input.jumpPressed)
{
_currentVelocity.y = 3.0f;
}
}
else
{
}
_currentVelocity.y -= 5.0f * Time.fixedDeltaTime;
_currentVelocity.x = 0;
_currentVelocity.z = 0;
_currentVelocity += transform.forward * input.verticalValue + transform.right * input.horizontalValue;
float horizontalMagnitude = Mathf.Sqrt(_currentVelocity.x * _currentVelocity.x) + (_currentVelocity.z * _currentVelocity.z);
if (horizontalMagnitude > speed)
{
_currentVelocity.x = _currentVelocity.x / horizontalMagnitude * speed;
_currentVelocity.z = _currentVelocity.z / horizontalMagnitude * speed;
}
var result = _controller.Move(_currentVelocity * Time.fixedDeltaTime * speed);
if ((result & CollisionFlags.Below) != 0)
{
if (_currentVelocity.y < 0)
{
_currentVelocity.y = 0.0f;
}
}
//-- shooting
if (input.shootingPressed)
{
Shoot(input);
}
}
UnitMoveState(Player p, BaseUnit baseUnit, MapManager mP, MapHighlighter mH, PlayerInputState pS, Selection selection, PathDrower pathDrower)
{
_player = p;
_pathDrower = pathDrower;
_baseUnit = baseUnit;
_mapHighlighter = mH;
_mapManagaer = mP;
_playerInputState = pS;
_selection = selection;
_playerInputState.IsCancelAction += Cancel;
_playerInputState.IsConfirmedAction = Confirm;
}
//Only called if we are broadcasting
public void HandleBroadcast(PlayerInputState input, bool broadcasting)
{
if (!broadcasting)
{
if (tPointer.activeSelf)
{
tPointer.SetActive(false);
}
transmittingSound.Stop();
return;
}
if (!transmittingSound.isPlaying) //<<OAKWOOD ADDED>>
{
transmittingSound.Play();
}
//<<OAKWOOD ADDED>>
// Handle targeting visual aid
// Should disappear when player is not actively aiming with stick
var buffer = 0.2f;
if (Mathf.Abs(input.Horizontal) >= buffer || Mathf.Abs(input.Vertical) >= buffer)
{
tPointer.SetActive(true);
var targetAngle = (Mathf.Atan2(input.Vertical, input.Horizontal) * Mathf.Rad2Deg) - 90;
tPointer.transform.rotation = Quaternion.Slerp(tPointer.transform.rotation, Quaternion.Euler(0, 0, targetAngle), 10f * Time.deltaTime);
}
else
{
tPointer.SetActive(false);
}
Vector2 targetVector = new Vector2(input.Horizontal, input.Vertical).normalized *bulletSpeed;
if (input.JumpDown && CanTransmit(TransmissionType.Jump) && targetVector != new Vector2(0, 0))
{
ShootTransmissionBullet(TransmissionType.Jump, targetVector, tPointer.transform.rotation);
}
if (input.TransmitMove && CanTransmit(TransmissionType.Move) && targetVector != new Vector2(0, 0))
{
ShootTransmissionBullet(TransmissionType.Move, targetVector, tPointer.transform.rotation);
}
}
void ReadInputInto(InputEntity inputEntity)
{
var inputState = new PlayerInputState();
var didReadAny = ReadPlayerInputStateInto(ref inputState);
if (!didReadAny)
{
return;
}
var inputs = inputEntity.playerInputs.inputs;
//inputs.Clear(); // TEMP Past input records are never removed (yet), so we clear them here to prevent clutter.
var currentTick = game.currentTick.value;
inputs.Add(new PlayerInputRecord(currentTick, inputState));
inputEntity.ReplacePlayerInputs(inputs);
}
public static void Update(PlayerInputConfig playerInputConfig, PlayerInputState playerInputState)
{
var wasJumpRequested = playerInputState.platformerState.isJumpRequested;
playerInputState.platformerState.isJumpRequested = Input.GetKey(playerInputConfig.jumpCode);
foreach (var pair in playerInputConfig.directions)
{
if (Input.GetKeyDown(pair.key))
{
playerInputState.directions.AddFirst(pair.direction);
}
if (Input.GetKeyUp(pair.key))
{
playerInputState.directions.Remove(pair.direction);
}
}
var head = playerInputState.directions.First;
var oldDirection = playerInputState.platformerState.walkDirection;
playerInputState.platformerState.walkDirection = head == null ? PlatformerWalkDirection.None : head.Value;
}
void Shoot(PlayerInputState input)
{
Vector3 origin = cameraPosition.position;
Vector3 direction = cameraPosition.forward;
if (isServer && input.serverFrame != ServerSimulation.frameNumber)
{
ServerSimulation.Rewind(input.networkTime - _currentLatency);
}
RaycastHit hit;
if (Physics.Raycast(origin, direction, out hit, 1000))
{
var instance = Instantiate(hitPrefab, hit.collider.transform, false);
instance.transform.position = hit.point;
instance.transform.forward = hit.normal;
}
Debug.DrawRay(origin, direction * 1000);
Debug.Break();
}
public void Init()
{
anim = this.GetComponent <FGAnimator>();
anim.Init();
anim.Play("Idle");
_currentAttackAnimation = "";
_inputState = this.GetComponent <PlayerInputState>();
_inputState.Init();
_currentState = new PlayerState(startingDirection);
_lastState = new PlayerState(startingDirection);
entityPhysics = this.GetComponent <WorldState2D>();
entityPhysics.Init(this.GetComponent <RectTransform>().anchoredPosition);
hurtbox = new Hurtbox(this.GetComponent <RectTransform>());
entityPhysics.AddCollider(hurtbox);
//entityPhysics = new Physics2D(this.GetComponent<RectTransform>().anchoredPosition);
//collision.SetPhysics(entityPhysics);
initialized = true;
}
public MessageHandler RegisterNetwork(MessageHandler send, PlatformerCharacterConfig config, string guid, float trustDistance)
{
this.trustDistance = trustDistance;
platformerInputState = new PlatformerCharacterInputState();
platformerInputState.isJumpRequested = false;
platformerInputState.walkDirection = PlatformerWalkDirection.None;
playerInputState = new PlayerInputState(platformerInputState);
inputMessage.playerGuid = guid;
inputMessage.state = playerInputState.platformerState;
this.platformerConfig = config;
this.networkSend = send;
return((opCode, message) => {
if (opCode == OpCode.PLAYER_POSITION)
{
UpdateForServerPosition(((PositionMessage)message).position);
}
else if (opCode == OpCode.PLAYER_INPUT)
{
UpdateForServerPosition(((PlayerInputMessage)message).position.toVector());
}
return 1;
});
}
/// <summary>
/// At update, we check the various commands and send them to the player.
/// </summary>
void Update()
{
PlayerInputState input = GetInputState();
//Pass input to relevant controllers
if (!PlayerMovementController.advancedMovementState.broadcasting)
{
MovingController.Move(input.Horizontal, input.Vertical);
if (!PlayerMovementController.advancedMovementState.recalling)
{
JumpingController.Jump(input.JumpDown, input.JumpUp);
}
}
PlayerMovementController.Recall(input.Recall);
Transmitter.HandleRecall(input, PlayerMovementController.advancedMovementState.recalling);
PlayerMovementController.Broadcast(input.Broadcast);
Transmitter.HandleBroadcast(input, PlayerMovementController.advancedMovementState.broadcasting);
if (Input.GetButtonDown("Help"))
{
if (GameController.S.controlsText.enabled)
{
GameController.S.controlsText.enabled = false;
GameController.S.helpText.enabled = true;
}
else
{
GameController.S.controlsText.enabled = true;
GameController.S.helpText.enabled = false;
}
}
}
public PlayerInputRecord(ulong timestamp, PlayerInputState inputState)
{
this.timestamp = timestamp;
this.inputState = inputState;
}
/// <summary>
/// Prompt Sheep player to select piece to move.
/// </summary>
/// <param name="player">The player to be prompted.</param>
/// <returns>The selected piece to be moved. Returns null if player pressed the escape key.</returns>
private Piece PromptSheepPlayerToSelectPiece(SheepPlayer player)
{
ConsoleKey userInput;
Direction directionInput;
Piece piece;
int currentPieceIndex = 0;
PlayerInputState = PlayerInputState.LeftAndRight;
CallToAction = "Select the piece you wish to move.";
// Only leaves loop on player instruction
while (true)
{
RefreshUI();
piece = player.Pieces[currentPieceIndex];
HighlightBoardSquare(piece.BoardSquare);
userInput = GetPlayerInputKey();
// If player presses enter...
if (userInput == ConsoleKey.Enter)
{
// ...check if selected piece has any possible move. If not...
if (!Board.GetPieceHasPossibleMoves(player, piece))
{
// ...warn the player...
AddLogMessage($"{CurrentPlayerName} you can't select that piece because it doens't have any possible moves.");
// ...refresh the UI and continue
RefreshUI();
continue;
}
// ...refresh the UI...
RefreshUI();
// ...and leave loop.
break;
}
// If the player presses escape...
else if (userInput == ConsoleKey.Escape)
{
// ...set return object to null...
piece = null;
// ...set colors to default...
SetConsoleColorToDefault();
// ...and break.
break;
}
directionInput = GetDirection(userInput);
// Left and right to move through the pieces
if (directionInput == Direction.Left || directionInput == Direction.Right)
{
switch (directionInput)
{
case Direction.Left:
currentPieceIndex--;
break;
case Direction.Right:
currentPieceIndex++;
break;
}
// If the index would be outside of the array.
if (currentPieceIndex < 0)
{
currentPieceIndex = player.Pieces.Length - 1;
}
else if (currentPieceIndex >= player.Pieces.Length)
{
currentPieceIndex = 0;
}
}
}
return(piece);
}
void CreateInputState(ref PlayerInputState state)
{
state.inputID = _inputIdMax++;
state.networkTime = Network.time;
state.serverFrame = ServerSimulation.frameNumber;
}
public PlayerInputEvent(OpenPlayer player, PlayerInput input, PlayerInputState state) : base(player)
{
Input = input;
State = state;
}