/// This will FAIL if ANY player-controlled-Tile can't do this move.
public static MoveResults ExecuteMove(Board b, Vector2Int dir)
{
// No dir?? Do nothing; return success!
if (dir == Vector2Int.zero)
{
return(MoveResults.Success);
}
// Get list of all things that're considered a "player".
List <Tile> players = b.GetPlayers();
if (players.Count == 0)
{
return(MoveResults.Fail);
} // No players?? Return FAIL.
//if (AreGoalsSatisfied) { return false; } // Already won? Return FAIL.
// Move 'em all, and return is ANY succeeded!
MoveResults finalResult = MoveResults.Fail;
foreach (Tile obj in players)
{
if (MayMoveTile(b, obj, dir))
{
MoveTile(b, obj, dir);
finalResult = MoveResults.Success;
}
}
// Destroy any tiles on destroy-spaces.
List <Tile> tilesToDestroy = new List <Tile>();
for (int i = b.allTiles.Count - 1; i >= 0; --i)
{
Tile tile = b.allTiles[i];
if (tile.MySpace.ShouldDestroyTile(tile))
{
foreach (Tile t in tile.MySpace.MyTiles)
{
tilesToDestroy.Add(t);
}
}
}
foreach (Tile tile in tilesToDestroy)
{
tile.RemoveFromPlay();
}
// IF success, then update all the TextRules!
if (finalResult == MoveResults.Success)
{
b.RefreshAndApplyTextRules();
}
return(finalResult);
}
public static MoveResults MoveOccupant(Board b, BoardOccupant bo, Vector2Int dir)
{
// No dir?? Do nothing; return success!
if (dir == Vector2Int.zero)
{
return(MoveResults.Success);
}
TranslationInfo ti = GetTranslationInfo(b, bo.ColRow, dir);
BoardSpace spaceFrom = GetSpace(b, ti.from);
BoardSpace spaceTo = GetSpace(b, ti.to);
// Someone's null? Return Fail.
if (bo == null || spaceTo == null)
{
return(MoveResults.Fail);
}
// We can't EXIT this space? Return Fail.
if (!spaceFrom.MayOccupantEverExit(ti.dirOut))
{
return(MoveResults.Fail);
}
// We can't ENTER this space? Return Fail.
if (!spaceTo.MayOccupantEverEnter(ti.dirIn))
{
return(MoveResults.Fail);
}
// Always remove its footprint first. We're about to move it!
bo.RemoveMyFootprint();
// Next space is OCCUPIED? Ok, try to move THAT fella, and return if fail!
if (spaceTo.HasOccupant)
{
MoveResults result = MoveOccupant(b, ti.to, ti.dirOut);
if (result != MoveResults.Success)
{
return(result);
}
}
// Okay, we're good to move our original fella! Do!
//int newSideFacing = GetNewSideFacing(b, bo.SideFacing, occPos, dir);
bo.SetColRow(ti.to, ti.dirOut);
bo.ChangeSideFacing(ti.sideDelta);
bo.ChangeChirality(ti.chirDeltaH, ti.chirDeltaV);
// Put footprint back down.
bo.AddMyFootprint();
// Return success!
return(MoveResults.Success);
}
public static MoveResults MoveTile(Board b, Tile tile, Vector2Int dir)
{
// No dir?? Do nothing; return success!
if (dir == Vector2Int.zero)
{
return(MoveResults.Success);
}
TranslationInfo ti = GetTranslationInfo(b, tile.ColRow, dir);
BoardSpace spaceFrom = GetSpace(b, ti.from);
BoardSpace spaceTo = GetSpace(b, ti.to);
// Someone's null? Return Fail.
if (tile == null || spaceTo == null)
{
return(MoveResults.Fail);
}
// We can't EXIT this space? Return Fail.
if (!spaceFrom.MayTileEverExit(ti.dirOut))
{
return(MoveResults.Fail);
}
// We can't ENTER this space? Return Fail.
if (!spaceTo.MayTileEverEnter(ti.dirIn))
{
return(MoveResults.Fail);
}
// Always remove its footprint first. We're about to move it!
tile.RemoveMyFootprint();
// Next space has somethin' to push? Ok, try to move THAT fella, and return if fail!
if (spaceTo.HasPushTile())
{
MoveResults result = MovePushTiles(b, ti.to, ti.dirOut);
if (result != MoveResults.Success)
{
return(result);
}
}
// Okay, we're good to move our original fella! Do!
tile.SetColRow(ti.to, ti.dirOut);
// Put footprint back down.
tile.AddMyFootprint();
// Return success!
return(MoveResults.Success);
}
/// This will FAIL if ANY occupant can't do this move.
public static MoveResults MovePlayers(Board b, List <Vector2Int> occPoses, Vector2Int dir)
{
// No dir?? Do nothing; return success!
if (dir == Vector2Int.zero)
{
return(MoveResults.Success);
}
// Make a list of the Occupants we wanna move.
List <BoardOccupant> bosToMove = new List <BoardOccupant>();
foreach (Vector2Int boPos in occPoses)
{
bosToMove.Add(b.GetOccupant(boPos));
}
//// Remove these occupants' footprints!
//foreach (BoardOccupant bo in bosToMove) { bo.RemoveMyFootprint(); }
// Move 'em all, and return the result!
bool justNeedOneToMove = true;
if (justNeedOneToMove)
{
MoveResults finalResult = MoveResults.Fail;
foreach (BoardOccupant bo in bosToMove)
{
if (MayMoveOccupant(b, bo.ColRow, dir))
{
MoveOccupant(b, bo, dir);
finalResult = MoveResults.Success;
}
}
return(finalResult);
}
else
{
foreach (BoardOccupant bo in bosToMove)
{
MoveResults result = MoveOccupant(b, bo, dir);
if (result == MoveResults.Fail)
{
return(MoveResults.Fail);
} // This move didn't work? Return fail.
}
return(MoveResults.Success);
}
}
private MoveResults GetMoveResults(Coord orig, int dist, Coord[] dirs)
{
Verbose(10, $"BoardModel: GetMoveResults: {orig} {dist} {dirs}");
var moveResults = new MoveResults();
foreach (var next in dirs)
{
var minDist = Int32.MaxValue;
for (int n = 1; n <= dist; ++n)
{
var coord = orig + next * n;
if (coord == orig)
{
continue;
}
if (!IsValidCoord(coord))
{
continue;
}
var model = At(coord);
var manDist = ManhattanDistance(coord, orig);
if (model != null && !moveResults.Interrupts.Contains(model))
{
if (manDist <= minDist)
{
moveResults.Interrupts.Add(model);
minDist = manDist;
}
continue;
}
moveResults.Coords.Add(coord);
}
}
return(moveResults);
}
private static MoveResults MovePushTiles(Board b, Vector2Int occPos, Vector2Int dir)
{
// Try to move each one. If ANY one fails, we return a TOTAL fail.
List <Tile> tilesToMove = new List <Tile>();
foreach (Tile tile in b.GetSpace(occPos).MyTiles)
{
if (tile.IsPush)
{
tilesToMove.Add(tile);
}
}
foreach (Tile obj in tilesToMove)
{
MoveResults result = MoveTile(b, obj, dir);
if (result != MoveResults.Success)
{
return(MoveResults.Fail);
}
}
return(MoveResults.Success);
}
public void ThenTheMoveResultsShouldBeEmpty()
{
MoveResults.Should().BeEmpty();
}
