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); }