コード例 #1
0
        public static string[] GetItems(SpecifierType specifierType, DateTimeFormatInfo dateTimeFormat)
        {
            switch (specifierType)
            {
            case SpecifierType.ddd:
                return(dateTimeFormat.AbbreviatedDayNames);

            case SpecifierType.dddd:
                return(dateTimeFormat.DayNames);

            case SpecifierType.MMM:
                return(dateTimeFormat.AbbreviatedMonthNames);

            case SpecifierType.MMMM:
                return(dateTimeFormat.MonthNames);

            case SpecifierType.t:
                string   amDesignator = dateTimeFormat.AMDesignator;
                string   pmDesignator = dateTimeFormat.PMDesignator;
                string[] items        = new string[] {
                    !string.IsNullOrEmpty(amDesignator) ? amDesignator.Substring(0, 1) : string.Empty,
                    !string.IsNullOrEmpty(pmDesignator) ? pmDesignator.Substring(0, 1) : string.Empty,
                };
                return(items);

            case SpecifierType.tt:
                return(new string[] {
                    dateTimeFormat.AMDesignator,
                    dateTimeFormat.PMDesignator,
                });

            default:
                throw new ArgumentOutOfRangeException("specifierType");
            }
        }
コード例 #2
0
 public SpecifierInfo(SpecifierType type, ValueType valueType, string symbol,
                      int max, bool matchesExtraSymbols)
     : this()
 {
     MatchesExtraSymbols = matchesExtraSymbols;
     MaxLength           = max;
     Symbol    = symbol;
     Type      = type;
     ValueType = valueType;
 }
コード例 #3
0
        }                                         // 0 for none, 1 for check, 2 for checkmate

        public Move(byte source, byte destination, PieceColour colour, Piece movingPiece,
                    MoveResult result, string fen, int checkOrCheckmate, SpecifierType specifierRequired = SpecifierType.None, PieceType?promoteTo = null)
        {
            Source            = source;
            Destination       = destination;
            Colour            = colour;
            MovingPiece       = movingPiece;
            SpecifierRequired = specifierRequired;
            PromoteTo         = promoteTo;
            Result            = result;
            FEN = fen;
            CheckOrCheckmate = checkOrCheckmate;
        }
コード例 #4
0
ファイル: BossFight.cs プロジェクト: Vipeax/RealmPlayers
            public DataPrecisionDetails(Old_RaidBossFight _BossFight, RealmDB _RealmDB)
            {
                m_FightPrecision       = (float)_BossFight.CalculatePrecision(_RealmDB.RD_IsPlayerFunc(_BossFight));
                m_HasResetsMidFight    = _BossFight.GetFightData().HasResetsMidFight();
                m_ContainCorruptSWSync = _BossFight.GetUnrealisticPlayerSpikes(_RealmDB.RD_GetPlayerIdentifierFunc(_BossFight)).Count != 0;
                m_AddonVersion         = _BossFight.GetFightData().AddonVersion;
                m_RecordedBy           = _BossFight.GetFightData().RecordedByPlayer;

                var timeSlices = _BossFight.GetFightData().TimeSlices;

                float bossPart1Percentage = 0.0f;
                float bossPart2Percentage = 0.0f;

                string startY = "Start_Y";

                if (_BossFight.GetBossName() == "Razorgore the Untamed" && (_BossFight.GetStartDateTime() < new DateTime(2014, 3, 12) || m_AddonVersion == "1.8.2" || m_AddonVersion == "1.8.1" || m_AddonVersion == "1.7"))
                {
                    startY = "Start_Y=Grethok the Controller";
                }
                for (int i = 0; i < timeSlices.Count; ++i)
                {
                    if (m_StartSpecifier != SpecifierType.YellSpecifier && timeSlices[i].IsStartEvent())
                    {
                        if (timeSlices[i].IsEvent(startY) == true)
                        {
                            m_StartSpecifier = SpecifierType.YellSpecifier;
                        }
                        else
                        {
                            m_StartSpecifier = SpecifierType.HealthSpecifier;
                        }
                    }
                    if (m_HealthPercentageFirstSeen < 0.99f && timeSlices[i].IsBossHealthEvent())
                    {
                        if (_BossFight.GetBossName() == "C'Thun")
                        {
                            float eyeofcthunMax = timeSlices[i].GetTotalBossPercentage("Eye of C'Thun", true) * 0.5f;
                            if (eyeofcthunMax > bossPart1Percentage)
                            {
                                bossPart1Percentage = eyeofcthunMax;
                            }
                            float cthunMax = timeSlices[i].GetTotalBossPercentage("C'Thun", true) * 0.5f;
                            if (cthunMax > bossPart2Percentage)
                            {
                                bossPart2Percentage = cthunMax;
                            }
                            if (bossPart1Percentage + bossPart2Percentage > m_HealthPercentageFirstSeen)
                            {
                                m_HealthPercentageFirstSeen = bossPart1Percentage + bossPart2Percentage;
                            }
                        }
                        else
                        {
                            var healthPercentage = timeSlices[i].GetTotalBossPercentage(_BossFight.GetBossName());
                            if (healthPercentage > m_HealthPercentageFirstSeen)
                            {
                                m_HealthPercentageFirstSeen = healthPercentage;
                            }
                        }
                    }
                    if (m_EndSpecifier != SpecifierType.YellSpecifier && timeSlices[i].IsDeadEvent())
                    {
                        if (timeSlices[i].IsEvent("Dead_Y") == true)
                        {
                            m_EndSpecifier = SpecifierType.YellSpecifier;
                            break;
                        }
                        else
                        {
                            m_EndSpecifier = SpecifierType.HealthSpecifier;
                        }
                    }
                }
            }
