private void MoveTo(DirectionButton dir, Vector3 destPosition)
{
m_animationController.UpdateAnimation(_positionDiff, _lastPositionDiff, _isMoving);
if (!_isMoving || (destPosition == transform.position))
{
ClampCurrentPosition();
return;
}
if (_isMoving && (dir != DirectionButton.NONE) && (dir == _lastCollisionDir))
{
ClampCurrentPosition();
if (!(_lastCollidedObject is null))
{
onCollision.Invoke(_lastCollidedObject);
}
return;
}
if (_isMoving)
{
_lastCollidedObject = null;
_lastCollisionDir = DirectionButton.NONE;
}
var tr = transform;
tr.position = Vector3.MoveTowards(tr.position, destPosition, Time.deltaTime * m_Speed);
tr.rotation = new Quaternion(0, 0, 0, 0);
}
IEnumerator PlayerAction(Player player, DirectionButton direction)
{
var lastPos = player.data.position;
CallDirection(player, direction.GetDirection());
var cell = board.GetCell(player.data.position);
if (player.data.position == Vector2Int.zero)
{
if (player.data.heldBitcoins < 3)
{
++player.data.heldBitcoins;
audioSource.PlayOneShot(gotBitcoinSound);
}
player.data.position = lastPos;
}
else if (player.data.position == player.data.startPosition)
{
player.data.baseBitcoins += player.data.heldBitcoins;
player.data.heldBitcoins = 0;
}
else if ((cell & Board.Cell.AnyPlayer) != 0)
{
var other = GetPlayerAtCell(cell);
Steal(player, other);
player.data.position = lastPos;
}
yield return(new WaitForSeconds(moveDelay));
}
void OnCollisionEnter2D(Collision2D col)
{
_lastCollidedObject = col;
_lastCollisionDir = _lastDirection;
ClampCurrentPosition();
onCollision.Invoke(col);
}
private void MovementUpdate(DirectionButton dir)
{
if (!_isMoving)
{
_currentTilesToMove = m_TilesPerStep;
}
Move(dir, _currentTilesToMove);
}
public void Move(DirectionButton dir, int tiles)
{
_currentTilesToMove = tiles;
Vector3 destPosition = CalculateDestinationPosition(
transform.position, dir, tiles
);
MoveTo(dir, destPosition);
}
void OnCollisionStay2D(Collision2D col)
{
_lastCollidedObject = col;
_lastCollisionDir = _lastDirection;
if (_isMoving)
{
onCollision.Invoke(col);
}
StopMoving();
}
public void TriggerDirectionButton(DirectionButton dir)
{
if (!CanMove() && IsMoving())
{
StopMoving();
}
if (CanMove())
{
MovementUpdate(dir);
}
}
private void FixedUpdate()
{
if (!CanMove() && IsMoving())
{
StopMoving();
}
DirectionButton dir = LegacyInputManager.GetPressedDirectionButton();
if (!IsMoving() && dir == DirectionButton.NONE)
{
return;
}
TriggerDirectionButton(dir);
}
private void SetDirectionIndicator(bool isReverse)
{
if (isReverse)
{
BackwardArrow.Visibility = Visibility.Collapsed;
ForwardArrow.Visibility = Visibility.Visible;
ToolTipService.SetToolTip(DirectionButton, "Forwards");
DirectionButton.SetValue(AutomationProperties.NameProperty, "Set playback direction to forwards");
}
else
{
BackwardArrow.Visibility = Visibility.Visible;
ForwardArrow.Visibility = Visibility.Collapsed;
ToolTipService.SetToolTip(DirectionButton, "Reverse");
DirectionButton.SetValue(AutomationProperties.NameProperty, "Set playback direction to reverse");
}
}
IEnumerator PlayerAction(Player player, DirectionButton direction)
{
var lastPos = player.data.position;
CallDirection(player, direction.GetDirection());
var cell = board.GetCell(player.data.position);
Debug.Log(cell);
if (player.data.position == Vector2Int.zero)
{
Debug.Log($"{player.data.playerName} is mining!");
if (player.data.heldBitcoins < 3)
{
++player.data.heldBitcoins;
audioSource.PlayOneShot(gotBitcoinSound);
}
player.data.position = lastPos;
}
else if (player.data.position == player.data.startPosition)
{
Debug.Log($"{player.data.playerName} is storing!");
player.data.baseBitcoins += player.data.heldBitcoins;
player.data.heldBitcoins = 0;
}
else if (GetPlayer(player.data.position, player, out Player other))
{
Debug.Log(
$"{player.data.playerName} is stealing from " +
$"{other.data.playerName}!"
);
Steal(player, other);
player.data.position = lastPos;
}
yield return(new WaitForSeconds(moveDelay));
}
public static Vector2 GetDirectionButtonVector(DirectionButton dir)
{
switch (dir)
{
case DirectionButton.UP:
return(Vector2.up);
case DirectionButton.DOWN:
return(Vector2.down);
case DirectionButton.LEFT:
return(Vector2.left);
case DirectionButton.RIGHT:
return(Vector2.right);
default:
return(Vector2.zero);
}
}
void Update()
{
ActionButton action = LegacyInputManager.GetPressedActionButton();
DirectionButton dir = m_animationController.GetLastAnimationDirection();
Vector3 dirVector = LegacyInputManager.GetDirectionButtonVector(dir);
RaycastHit2D hit = CheckInteractableRaycast(dirVector);
if (!hit || !hit.collider || !hit.collider.gameObject.HasComponent <Interactable>())
{
Debug.DrawRay(transform.position, dirVector, Color.red);
Debug.DrawRay(transform.position, hit.point, Color.blue);
return;
}
Debug.DrawRay(transform.position, dirVector, Color.green);
Debug.DrawRay(transform.position, hit.point, Color.blue);
hit.collider.gameObject.GetComponent <Interactable>()
.Interact(new InteractionContext(dir, action, m_DialogManager));
}
private Vector3 CalculateDestinationPosition(Vector3 origin, DirectionButton dir, int tiles = 1)
{
if (_inputDelayCoolDown > 0)
{
_inputDelayCoolDown--;
}
if (_inputEnabled)
{
_destinationPosition = origin;
CalculateMovement(dir, tiles);
}
if (_isMoving)
{
if (origin == _destinationPosition)
{
// done moving in a tile
_isMoving = false;
_inputEnabled = true;
CalculateMovement(dir, tiles);
}
if (origin == _destinationPosition)
{
return(origin);
}
return(_destinationPosition);
}
_positionDiff.x = 0;
_positionDiff.y = 0;
_positionDiff.z = 0;
return(ClampPosition(origin));
}
public void UpdateAnimation(DirectionButton dir)
{
var pos = LegacyInputManager.GetDirectionButtonVector(dir);
UpdateAnimation(pos, pos);
}
public InteractionContext(DirectionButton direction, ActionButton action, DialogManager dialogManager)
{
this.direction = direction;
this.action = action;
this.dialogManager = dialogManager;
}
// Returns the calculated final destination vector
private void CalculateMovement(DirectionButton dir, int tiles = 1)
{
if (_inputDelayCoolDown > 0)
{
return;
}
if (dir == DirectionButton.NONE)
{
return;
}
float x = 0, y = 0, z = 0;
switch (dir)
{
case DirectionButton.UP:
{
y = tiles;
}
break;
case DirectionButton.RIGHT:
{
x = tiles;
}
break;
case DirectionButton.DOWN:
{
y = tiles * -1;
}
break;
case DirectionButton.LEFT:
{
x = tiles * -1;
}
break;
}
_lastPositionDiff.x = x;
_lastPositionDiff.y = y;
_lastPositionDiff.z = z;
if (_lastDirection != dir)
{
_inputDelayCoolDown = m_InputDelay;
_lastDirection = dir;
return;
}
_inputEnabled = false;
_isMoving = true;
_positionDiff.x = x;
_positionDiff.y = y;
_positionDiff.z = z;
_destinationPosition += _positionDiff;
_destinationPosition = ClampPosition(_destinationPosition);
}
