private bool DoesNotViolateTerritoryDrop(ref DropPrepStepState token, PieceSide side, IEntitiesDB entitiesDB)
{
TurnEV turnPlayer = turnService.GetCurrentTurnEV(entitiesDB);
return(!HasDropAbility(ref token.HandPiece, side, DropAbility.TERRITORY_DROP) ||
turnService.IsRankWithinTerritory(turnPlayer, token.DestinationTile.Location.Location.y));
}
private string CreateTurnSaveInfoString()
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
int iaActive = currentTurn.InitialArrangement.IsInitialArrangementInEffect ? 1 : 0;
return(iaActive + "," + currentTurn.TurnPlayer.PlayerColor.ToString());
}
public bool IsSubstitutionPossible(PieceEV?clickedPiece, TileEV?clickedTile, IEntitiesDB entitiesDB)
{
// Remember, Commander cannot run to Samurai during check, b/c that's a violation of a different rule
/* Conditions:
* piece clicked
* not a destination tile (user is clicking this piece to access substitution ability or click-highlight it)
* commander in check
* samurai (has substitution ability)
* piece is topOfTower
* piece tier == 1
* piece is adjacent to Commander vertically or horizontally
* substitution would resolve check
*/
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
PieceEV commander = pieceFindService.FindCommander(currentTurn.TurnPlayer.PlayerColor, entitiesDB);
return(currentTurn.Check.CommanderInCheck &&
clickedPiece.HasValue &&
clickedTile.HasValue &&
(!clickedTile.Value.Tile.PieceRefEntityId.HasValue || clickedTile.Value.Tile.PieceRefEntityId.Value == 0) &&
AbilityToPiece.HasAbility(OtherMoveAbility.SUBSTITUTION, clickedPiece.Value.Piece.PieceType) &&
clickedPiece.Value.Tier.Tier == 1 &&
clickedPiece.Value.Tier.TopOfTower &&
IsAdjacentLocationToCommander(clickedPiece.Value, commander) &&
DoesSubstitutionResolveCheck(clickedPiece.Value, commander, entitiesDB));
}
public bool DropReleasesCheck(
PieceEV pieceToDrop,
Vector2 location,
TurnEV turn,
PieceSide side,
IEntitiesDB entitiesDB)
{
bool returnValue = false;
PieceEV?topPieceAtLocation = pieceFindService.FindTopPieceByLocation(location, entitiesDB);
pieceSetService.SetTopOfTowerToFalse(topPieceAtLocation, entitiesDB);
int tier = topPieceAtLocation.HasValue ? topPieceAtLocation.Value.Tier.Tier + 1 : 1;
pieceSetService.SetPieceLocationAndTier(pieceToDrop, location, tier, entitiesDB);
pieceSetService.SetPiecePlayerOwner(pieceToDrop, turn.TurnPlayer.PlayerColor, entitiesDB);
pieceSetService.SetPieceSide(pieceToDrop, side, entitiesDB);
returnValue = !IsCommanderInCheck(turn.TurnPlayer.PlayerColor, entitiesDB);
pieceSetService.SetPieceLocationToHandLocation(pieceToDrop, entitiesDB);
if (topPieceAtLocation.HasValue)
{
pieceSetService.SetTopOfTower(topPieceAtLocation.Value, entitiesDB);
}
return(returnValue);
}
private bool CheckDropToken(ref HandPieceEV handPiece, ref TileEV destinationTile, PieceSide?sideToCheck)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
PieceEV pieceToDrop = pieceFindService.FindFirstPieceByLocationAndType(
BoardConst.HAND_LOCATION, handPiece.HandPiece.PieceType, handPiece.HandPiece.Back, entitiesDB);
bool returnValue = !currentTurn.Check.CommanderInCheck;
if (!returnValue) // Commander is in check
{
bool singleSideValid = sideToCheck.HasValue && checkService.DropReleasesCheck(
pieceToDrop,
destinationTile.Location.Location,
currentTurn,
sideToCheck.Value,
entitiesDB);
bool eitherSideValid = !sideToCheck.HasValue && (
checkService.DropReleasesCheck(
pieceToDrop,
destinationTile.Location.Location,
currentTurn,
PieceSide.FRONT,
entitiesDB) ||
checkService.DropReleasesCheck(
pieceToDrop,
destinationTile.Location.Location,
currentTurn,
PieceSide.BACK,
entitiesDB));
returnValue = singleSideValid || eitherSideValid;
}
return(returnValue);
}
private void OnPressed(int entityId, bool isPressed)
{
if (!isPressed)
{
return;
}
// if not turn team or num piece count == 0, stop
HandPieceEV handPiece = handService.FindHandPiece(entityId, entitiesDB);
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
if (handPiece.PlayerOwner.PlayerColor != currentTurn.TurnPlayer.PlayerColor ||
handPiece.HandPiece.NumPieces.value <= 0 ||
currentTurn.ForcedRearrangementStatus.ForcedRearrangmentActive)
{
handPiece.Highlight.IsPressed.value = false; // Will trigger a HandPiecePressEngine, but IsPressed check will stop it
return;
}
var pressState = new HandPiecePressStepState
{
HandPieceEntityId = entityId
};
boardPressSequence.Next(this, ref pressState);
}
public bool NoCheckViolationsExist(List <PieceEV> towerPieces, bool immobileCapturePossible, IEntitiesDB entitiesDB)
{
if (!immobileCapturePossible)
{
return(true);
}
// EFE scenario, where capturing below one piece is invalid, but capturing the other piece is valid
int totalNumImmobileCaptures = 0;
int validNumImmobileCaptures = 0;
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
for (int tierIndex = 1; tierIndex < towerPieces.Count; ++tierIndex)
{
if (towerPieces[tierIndex].PlayerOwner.PlayerColor != towerPieces[tierIndex - 1].PlayerOwner.PlayerColor
// Also ensure piece that strikes is capable of immobile capture
&& CanImmobileCapture(currentTurn.TurnPlayer.PlayerColor, towerPieces[tierIndex]) &&
CanImmobileCapture(currentTurn.TurnPlayer.PlayerColor, towerPieces[tierIndex - 1]))
{
totalNumImmobileCaptures++;
if (DoesImmobileCaptureResolveOrPreventCheck(towerPieces, tierIndex, entitiesDB))
{
validNumImmobileCaptures++;
}
}
}
return(totalNumImmobileCaptures == validNumImmobileCaptures || (totalNumImmobileCaptures > 0 && validNumImmobileCaptures > 0));
}
private void ChangeTileColor(List <TileEV> tilesToChange, ref PressStepState token)
{
bool isClicked = token.PiecePressState == PiecePressState.CLICKED;
PieceEV piece = pieceFindService.FindPieceEV(token.PieceEntityId, entitiesDB);
int pieceIdtoken = token.PieceEntityId;
HighlightState newHighlightState = HighlightService.CalcClickHighlightState(piece.PlayerOwner.PlayerColor);
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
bool doesPieceBelongToTurnPlayer = currentTurn.TurnPlayer.PlayerColor == piece.PlayerOwner.PlayerColor;
foreach (TileEV tileEV in tilesToChange)
{
entitiesDB.ExecuteOnEntity(
tileEV.ID,
(ref TileEV tileToChange) =>
{
tileToChange.Highlight.IsHighlighted = isClicked;
if (doesPieceBelongToTurnPlayer)
{
tileToChange.Tile.PieceRefEntityId = isClicked ? (int?)pieceIdtoken : null;
}
if (isClicked)
{
tileToChange.Highlight.CurrentColorStates.Add(newHighlightState);
}
else
{
tileToChange.Highlight.CurrentColorStates.Remove(newHighlightState);
}
});
tileEV.ChangeColorTrigger.PlayChangeColor = true;
}
}
private bool DoesNotViolateTerritoryDrop(
ref HandPieceEV handPiece, ref Vector2 location, PieceSide side, IEntitiesDB entitiesDB)
{
TurnEV turnPlayer = turnService.GetCurrentTurnEV(entitiesDB);
return(!HasDropAbility(ref handPiece, side, DropAbility.TERRITORY_DROP) ||
turnService.IsRankWithinTerritory(turnPlayer, location.y));
}
private bool DoesNotViolateInitialArrangement(ref HandPieceEV handPiece, ref Vector2 location, PieceSide side, IEntitiesDB entitiesDB)
{
TurnEV turnEV = turnService.GetCurrentTurnEV(entitiesDB);
return(!turnEV.InitialArrangement.IsInitialArrangementInEffect ||
(turnService.IsRankWithinTerritory(turnEV, location.y) &&
side == PieceSide.FRONT));
}
private PieceSideState CheckDropToken(ref HandPieceEV handPiece, ref TileEV destinationTile, PieceSide?sideToCheck)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
if (currentTurn.InitialArrangement.IsInitialArrangementInEffect)
{
return(PieceSideState.FRONT);
}
PieceEV pieceToDrop = pieceFindService.FindFirstPieceByLocationAndType(
BoardConst.HAND_LOCATION, handPiece.HandPiece.PieceType, handPiece.HandPiece.Back, entitiesDB);
bool singleSideValid = sideToCheck.HasValue && checkmateService.DropReleasesCheck(
pieceToDrop,
destinationTile.Location.Location,
currentTurn.TurnPlayer.PlayerColor,
sideToCheck.Value,
handPiece,
entitiesDB);
bool frontSideValid = !sideToCheck.HasValue &&
checkmateService.DropReleasesCheck(
pieceToDrop,
destinationTile.Location.Location,
currentTurn.TurnPlayer.PlayerColor,
PieceSide.FRONT,
handPiece,
entitiesDB);
bool backSideValid = !sideToCheck.HasValue &&
checkmateService.DropReleasesCheck(
pieceToDrop,
destinationTile.Location.Location,
currentTurn.TurnPlayer.PlayerColor,
PieceSide.BACK,
handPiece,
entitiesDB);
if (singleSideValid)
{
return(sideToCheck.Value == PieceSide.FRONT ? PieceSideState.FRONT : PieceSideState.BACK);
}
else if (frontSideValid && backSideValid)
{
return(PieceSideState.BOTH);
}
else if (frontSideValid)
{
return(PieceSideState.FRONT);
}
else if (backSideValid)
{
return(PieceSideState.BACK);
}
else
{
return(PieceSideState.NONE);
}
}
public void Step(ref CheckmateModalStepState token, int condition)
{
ModalEV modal = modalService.FindModalEV(entitiesDB);
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
PlayerColor victoriousPlayer = TurnService.CalcOtherTurnPlayer(currentTurn.TurnPlayer.PlayerColor);
SetModalOptions(modal, victoriousPlayer);
modalService.DisplayModal(modal);
}
public void Step(ref SubstitutionStepState token, int condition)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
PieceEV commander = pieceFindService.FindCommander(currentTurn.TurnPlayer.PlayerColor, entitiesDB);
PieceEV ninja = token.SubstitutionPiece;
SwitchCommanderAndNinjaPiece(commander, ninja);
NextActionTurnEnd();
}
public void Step(ref TurnStartStepState token, int condition)
{
TurnEV turn = turnService.GetCurrentTurnEV(entitiesDB);
if (turn.Check.CommanderInCheck && !checkmateService.AnyValidMoves(turn.TurnPlayer.PlayerColor, entitiesDB))
{
Debug.Log("CHECKMATED PLAYER: " + turn.TurnPlayer.PlayerColor.ToString());
NextActionCheckmateModal();
}
}
private void SetInitialArrangementStatus(TurnEV currentTurn)
{
if (currentTurn.InitialArrangement.IsInitialArrangementInEffect &&
handService.AreHandsEmpty(entitiesDB))
{
entitiesDB.ExecuteOnEntity(
currentTurn.ID,
(ref TurnEV turnToChange) => { turnToChange.InitialArrangement.IsInitialArrangementInEffect = false; });
}
}
private void SetTierOptions(TowerModalEV modal, ModalType modalType, List <PieceEV> piecesAtLocation)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
PlayerColor turnColor = currentTurn.TurnPlayer.PlayerColor;
PieceEV pieceTier1 = piecesAtLocation[0];
PieceEV pieceTier2 = piecesAtLocation[1];
PieceEV? pieceTier3 = modalType == ModalType.TOWER_3RD_TIER ? (PieceEV?)piecesAtLocation[2] : null;
PlayerColor topPlayerColor = pieceTier3.HasValue ?
pieceTier3.Value.PlayerOwner.PlayerColor : pieceTier2.PlayerOwner.PlayerColor;
bool immobileCapturePossible = immobileCaptureService.ImmobileCapturePossible(piecesAtLocation, currentTurn.TurnPlayer.PlayerColor, entitiesDB);
bool noCheckViolationsExist = immobileCaptureService.NoCheckViolationsExist(piecesAtLocation, immobileCapturePossible, entitiesDB);
entitiesDB.ExecuteOnEntity(
modal.ID,
(ref TowerModalEV modalToChange) =>
{
modalToChange.ImmobileCaptureState.ImmobileCaptureDesignated = false;
modalToChange.Tier1.Enabled = pieceTier1.Tier.TopOfTower ||
(immobileCapturePossible && noCheckViolationsExist &&
pieceTier1.PlayerOwner.PlayerColor != pieceTier2.PlayerOwner.PlayerColor &&
pieceTier1.PlayerOwner.PlayerColor == turnColor);
modalToChange.Tier1.Name = CalcButtonText(pieceTier1);
modalToChange.Tier1.ReferencedPieceId = pieceTier1.ID.entityID;
modalToChange.Tier1.Team = pieceTier1.PlayerOwner.PlayerColor;
modalToChange.Tier1.PieceType = pieceTier1.Piece.PieceType;
modalToChange.Tier1.Back = pieceTier1.Piece.Back;
modalToChange.Tier2.Enabled = pieceTier2.Tier.TopOfTower ||
(immobileCapturePossible && noCheckViolationsExist &&
(pieceTier2.PlayerOwner.PlayerColor != pieceTier1.PlayerOwner.PlayerColor ||
(!pieceTier3.HasValue || pieceTier2.PlayerOwner.PlayerColor != pieceTier3.Value.PlayerOwner.PlayerColor)) &&
pieceTier2.PlayerOwner.PlayerColor == turnColor);
modalToChange.Tier2.Name = CalcButtonText(pieceTier2);
modalToChange.Tier2.ReferencedPieceId = pieceTier2.ID.entityID;
modalToChange.Tier2.Team = pieceTier2.PlayerOwner.PlayerColor;
modalToChange.Tier2.PieceType = pieceTier2.Piece.PieceType;
modalToChange.Tier2.Back = pieceTier2.Piece.Back;
if (pieceTier3.HasValue)
{
modalToChange.Tier3.Enabled = pieceTier3.Value.Tier.TopOfTower;
modalToChange.Tier3.Name = CalcButtonText(pieceTier3.Value);
modalToChange.Tier3.ReferencedPieceId = pieceTier3.Value.ID.entityID;
modalToChange.Tier3.Team = pieceTier3.Value.PlayerOwner.PlayerColor;
modalToChange.Tier3.PieceType = pieceTier3.Value.Piece.PieceType;
modalToChange.Tier3.Back = pieceTier3.Value.Piece.Back;
}
else
{
modalToChange.Tier3.Enabled = false;
}
});
}
public void Step(ref TurnStartStepState token, int condition)
{
TurnEV turnEV = turnService.GetCurrentTurnEV(entitiesDB);
TileEV[] tiles = tileService.FindAllTileEVs(entitiesDB);
FindAndHighlightTeamTiles(PlayerColor.BLACK, tiles, PlayerColor.BLACK == turnEV.TurnPlayer.PlayerColor);
FindAndHighlightTeamTiles(PlayerColor.WHITE, tiles, PlayerColor.WHITE == turnEV.TurnPlayer.PlayerColor);
PlayColorAllTiles(tiles);
}
private void NextActionInitiateImmobileCapture(PieceEV piece)
{
/**
* Scenarios, [Tier1, Tier2, Tier3], F=Friendly, E=Enemy:
* * FO, FOO, OFO
* * OF, OFF, FOF
*
* The pieceToCapture is either the piece param (piece that was clicked) or an
* adjacent piece. Business logic:
*
* If topOfTower is NOT turn player color, then it's piece that was clicked
* Else it's the adjacent piece that is NOT turn player color; there will only
* be one of those
*/
PieceEV pieceToCapture = piece;
PieceEV topOfTowerPiece = pieceFindService.FindTopPieceByLocation(piece.Location.Location, entitiesDB).Value;
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
//if (topOfTowerPiece.PlayerOwner.PlayerColor != currentTurn.TurnPlayer.PlayerColor)
//{
// pieceToCapture = piece;
//}
//else
if (topOfTowerPiece.PlayerOwner.PlayerColor == currentTurn.TurnPlayer.PlayerColor)
{
List <PieceEV> pieces = pieceFindService.FindPiecesByLocation(piece.Location.Location, entitiesDB);
bool pieceFound = false;
foreach (PieceEV pieceToCheck in pieces)
{
if (Math.Abs(piece.Tier.Tier - pieceToCheck.Tier.Tier) == 1 &&
currentTurn.TurnPlayer.PlayerColor != pieceToCheck.PlayerOwner.PlayerColor)
{
pieceToCapture = pieceToCheck;
pieceFound = true;
break;
}
}
if (!pieceFound)
{
throw new InvalidOperationException("Did not find adjacent piece of opposite color.");
}
}
var immobileCapturePieceStepState = new ImmobileCapturePieceStepState
{
PieceToCapture = pieceToCapture
};
towerModalConfirmSequence.Next(this, ref immobileCapturePieceStepState, (int)TowerAnswerState.INITIATE_IMMOBILE_CAPTURE);
}
public void Step(ref ForcedRecoveryStepState token, int condition)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
IPieceData piece = pieceFactory.CreateIPieceData(token.PieceMoved.Piece.PieceType);
bool forcedRecoveryPossible = token.PieceMoved.Tier.TopOfTower && // Paranoia check
piece.Abilities.PostMove.Contains(PostMoveAbility.FORCED_RECOVERY) &&
!HasDestinationTiles(token.PieceMoved) &&
checkService.ForcedRecoveryResolvesOrDoesNotCreateCheck(token.PieceMoved, currentTurn, entitiesDB);
NextAction(ref token, forcedRecoveryPossible);
}
public bool IsTierExchangePossible(BoardPressStateInfo stateInfo, TurnEV currentTurn, IEntitiesDB entitiesDB)
{
if (!stateInfo.tile.HasValue || currentTurn.InitialArrangement.IsInitialArrangementInEffect)
{
return(false);
}
List <PieceEV> towerPieces = pieceFindService.FindPiecesByLocation(stateInfo.tile.Value.Location.Location, entitiesDB);
return(IsTier1ExchangePossible(towerPieces, currentTurn.TurnPlayer.PlayerColor) ||
IsTier3ExchangePossible(towerPieces, currentTurn.TurnPlayer.PlayerColor));
}
private void SetTurnStatus(PlayerColor turnPlayer, bool initialArrangementInEffect)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
entitiesDB.ExecuteOnEntity(
currentTurn.ID,
(ref TurnEV turnToChange) =>
{
turnToChange.TurnPlayer.PlayerColor = turnPlayer;
turnToChange.InitialArrangement.IsInitialArrangementInEffect = initialArrangementInEffect;
});
}
private void EndTurn()
{
SwitchTurnPlayer();
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
SetInitialArrangementStatus(currentTurn);
if (!currentTurn.InitialArrangement.IsInitialArrangementInEffect)
{
var turnStartStepState = new TurnStartStepState();
turnStartSequencer.Next(this, ref turnStartStepState);
}
}
public void Step(ref BetrayalStepState token, int condition)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
List <PieceEV> towerPieces = pieceFindService.FindPiecesByLocation(token.PieceMoved.Location.Location, entitiesDB);
foreach (PieceEV piece in towerPieces)
{
if (piece.PlayerOwner.PlayerColor != currentTurn.TurnPlayer.PlayerColor)
{
FlipPiece(piece, currentTurn.TurnPlayer.PlayerColor);
}
}
}
public bool IsTierExchangePossible(BoardPressStateInfo stateInfo, IEntitiesDB entitiesDB)
{
if (!stateInfo.tile.HasValue)
{
return(false);
}
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
List <PieceEV> towerPieces = pieceFindService.FindPiecesByLocation(stateInfo.tile.Value.Location.Location, entitiesDB);
return(IsTier1ExchangePossible(towerPieces, currentTurn.TurnPlayer.PlayerColor) ||
IsTier3ExchangePossible(towerPieces, currentTurn.TurnPlayer.PlayerColor));
}
public void Step(ref TurnStartStepState token, int condition)
{
TurnEV turn = turnService.GetCurrentTurnEV(entitiesDB);
bool inCheck = checkService.IsCommanderInCheck(turn.TurnPlayer.PlayerColor, entitiesDB);
turnService.SetCheckStatus(turn, inCheck, entitiesDB);
Debug.Log("Turn Player: " + turn.TurnPlayer.PlayerColor.ToString());
if (inCheck)
{
Debug.Log("CHECK: " + turn.TurnPlayer.PlayerColor.ToString());
}
}
public void Step(ref ForcedRearrangementStepState token, int condition)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
turnService.SetForcedRearrangementStatus(currentTurn, true, entitiesDB);
HandPieceEV handPiece = handService.FindHandPiece(
token.PieceToRearrange.Value.Piece.Front,
token.PieceToRearrange.Value.Piece.Back,
currentTurn.TurnPlayer.PlayerColor,
entitiesDB);
handService.HighlightHandPiece(ref handPiece, true, entitiesDB);
}
private void SetTurnEV(TurnEV currentTurn, IEntitiesDB entitiesDB)
{
PlayerColor nextTurnPlayer =
currentTurn.TurnPlayer.PlayerColor == PlayerColor.BLACK
? PlayerColor.WHITE : PlayerColor.BLACK;
entitiesDB.ExecuteOnEntity(
currentTurn.ID,
(ref TurnEV turnToChange) =>
{
turnToChange.TurnPlayer.PlayerColor = nextTurnPlayer;
turnToChange.ForcedRearrangementStatus.ForcedRearrangmentActive = false;
});
}
public void Step(ref DropStepState token, int condition)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
PieceEV pieceToDrop = pieceFindService.FindFirstPieceByLocationAndType(
BoardConst.HAND_LOCATION, token.HandPiece.HandPiece.PieceType, token.HandPiece.HandPiece.Back, entitiesDB);
dropService.DropPiece(
ref pieceToDrop,
ref token.DestinationTile,
token.Side,
token.HandPiece.PlayerOwner.PlayerColor,
entitiesDB);
UpdateHandPiece(ref token.HandPiece);
GotoTurnEndStep();
}
public void Step(ref BetrayalStepState token, int condition)
{
TurnEV currentTurn = turnService.GetCurrentTurnEV(entitiesDB);
List <PieceEV> towerPieces = pieceFindService.FindPiecesByLocation(token.PieceMoved.Location.Location, entitiesDB);
foreach (PieceEV piece in towerPieces)
{
// Only flip enemy pieces that are NOT the commander
if (piece.PlayerOwner.PlayerColor != currentTurn.TurnPlayer.PlayerColor &&
piece.Piece.PieceType != PieceType.COMMANDER)
{
FlipPiece(piece, currentTurn.TurnPlayer.PlayerColor);
}
}
}
public bool ForcedRecoveryResolvesOrDoesNotCreateCheck(PieceEV pieceMoved, TurnEV turn, IEntitiesDB entitiesDB)
{
bool returnValue = false;
Vector2 oldLocation = new Vector2(pieceMoved.Location.Location.x, pieceMoved.Location.Location.y);
int oldTier = pieceMoved.Tier.Tier;
bool oldTopOfTower = pieceMoved.Tier.TopOfTower;
pieceSetService.SetPieceLocationToHandLocation(pieceMoved, entitiesDB);
returnValue = !IsCommanderInCheck(turn.TurnPlayer.PlayerColor, entitiesDB);
pieceSetService.SetPieceLocationAndTier(pieceMoved, oldLocation, oldTier, entitiesDB);
pieceSetService.SetTopOfTower(pieceMoved, entitiesDB, oldTopOfTower);
return(returnValue);
}