コード例 #5
0
        public static List <Tuple <Move, string> > getPossibleMoveNotations(Board gameBoard)
        {
            List <Tuple <Move, string> > possibleMoveNotations = new List <Tuple <Move, string> >();

            for (int i = 0; i < gameBoard.Squares.Length; i++)
            {
                if (gameBoard.Squares[i].Piece != null)
                {
                    for (int j = 0; j < gameBoard.Squares[i].Piece.LegalMoves.Count; j++)
                    {
                        SpecifierType disambiguationNeeded = checkDisabiguationNeeded(gameBoard, (byte)i, gameBoard.Squares[i].Piece.LegalMoves[j]);

                        Board      copiedBoard = new Board(gameBoard, true);
                        MoveResult result      = MoveResult.None;
                        if ((gameBoard.Squares[i].Piece.Type == PieceType.Pawn) && (Array.IndexOf(copiedBoard.pawnPromotionDestinations, gameBoard.Squares[i].Piece.LegalMoves[j]) != -1))
                        {
                            //Promotion
                            result = copiedBoard.MakeMove((byte)i, gameBoard.Squares[i].Piece.LegalMoves[j], PieceType.Queen);

                            string copiedBoardFEN = copiedBoard.ToFEN();

                            int        checkOrCheckmate = 0;
                            GameStatus mateState        = copiedBoard.CheckForMate();
                            if (mateState == GameStatus.WhiteCheckmate || mateState == GameStatus.BlackCheckmate)
                            {
                                checkOrCheckmate = 2;
                            }
                            else if (copiedBoard.WhiteCheck || copiedBoard.BlackCheck)
                            {
                                checkOrCheckmate = 1;
                            }

                            Move newMove = new Move((byte)i, gameBoard.Squares[i].Piece.LegalMoves[j], gameBoard.Squares[i].Piece.Colour, gameBoard.Squares[i].Piece,
                                                    result, copiedBoardFEN, checkOrCheckmate, disambiguationNeeded, PieceType.Queen);
                            Tuple <Move, string> newTuple = new Tuple <Move, string>(newMove, MoveToNotation(newMove));
                            possibleMoveNotations.Add(newTuple);
                            newMove = new Move((byte)i, gameBoard.Squares[i].Piece.LegalMoves[j], gameBoard.Squares[i].Piece.Colour, gameBoard.Squares[i].Piece,
                                               result, copiedBoardFEN, checkOrCheckmate, disambiguationNeeded, PieceType.Rook);
                            newTuple = new Tuple <Move, string>(newMove, MoveToNotation(newMove));
                            possibleMoveNotations.Add(newTuple);
                            newMove = new Move((byte)i, gameBoard.Squares[i].Piece.LegalMoves[j], gameBoard.Squares[i].Piece.Colour, gameBoard.Squares[i].Piece,
                                               result, copiedBoardFEN, checkOrCheckmate, disambiguationNeeded, PieceType.Bishop);
                            newTuple = new Tuple <Move, string>(newMove, MoveToNotation(newMove));
                            possibleMoveNotations.Add(newTuple);
                            newMove = new Move((byte)i, gameBoard.Squares[i].Piece.LegalMoves[j], gameBoard.Squares[i].Piece.Colour, gameBoard.Squares[i].Piece,
                                               result, copiedBoardFEN, checkOrCheckmate, disambiguationNeeded, PieceType.Knight);
                            newTuple = new Tuple <Move, string>(newMove, MoveToNotation(newMove));
                            possibleMoveNotations.Add(newTuple);
                        }
                        else
                        {
                            result = copiedBoard.MakeMove((byte)i, gameBoard.Squares[i].Piece.LegalMoves[j]);

                            string copiedBoardFEN = copiedBoard.ToFEN();

                            int        checkOrCheckmate = 0;
                            GameStatus mateState        = copiedBoard.CheckForMate();
                            if (mateState == GameStatus.WhiteCheckmate || mateState == GameStatus.BlackCheckmate)
                            {
                                checkOrCheckmate = 2;
                            }
                            else if (copiedBoard.WhiteCheck || copiedBoard.BlackCheck)
                            {
                                checkOrCheckmate = 1;
                            }

                            Move newMove = new Move((byte)i, gameBoard.Squares[i].Piece.LegalMoves[j], gameBoard.Squares[i].Piece.Colour, gameBoard.Squares[i].Piece,
                                                    result, copiedBoardFEN, checkOrCheckmate, disambiguationNeeded, null);
                            Tuple <Move, string> newTuple = new Tuple <Move, string>(newMove, MoveToNotation(newMove));
                            possibleMoveNotations.Add(newTuple);
                        }
                    }
                }
            }
            return(possibleMoveNotations);
        }
