private void InsertBoardUnitAtIndex(int targetIndex, IBoardUnit boardUnit)
    {
        if (targetIndex == 0)
        {
            this.boardUnits.Insert(0, boardUnit);
            return;
        }

        int seenCount = 0;

        for (int i = 0; i < this.boardUnits.Count; i++)
        {
            IBoardUnit unit = this.boardUnits[i];
            if (unit.IsEnemyPlayer == boardUnit.IsEnemyPlayer && unit.IsFrontRow == boardUnit.IsFrontRow)
            {
                seenCount++;
            }

            if (seenCount == targetIndex)
            {
                this.boardUnits.Insert(i + 1, boardUnit);
                break;
            }
        }
    }
    private List <IBoardUnit> GetBoardUnitsForRow(bool isEnemyPlayer, bool isFrontRow)
    {
        List <IBoardUnit> unitsList = new List <IBoardUnit>();

        for (int i = 0; i < this.boardUnits.Count; i++)
        {
            IBoardUnit unit = this.boardUnits[i];

            if (unit.IsEnemyPlayer == isEnemyPlayer &&
                unit.IsFrontRow == isFrontRow)
            {
                // Add units in specified row
                unitsList.Add(unit);
            }
        }
        return(unitsList);
    }
    private int GetColPositionFromDropPosition(Vector2 dropPosition, bool isEnemyPlayer, bool isFrontRow)
    {
        List <IBoardUnit> unitsList     = this.GetBoardUnitsForRow(isEnemyPlayer, isFrontRow);
        List <Vector2>    unitPositions = this.GetUnitPositionsForRow(isEnemyPlayer, isFrontRow, unitsList.Count);

        for (int i = 0; i < unitsList.Count; i++)
        {
            IBoardUnit unit = unitsList[i];
            if (unit.IsTempSpaceholder)
            {
                continue;
            }

            Vector2 unitPosition = unitPositions[i];
            if (dropPosition.x < unitPosition.x)
            {
                return(i);
            }
        }

        return(unitsList.Count);
    }
    private void RerenderRow(bool isEnemyPlayer, bool isFrontRow)
    {
        // Move rest of ships to account for removed space
        List <IBoardUnit> unitsList     = this.GetBoardUnitsForRow(isEnemyPlayer, isFrontRow);
        List <Vector2>    unitPositions = this.GetUnitPositionsForRow(isEnemyPlayer, isFrontRow, unitsList.Count);

        for (int i = 0; i < unitsList.Count; i++)
        {
            IBoardUnit unit = unitsList[i];
            if (!unit.IsTempSpaceholder)
            {
                ((CardScript)unit).MoveHorizontally(unitPositions[i]);
            }
            else
            {
                PlaceholderBoardUnit placeHolder = (PlaceholderBoardUnit)unit;
                if (placeHolder.ShouldReplaceWithRealUnit)
                {
                    InsertNewUnitOnBoard(placeHolder, unitPositions[i]);
                }
            }
        }
    }
Esempio n. 5
0
 public void AddUnit(IBoardUnit unit)
 {
     Units.Add(unit);
 }
Esempio n. 6
0
 public void ReleaseUnit(IBoardUnit unit)
 {
     Units.Remove(unit);
 }
Esempio n. 7
0
 public bool IsSet(IBoardUnit unit)
 {
     var board = unit.AsBoard;
     return (value & board.value) == board.value;
 }
Esempio n. 8
0
 public bool IsClear(IBoardUnit unit)
 {
     return !Contains(unit);
 }
Esempio n. 9
0
 public Bitboard Intersect(IBoardUnit unit)
 {
     return value & unit.AsBoard.value;
 }
Esempio n. 10
0
 public bool Contains(IBoardUnit bu)
 {
     return (this.value & bu.AsBoard.value) > 0;
 }
Esempio n. 11
0
 public BoardBuilder And(IBoardUnit unit)
 {
     return new BoardBuilder(resultField.And(unit), invertedField);
 }
Esempio n. 12
0
 public TileChangedArgs(IBoardUnit boardUnit, Tile fromTile, Tile toTile)
 {
     BoardUnit = boardUnit;
     FromTile  = fromTile;
     ToTile    = toTile;
 }