Esempio n. 1
0
        private static Char GetStateDesc(FourInARowFieldState state)
        {
            switch (state)
            {
            case FourInARowFieldState.Empty: return('E');

            case FourInARowFieldState.Circle: return('O');

            case FourInARowFieldState.Cross: return('X');

            default:
                throw new NotSupportedException(state.ToString());
            }
        }
Esempio n. 2
0
 private static Int32 GetSign(FourInARowFieldState state)
 {
     if (state == FourInARowFieldState.Cross)
     {
         return(1);
     }
     else if (state == FourInARowFieldState.Circle)
     {
         return(-1);
     }
     else
     {
         throw new ArgumentException(state.ToString());
     }
 }
Esempio n. 3
0
        public FourInARowState()
        {
            _fields = new FourInARowFieldState[ColumnCount][];

            _nextMoveIndexes = new Int32[ColumnCount];

            for (Int32 q = 0; q < _fields.Length; q++)
            {
                _fields[q] = new FourInARowFieldState[RowCount];
            }

            _stateDesc = new Char[RowCount * ColumnCount];

            for (Int32 q = 0; q < _stateDesc.Length; q++)
            {
                _stateDesc[q] = GetStateDesc(FourInARowFieldState.Empty);
            }
        }
Esempio n. 4
0
        internal FourInARowState(FourInARowState source)
        {
            if (null == source)
            {
                throw new ArgumentNullException("source");
            }

            _nextMoveIndexes = (Int32[])source._nextMoveIndexes.Clone();

            _fields = new FourInARowFieldState[ColumnCount][];

            for (Int32 q = 0; q < _fields.Length; q++)
            {
                _fields[q] = (FourInARowFieldState[])source._fields[q].Clone();
            }

            _stateDesc = (Char[])source._stateDesc.Clone();

            _lastEmptyRow = source._lastEmptyRow;
        }
Esempio n. 5
0
        internal void Set(Int32 x, Int32 y, FourInARowFieldState state)
        {
            _fields[x][y] = state;

            _stateDesc[x + ColumnCount * y] = GetStateDesc(state);

            _nextMoveIndexes[x]++;

            if (y >= _lastEmptyRow)
            {
                _lastEmptyRow = y + 1;
            }

            if (state == FourInARowFieldState.Cross)
            {
                _crossesInRow[y]++;
                _crossesInColumn[x]++;
            }
            else if (state == FourInARowFieldState.Circle)
            {
                _circlesInRow[y]++;
                _circlesInColumn[x]++;
            }
        }
Esempio n. 6
0
        private static void ProcessField(FourInARowState state, Int32 x, Int32 y, FieldContext context)
        {
            FourInARowFieldState field = state.Get(x, y);

            context.LastFourItems.Add(field);

            if (field == FourInARowFieldState.Empty)
            {
                context.EmptyInRow++;
            }

            if (field == FourInARowFieldState.Circle)
            {
                context.CirclesInRow++;
            }

            if (field == FourInARowFieldState.Cross)
            {
                context.CrossesInRow++;
            }

            if (context.LastFourItems.Count >= 4)
            {
                if (context.LastFourItems.Count > 4)
                {
                    FourInARowFieldState first = context.LastFourItems[0];

                    context.LastFourItems.RemoveAt(0);

                    if (first == FourInARowFieldState.Empty)
                    {
                        context.EmptyInRow--;
                    }

                    if (first == FourInARowFieldState.Circle)
                    {
                        context.CirclesInRow--;
                    }

                    if (first == FourInARowFieldState.Cross)
                    {
                        context.CrossesInRow--;
                    }
                }

                if (context.CirclesInRow == 0)
                {
                    if (context.CrossesInRow == 4)
                    {
                        context.PartialResults.FourCrossesInRow++;
                    }
                    else if (context.CrossesInRow == 2 && context.EmptyInRow == 2)
                    {
                        context.PartialResults.TwoCrossesInRow++;
                    }
                    else if (context.CrossesInRow == 3 && context.EmptyInRow == 1)
                    {
                        context.PartialResults.ThreeCrossesInRow++;
                    }
                    else if (context.CrossesInRow == 1 && context.EmptyInRow == 3)
                    {
                        context.PartialResults.OneCrossInRow++;
                    }
                }

                if (context.CrossesInRow == 0)
                {
                    if (context.CirclesInRow == 4)
                    {
                        context.PartialResults.FourCirclesInRow++;
                    }
                    else if (context.CirclesInRow == 2 && context.EmptyInRow == 2)
                    {
                        context.PartialResults.TwoCirclesInRow++;
                    }
                    else if (context.CirclesInRow == 3 && context.EmptyInRow == 1)
                    {
                        context.PartialResults.ThreeCirclesInRow++;
                    }
                    else if (context.CirclesInRow == 1 && context.EmptyInRow == 3)
                    {
                        context.PartialResults.OneCircleInRow++;
                    }
                }
            }
        }