private void Update()
{
if (GameManager.Instance.StoppedPlaying)
{
return;
}
DrawHud();
var(playerX, playerY) = new Vector2(player.x, player.y).ToGrid().ToInt().Unpack();
var movementDirection = new Vector2Int((int)Input.GetAxisDown("Horizontal"), (int)Input.GetAxisDown("Vertical"));
var drillDirection = new Vector2Int((int)Input.GetAxis("Horizontal"), (int)Input.GetAxis("Vertical"));
// Constrain movement to only one axis, with priority for vertical movement
if (movementDirection.x != 0 && movementDirection.y != 0)
{
movementDirection.x = 0;
}
if (drillDirection.x != 0 && drillDirection.y != 0)
{
drillDirection.x = 0;
}
var desiredPosition = movementDirection.Add(playerX, playerY);
var desiredDrillDirection = drillDirection.Add(playerX, playerY);
var rangeCheck = desiredPosition.x >= 0 && desiredPosition.x < TilesHorizontal && desiredPosition.y >= 0 && desiredPosition.y < TilesVertical;
var movedThisFrame = false;
UpdateDrilling(ref playerX, ref playerY, ref rangeCheck, ref movedThisFrame, ref movementDirection, ref desiredPosition, ref drillDirection, ref desiredDrillDirection);
UpdateMovement(ref playerX, ref playerY, ref rangeCheck, ref movedThisFrame, ref movementDirection, ref desiredPosition);
UpdateGravity(ref playerX, ref playerY, ref rangeCheck, ref movementDirection, ref desiredPosition);
UpdateFuel(ref playerX, ref playerY);
UpdateTimers();
UpdateCamera();
PostUpdateChecks(ref playerY);
}
private void UpdateMovement(ref int playerX, ref int playerY, ref bool rangeCheck, ref bool movedThisFrame, ref Vector2Int movementDirection, ref Vector2Int desiredPosition)
{
if (movementDirection == Vector2Int.zero)
{
return;
}
if (movementDirection.x == -1)
{
player.Flip = false;
}
else if (movementDirection.x == 1)
{
player.Flip = true;
}
// If player can move
if (rangeCheck && tiles[desiredPosition.x, desiredPosition.y] == ObjectType.Empty && !movedThisFrame)
{
// Do the actual movement
player.Move(movementDirection.ToWorld().ToVec2());
tiles[playerX, playerY] = ObjectType.Empty;
tiles[desiredPosition.x, desiredPosition.y] = ObjectType.Player;
// Recalculate position
(playerX, playerY) = new Vector2(player.x, player.y).ToGrid().ToInt().Unpack();
desiredPosition = movementDirection.Add(playerX, playerY);
rangeCheck = desiredPosition.x >= 0 && desiredPosition.x < TilesHorizontal && desiredPosition.y >= 0 && desiredPosition.y < TilesVertical;
}
timeSinceLastMovement = 0f;
gravityTimeLeft = Settings.Instance.GravityFrequency;
}
private void BreakTile(ref Vector2Int desiredPosition, ref Vector2Int desiredDrillDirection, ref Vector2Int drillDirection, ref Vector2Int movementDirection, ref int playerX, ref int playerY, ref bool movedThisFrame, ref bool rangeCheck)
{
Score += Settings.Instance.Tiles.TypeToTile[tiles[desiredDrillDirection.x, desiredDrillDirection.y]].ScoreAmount;
fuelBar.FuelAmount += Settings.Instance.Tiles.TypeToTile[tiles[desiredDrillDirection.x, desiredDrillDirection.y]].FuelAmount;
player.Move(drillDirection.ToWorld().ToVec2());
tiles[playerX, playerY] = ObjectType.Empty;
var minedTile = tiles[desiredDrillDirection.x, desiredDrillDirection.y];
tiles[desiredDrillDirection.x, desiredDrillDirection.y] = ObjectType.Player;
movedThisFrame = true;
player.AnimationState = AnimationState.DrillOn;
drillProgressIndicator.Alpha = 0f;
drillProgressIndicator.visible = false;
startedDrilling = false;
canStartDrilling = false;
// Do something if a special tile was mined
// ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
ExecuteActionOnMinedTile(minedTile);
// Recalculate position
(playerX, playerY) = new Vector2(player.x, player.y).ToGrid().ToInt().Unpack();
desiredPosition = movementDirection.Add(playerX, playerY);
rangeCheck = desiredPosition.x >= 0 && desiredPosition.x < TilesHorizontal && desiredPosition.y >= 0 && desiredPosition.y < TilesVertical;
}
public List <Cell> GetCellsPath(Vector2Int startIndex, Direction direction)
{
var path = new List <Cell>();
var startCell = GetCellAt(startIndex);
if (startCell == null)
{
return(path);
}
while (true)
{
var nextCellIndex = startIndex.Add(direction);
var nextCell = GetCellAt(nextCellIndex);
if (nextCell == null || nextCell.type != CellType.Floor)
{
break;
}
path.Add(nextCell);
startIndex = nextCellIndex;
}
return(path);
}
private void UpdateGravity(ref int playerX, ref int playerY, ref bool rangeCheck, ref Vector2Int movementDirection, ref Vector2Int desiredPosition)
{
if (!(timeSinceLastMovement > Settings.Instance.PlayerMovementThreshold) || !(gravityTimeLeft <= 0))
{
return;
}
if (playerY + 1 < TilesVertical && tiles[playerX, playerY + 1] == ObjectType.Empty)
{
player.Move(0, Globals.TILE_SIZE);
tiles[playerX, playerY] = ObjectType.Empty;
tiles[playerX, playerY + 1] = ObjectType.Player;
// Recalculate position
(playerX, playerY) = new Vector2(player.x, player.y).ToGrid().ToInt().Unpack();
desiredPosition = movementDirection.Add(playerX, playerY);
rangeCheck = desiredPosition.x >= 0 && desiredPosition.x < TilesHorizontal && desiredPosition.y >= 0 && desiredPosition.y < TilesVertical;
}
gravityTimeLeft = Settings.Instance.GravityFrequency;
}
public bool IsValid(Vector2Int src, Vector2Int dst, Board board)
{
var vector = Vector2Int.Substract(dst, src);
var signVector = vector.SignVector;
var tempVector = new Vector2Int(signVector);
while (!tempVector.Equal(vector))
{
var piece = board.Occupants.SafeGetValue(
src.X + tempVector.X,
src.Y + tempVector.Y
);
if (piece != null)
{
return(false);
}
tempVector.Add(signVector);
}
return(true);
}
public Vector2Int[] AvailableMoveAroundLocations(Vector2Int origin)
{
var moveDirs = Direction.MOVE_DIRECTIONS;
var result = new List <Vector2Int>();
foreach (var dir in moveDirs)
{
var pos = Vector2Int.Add(origin, dir);
if (!IsWithinBound(pos))
{
continue;
}
var piece = Occupants.SafeGetValue(pos);
if (piece == null)
{
result.Add(pos);
}
}
return(result.ToArray());
}
public static ChessPiece FindPiece(Color player, Vector2Int origin, Board board)
{
var moveDirs = Direction.MOVE_DIRECTIONS;
foreach (var moveDir in moveDirs)
{
var currPos = new Vector2Int(origin);
while (Board.IsWithinBound(currPos))
{
currPos.Add(moveDir);
var(foundThreat, piece) = FindThreatPiece(player, currPos, origin, board);
if (piece != null && foundThreat)
{
return(piece);
}
if (piece != null)
{
break;
}
}
}
var lMovePostions = Direction.L_MOVE_DIRECTIONS;
foreach (var lMovePos in lMovePostions)
{
var currPos = Vector2Int.Add(origin, lMovePos);
var(foundThreat, piece) = FindThreatPiece(player, currPos, origin, board);
if (piece != null && foundThreat)
{
return(piece);
}
}
return(null);
}
public virtual void Do()
{
Color[] colors = new Color[(colliderChecks.x + textureBorder * 2) * (colliderChecks.y + textureBorder * 2)];
Vector2Int[] outlinePositions = new Vector2Int[0];
bool foundCollider;
bool foundNoCollider;
colliderBounds = collider.bounds;
boxCollider = collider as BoxCollider2D;
if (boxCollider != null)
{
boxColliderEdgeRadius = boxCollider.edgeRadius;
colliderBounds.Expand(Vector2.one * boxColliderEdgeRadius * 2);
boxCollider.edgeRadius = 0;
}
for (int x = 0; x < colliderChecks.x + textureBorder * 2; x++)
{
for (int y = 0; y < colliderChecks.y + textureBorder * 2; y++)
{
if (behaviour == Behaviour.FillInside)
{
if (CheckForCollider(new Vector2Int(x, y)))
{
colors[x + y * (colliderChecks.x + textureBorder * 2)] = Color.white;
}
}
else if (behaviour == Behaviour.FillOutside)
{
if (!CheckForCollider(new Vector2Int(x, y)))
{
colors[x + y * (colliderChecks.x + textureBorder * 2)] = Color.white;
}
}
else
{
foundCollider = CheckForCollider(new Vector2Int(x, y)) || CheckForCollider(new Vector2Int(x + 1, y)) || CheckForCollider(new Vector2Int(x, y + 1)) || CheckForCollider(new Vector2Int(x - 1, y)) || CheckForCollider(new Vector2Int(x, y - 1));
foundNoCollider = !CheckForCollider(new Vector2Int(x, y)) || !CheckForCollider(new Vector2Int(x + 1, y)) || !CheckForCollider(new Vector2Int(x, y + 1)) || !CheckForCollider(new Vector2Int(x - 1, y)) || !CheckForCollider(new Vector2Int(x, y - 1));
if (checkDiagonals)
{
foundCollider |= CheckForCollider(new Vector2Int(x + 1, y + 1)) || CheckForCollider(new Vector2Int(x - 1, y + 1)) || CheckForCollider(new Vector2Int(x - 1, y + 1)) || CheckForCollider(new Vector2Int(x - 1, y - 1));
foundNoCollider |= !CheckForCollider(new Vector2Int(x + 1, y + 1)) || !CheckForCollider(new Vector2Int(x - 1, y + 1)) || !CheckForCollider(new Vector2Int(x - 1, y + 1)) || !CheckForCollider(new Vector2Int(x - 1, y - 1));
}
if (foundCollider && foundNoCollider)
{
colors[x + y * (colliderChecks.x + textureBorder * 2)] = Color.white;
outlinePositions = outlinePositions.Add(new Vector2Int(x, y));
}
}
}
}
if (behaviour == Behaviour.Outline)
{
for (int x = 0; x < colliderChecks.x + textureBorder * 2; x++)
{
for (int y = 0; y < colliderChecks.y + textureBorder * 2; y++)
{
foreach (Vector2Int outlinePosition in outlinePositions)
{
if (Vector2Int.Distance(new Vector2Int(x, y), outlinePosition) <= outlineRadius)
{
colors[x + y * (colliderChecks.x + textureBorder * 2)] = Color.white;
break;
}
}
}
}
}
Texture2D texture = new Texture2D(colliderChecks.x + textureBorder * 2, colliderChecks.y + textureBorder * 2);
texture.SetPixels(colors);
texture.Apply();
if (makeAssetPathsUnique)
{
string newAssetPath = textureAssetPath;
while (File.Exists(newAssetPath))
{
newAssetPath = newAssetPath.Replace(".asset", "1.asset");
}
textureAssetPath = newAssetPath;
AssetDatabase.CreateAsset(texture, newAssetPath);
}
else
{
AssetDatabase.CreateAsset(texture, textureAssetPath);
}
AssetDatabase.Refresh();
Sprite sprite = Sprite.Create(texture, Rect.MinMaxRect(0, 0, colliderChecks.x + textureBorder * 2, colliderChecks.y + textureBorder * 2), Vector2.one / 2);
if (makeAssetPathsUnique)
{
string newAssetPath = spriteAssetPath;
while (File.Exists(newAssetPath))
{
newAssetPath = newAssetPath.Replace(".asset", "1.asset");
}
spriteAssetPath = newAssetPath;
AssetDatabase.CreateAsset(sprite, newAssetPath);
}
else
{
AssetDatabase.CreateAsset(sprite, spriteAssetPath);
}
AssetDatabase.Refresh();
if (boxCollider != null)
{
boxCollider.edgeRadius = boxColliderEdgeRadius;
}
if (spriteRenderer != null)
{
spriteRenderer.sprite = sprite;
Transform trs = spriteRenderer.GetComponent <Transform>();
trs.localScale = collider.GetSize();
trs.position = collider.GetCenter();
}
}