コード例 #6
0
 public string[] GetItems(SpecifierType specifierType)
 {
     return(GetItems(specifierType, this.DateTimeFormat));
 }
コード例 #7
0
        protected void OnPieceClick(object o, ButtonPressEventArgs args)
        {
            double transx = Math.Abs((BoardArea.Allocation.Width - (boardBackground.Width * 0.75))) / 2;

            PointD clickLocation = new PointD(args.Event.X - transx, args.Event.Y - transx);

            if (clickLocation.X < 30 || clickLocation.Y < 30 ||
                clickLocation.X > 522 || clickLocation.Y > 522)
            {
                return;
            }

            PointD pieceLocation = PieceDisplay.pieceCoordinates [0];
            int    pieceIndex    = 0;

            for (int i = 0; i < PieceDisplay.pieceCoordinates.Length; i++)
            {
                PointD p  = PieceDisplay.pieceCoordinates[i];
                double x1 = p.X * 0.75;
                double y1 = p.Y * 0.75;
                double x2 = x1 + 61.5;
                double y2 = y1 + 61.5;
                if (x1 <= clickLocation.X && clickLocation.X <= x2)
                {
                    if (y1 <= clickLocation.Y && clickLocation.Y <= y2)
                    {
                        pieceLocation = p;
                        pieceIndex    = MainClass.BoardOrientation == PieceColour.White ? i : Math.Abs(i - 63);
                        break;
                    }
                }
            }

            if (currentSelectionState == PieceSelectionState.None)
            {
                if (MainClass.CurrentBoard.Squares [pieceIndex].Piece == null)
                {
                    return;
                }
                selectedPiece = (byte)pieceIndex;

                boardContext = Gdk.CairoHelper.Create(BoardArea.GdkWindow);
                boardContext.Translate(transx, 0);
                boardContext.Scale(0.75, 0.75);
                selectionBorder.Show(boardContext, pieceLocation.X + 1, pieceLocation.Y + 1);
                boardContext.Dispose();
                currentSelectionState = PieceSelectionState.Selected;
            }
            else
            {
                if (!MainClass.CurrentBoard.IsMoveValid(selectedPiece, (byte)pieceIndex))
                {
                    currentSelectionState = PieceSelectionState.None;
                    Gtk.Application.Invoke(delegate {
                        RedrawBoard();
                    });
                    return;
                }

                if (MainClass.CurrentGameStatus != GameStatus.Active &&
                    MainClass.CurrentGameStatus != GameStatus.Inactive)
                {
                    Console.Error.WriteLine("(EE) Attempted move during finished game.");
                    MessageDialog errorDialog = new MessageDialog(
                        this,
                        DialogFlags.DestroyWithParent,
                        MessageType.Error,
                        ButtonsType.Ok,
                        "The game is over!");
                    errorDialog.Run();
                    errorDialog.Destroy();
                    return;
                }

                // Handle pawn promotion
                PieceType?promoteTo = null;
                if (MainClass.CurrentBoard.Squares [selectedPiece].Piece.Type == PieceType.Pawn &&
                    MainClass.CurrentBoard.IsMoveValid(selectedPiece, (byte)pieceIndex) &&
                    Array.IndexOf(MainClass.CurrentBoard.pawnPromotionDestinations, (byte)pieceIndex) != -1)
                {
                    PawnPromotionDialog dialog = new PawnPromotionDialog();
                    if (dialog.Run() == (int)Gtk.ResponseType.Ok)
                    {
                        promoteTo = dialog.PromoteTo;
                    }
                    else
                    {
                        dialog.Destroy();
                        return;
                    }
                    dialog.Destroy();
                }

                try {
                    SpecifierType specifierRequired = GameHistory.checkDisabiguationNeeded(MainClass.CurrentBoard, selectedPiece, (byte)pieceIndex);
                    MoveResult    result            = MainClass.CurrentBoard.MakeMove(selectedPiece, (byte)pieceIndex, promoteTo);

                    Piece movingPiece = null;
                    if (promoteTo == null)
                    {
                        movingPiece = MainClass.CurrentBoard.Squares[(byte)pieceIndex].Piece;
                    }
                    else
                    {
                        movingPiece = new Piece(MainClass.CurrentBoard.Squares [(byte)pieceIndex].Piece.Colour, PieceType.Pawn);
                    }

                    if (result == MoveResult.Capture && movingPiece.Type == PieceType.Pawn)
                    {
                        specifierRequired = SpecifierType.File;
                    }

                    int        checkOrCheckmate = 0;
                    GameStatus mateState        = MainClass.CurrentBoard.CheckForMate();
                    if (mateState == GameStatus.WhiteCheckmate || mateState == GameStatus.BlackCheckmate)
                    {
                        checkOrCheckmate = 2;
                    }
                    else if (MainClass.CurrentBoard.WhiteCheck || MainClass.CurrentBoard.BlackCheck)
                    {
                        checkOrCheckmate = 1;
                    }

                    string fenPosition = MainClass.CurrentBoard.ToFEN().Split(' ')[0];
                    MainClass.CurrentGameHistory.AddMove(new Move(selectedPiece, (byte)pieceIndex,
                                                                  MainClass.CurrentBoard.Squares [(byte)pieceIndex].Piece.Colour,
                                                                  movingPiece,
                                                                  result,
                                                                  MainClass.CurrentBoard.ToFEN(),
                                                                  checkOrCheckmate,
                                                                  specifierRequired,
                                                                  promoteTo), fenPosition);
                    UpdateGameHistoryView();

                    if (MainClass.CurrentGameHistory.UpdateFiftyMoveCount(result) == GameStatus.DrawFifty)
                    {
                        MainClass.CurrentGameStatus = GameStatus.DrawFifty;
                    }
                    else if (MainClass.CurrentGameHistory.CheckThreefoldRepetition() == GameStatus.DrawRepetition)
                    {
                        MainClass.CurrentGameStatus = GameStatus.DrawRepetition;
                    }
                } catch (InvalidOperationException) {
                }
                Gtk.Application.Invoke(delegate {
                    RedrawBoard();
                });
                GameStatus isMate = MainClass.CurrentBoard.CheckForMate();
                if (isMate != GameStatus.Active)
                {
                    MainClass.CurrentGameStatus = isMate;
                }
                if (MainClass.CurrentGameStatus != GameStatus.Active && MainClass.CurrentGameStatus != GameStatus.Inactive)
                {
                    ShowGameOverDialog(MainClass.CurrentGameStatus);
                }

                if (MainClass.CurrentGameStatus == GameStatus.Inactive)
                {
                    MainClass.CurrentGameStatus = GameStatus.Active;
                }

                Gtk.Application.Invoke(delegate {
                    MainClass.UpdateClock();
                    UpdatePlayerToMove();
                });

                currentSelectionState = PieceSelectionState.None;
            }
        }