public System.Drawing.Color PickRandomColor() { Array values = Enum.GetValues(typeof(ColorsEnum)); ColorsEnum randomColorKey = (ColorsEnum)values.GetValue(StaticRandom.Instance.Next(values.Length)); return(Colors[randomColorKey]); }
/// <summary> /// Returns a consistent index into an array size NUMBER_OF_COLORS. /// </summary> /// <returns> /// The index value for the color /// </returns> /// <param name='c'> /// The color to index into /// </param> /// <exception cref='NotImplementedException'> /// Is thrown if <see cref="ColorsEnum"/> is not consistent with this implementation. /// </exception> public static int ColorsEnumToIndex(ColorsEnum c) { switch (c) { case ColorsEnum.White: return(0); case ColorsEnum.Blue: return(1); case ColorsEnum.Black: return(2); case ColorsEnum.Red: return(3); case ColorsEnum.Green: return(4); case ColorsEnum.Colorless: return(5); } throw new NotImplementedException("Update this function to match ColorsEnum!"); }
public static bool isCheck(ColorsEnum color, GameManager gameManager) { Square kingSquare = GetKingSquareForPlayer(color, gameManager); List <Piece> attackingPieces = gameManager.getPiecesOfColor(Utils.NegateColor(color)); return(IsSquareUnderAttack(attackingPieces, kingSquare)); }
/// <summary> /// Sets the colors. /// </summary> /// <returns> /// The colors. /// </returns> /// <param name='c'> /// The ColorEnum to set. /// </param> /// <param name='manaCost'> /// Mana cost string to parse. /// </param> public static ColorsEnum SetColors(this ColorsEnum c, string manaCost) { string lmanaCost = manaCost.ToLower(); if (lmanaCost.Contains("w")) { c |= ColorsEnum.White; } if (lmanaCost.Contains("u")) { c |= ColorsEnum.Blue; } if (lmanaCost.Contains("b")) { c |= ColorsEnum.Black; } if (lmanaCost.Contains("r")) { c |= ColorsEnum.Red; } if (lmanaCost.Contains("g")) { c |= ColorsEnum.Green; } return(c); }
static string PrepareStringForColor(string elementTypeInCSharp, string valueAsString) { try { int colorAsInt; // Check if the color is a named color: if (!valueAsString.StartsWith("#")) { ColorsEnum namedColor = (ColorsEnum)Enum.Parse(typeof(ColorsEnum), valueAsString, true); colorAsInt = (int)namedColor; } else { valueAsString = valueAsString.Replace("#", ""); if (valueAsString.Length == 6) // This is becaue XAML is tolerant when the user has forgot the alpha channel (eg. #DDDDDD for Gray). { valueAsString = "FF" + valueAsString; } colorAsInt = int.Parse(valueAsString.Replace("#", ""), NumberStyles.HexNumber); } string result = string.Format("new {0}() {{ A = (byte){1}, R = (byte){2}, G = (byte){3}, B = (byte){4} }}", elementTypeInCSharp, //{0} (colorAsInt >> 0x18) & 0xff, //{1} (colorAsInt >> 0x10) & 0xff, //{2} (colorAsInt >> 8) & 0xff, //{3} colorAsInt & 0xff); //{4} return(result); } catch (Exception ex) { throw new wpf::System.Windows.Markup.XamlParseException("Invalid color: " + valueAsString, ex); } }
public static Square GetKingSquareForPlayer(ColorsEnum playerColor, GameManager gameManager) { Piece king = gameManager.getPiecesOfColor(playerColor).Find(piece => piece.Type == PieceControllerType.KING); char chessNotationX = ConvertLineToChessNotation((int)king.coordinates.x); char chessNotationY = ConvertColumnToChessNotation((int)king.coordinates.y); char[] charKey = { chessNotationY, chessNotationX }; return(Board.SquareMapping[new string(charKey)]); }
void ToggleAtMove() { if (AtMove == ColorsEnum.BLACK) { AtMove = ColorsEnum.WHITE; } else { AtMove = ColorsEnum.BLACK; } }
public void ChangeTurn() { if (ColorsTurn == ColorsEnum.White) { ColorsTurn = ColorsEnum.Black; } else { ColorsTurn = ColorsEnum.White; } }
public StackObject(StackObjectType objectType, string typeString, string text, Player owner, Player controller, ColorsEnum colors, GameActionDelegate resolutionAction) { ObjectType = objectType; TypeString = typeString; Text = text; Owner = owner; Controller = controller; Colors = colors; ResolutionAction = resolutionAction; }
/// <summary> /// Returns true if c is multicolored /// </summary> /// <param name='c'> /// The ColorEnum to check. /// </param> public static bool Multicolor(this ColorsEnum c) { // determine if it's multicolor by checking if c is a power of 2 or a power of 2 + 1 double cInDouble = (double)c; double logC = Math.Log(cInDouble, 2); double logCMinus1 = Math.Log(cInDouble - 1, 2); if (cInDouble != 0 && (logC - Math.Truncate(logC) == 0 || logCMinus1 - Math.Truncate(logCMinus1) == 0)) { return(true); } return(false); }
public void ChangeTurn() { IChessTimer ct = new StandardChessTimer(new StandardPlayer("A"), new StandardPlayer("B")); ColorsEnum startingTurnColor = ct.ColorsTurn; ColorsEnum secondTurnColor, thirdTurnColor; ct.ChangeTurn(); secondTurnColor = ct.ColorsTurn; ct.ChangeTurn(); thirdTurnColor = ct.ColorsTurn; Assert.Equal(ColorsEnum.White, startingTurnColor); Assert.Equal(ColorsEnum.Black, secondTurnColor); Assert.Equal(ColorsEnum.White, thirdTurnColor); }
void HandleEndTurnEvent(ColorsEnum colorAtMove, bool isCheck) { if (colorAtMove != playerColor) { if (isCheck == true) { playerStatus.text = PlayerStatusConstants.IN_CHECK; playerStatus.color = Color.red; } else { playerStatus.text = PlayerStatusConstants.THINKING; } } else { playerStatus.text = PlayerStatusConstants.NO_STATUS; } }
public bool VerifyKingPosition(IChessPiece pieceMoved, string finalPositionString, List <IChessPiece> chessPieces, ColorsEnum colorChecked) { Position finalPosition = new Position(finalPositionString); IChessPiece currentKing = chessPieces.Where(cp => cp.Name == "King" && cp.Color == colorChecked).FirstOrDefault(); //Create a piece that will temporarily replace piece that is moving but at the final position IChessPiece dummyPiece = new Pawn((int)colorChecked, finalPositionString); if (currentKing == pieceMoved) { dummyPiece = new King((int)colorChecked, finalPositionString); } IChessPiece pieceTaken = chessPieces.Where(cp => cp.Position.ColumnPosition == finalPosition.ColumnPosition && cp.Position.RowPosition == finalPosition.RowPosition).FirstOrDefault(); chessPieces.Remove(pieceMoved); //if(pieceTaken != null) chessPieces.Remove(pieceTaken); chessPieces.Add(dummyPiece); //Check if after the fake move king of the moving color is checked bool result = VerifyPosition(currentKing.Position, chessPieces, colorChecked); //If king is the moving piece we have to verify the new position if (dummyPiece.Name == "King") { result = VerifyPosition(dummyPiece.Position, chessPieces, colorChecked); } //Remove dummy and give back the pieces that were there at the beggining so that the reference type data won t be changed chessPieces.Remove(dummyPiece); if (pieceMoved != null) { chessPieces.Add(pieceMoved); } if (pieceTaken != null) { chessPieces.Add(pieceTaken); } return(result); }
public Bitmap[] ExtractCharacters(Bitmap imageBitmap, ColorsEnum?color = null) { ImageToMatrix imageToMatrix = new ImageToMatrix(); imageBitmap = new Bitmap(imageBitmap, new Size(260, 51)); List <Bitmap> charactersBitmap = new List <Bitmap>(); foreach (int delimiter in _delimiters) { Bitmap character = imageBitmap .Clone(new Rectangle { X = delimiter, Y = 8, Width = 27, Height = 29 }, imageBitmap.PixelFormat); charactersBitmap.Add(character); } if (color != null) { List <Bitmap> charactersBitmapColor = new List <Bitmap>(); foreach (Bitmap character in charactersBitmap) { imageToMatrix.Convert(character, out Color[][] imageColors); Color characterColor = imageColors.SelectMany(c => c).GroupBy(c => c.Name).OrderByDescending(g => g.Count()).ElementAt(1).ElementAt(0); ColorsEnum result = ColorDecoder.Decode(characterColor); if (result.Equals(color)) { charactersBitmapColor.Add(character); } } charactersBitmap = charactersBitmapColor; } return(charactersBitmap.ToArray()); }
public ColorsEnum?Verify() { //Check if king will be checked after the current move List <IChessPiece> currentColorPieces = Game.chessBoard.ChessPiecesOnBoard.Where(cp => cp.Color == Game.chessTimer.ColorsTurn).ToList(); List <string> currentColorPiecesPositions = currentColorPieces.Select(cp => cp.Position.ToString()).ToList(); foreach (string positionString in currentColorPiecesPositions) { int boardHightBoundary = Game.chessBoard.UpperRightCorner.RowPosition; int boardWidthBoundary = Game.chessBoard.UpperRightCorner.ColumnPosition; for (int i = 1; i <= boardWidthBoundary; i++) { for (int j = 1; j <= boardHightBoundary; j++) { var movedPiece = Game.chessBoard.GetAPieceFromPosition(positionString); bool isMovePossible = movedPiece.IsMovePossible(i, j, Game.chessBoard.ChessPiecesOnBoard); if (!isMovePossible) { continue; } Position finalPosition = new Position(i, j); bool willKingBeChecked = positionCheckedVerifier.VerifyKingPosition(movedPiece, finalPosition.ToString(), Game.chessBoard.ChessPiecesOnBoard, Game.chessTimer.ColorsTurn); if (!willKingBeChecked && isMovePossible) { return(null); } } } } ColorsEnum currentColor = Game.chessTimer.ColorsTurn; return(currentColor == ColorsEnum.White ? ColorsEnum.Black : ColorsEnum.White); }
public static GameObject InstantiatePieceAndPlaceOnSquare(string name, PieceControllerType type, ColorsEnum color, string destinationSquare) { GameObject newPiece = Utils.CreatePieceGameObject(name, type, color); Square square = Board.SquareMapping[destinationSquare]; Utils.PlaceOnObject(newPiece, square.gameObject); return(newPiece); }
public static GameObject CreatePieceGameObject(string name, PieceControllerType type, ColorsEnum color) { GameObject newGameObject = new GameObject(name); newGameObject.AddComponent <Piece>(); Piece PieceComponent = newGameObject.GetComponent <Piece>(); PieceComponent.IPiece = PieceFactory.createInstance(type); PieceComponent.Type = type; PieceComponent.SetColor(color); return(newGameObject); }
public bool IsAvailableForMove(ColorsEnum pieceColor) { return(GetPiece() == null || GetPiece().GetColor() != pieceColor); }
public bool VerifyPosition(string positionString, List <IChessPiece> chessPieces, ColorsEnum colorChecked) { Position position = new Position(positionString); return(VerifyPosition(position, chessPieces, colorChecked)); }
public int this[ColorsEnum color] { get { return(pool[Conversions.ColorsEnumToIndex(color)]); } set { pool[Conversions.ColorsEnumToIndex(color)] = value; } }
/// <summary> /// Returns a consistent index into an array size NUMBER_OF_COLORS. /// </summary> /// <returns> /// The index value for the color /// </returns> /// <param name='c'> /// The color to index into /// </param> /// <exception cref='NotImplementedException'> /// Is thrown if <see cref="ColorsEnum"/> is not consistent with this implementation. /// </exception> public static int ColorsEnumToIndex(ColorsEnum c) { switch(c) { case ColorsEnum.White: return 0; case ColorsEnum.Blue: return 1; case ColorsEnum.Black: return 2; case ColorsEnum.Red: return 3; case ColorsEnum.Green: return 4; case ColorsEnum.Colorless: return 5; } throw new NotImplementedException("Update this function to match ColorsEnum!"); }
public void SetColor(ColorsEnum value) { color = value; }
public int this[ColorsEnum color] { get { return pool[Conversions.ColorsEnumToIndex(color)]; } set { pool[Conversions.ColorsEnumToIndex(color)] = value; } }
void HandleEndTurnEvent(ColorsEnum colorAtMove, bool isCheck) { Utils.ToggleDraggableForPieces(FindObjectsOfType <Piece>()); ToggleAtMove(); // HandlePossibleChess(colorAtMove); }
public bool VerifyPosition(Position position, List <IChessPiece> chessPieces, ColorsEnum colorChecked) { bool IsPositionChecked = false; List <IChessPiece> enemyChessPieces = chessPieces.Where(cp => cp.Color != colorChecked).ToList(); foreach (IChessPiece cp in enemyChessPieces) { if (cp.IsMovePossible(position.ColumnPosition, position.RowPosition, chessPieces)) { IsPositionChecked = true; break; } } return(IsPositionChecked); }
public List <Piece> getPiecesOfColor(ColorsEnum color) { return(color == ColorsEnum.BLACK ? blackPieces : whitePieces); }
public Knight(ColorsEnum color, Tuple <int, int> position = null) { Color = color; Position = position != null ? position : new Tuple <int, int>(-1, -1); Symbol = '1'; }
public static ColorsEnum NegateColor(ColorsEnum color) { return(color == ColorsEnum.BLACK ? ColorsEnum.WHITE : ColorsEnum.BLACK); }
public string GetColor(ColorsEnum color) //public string GetColor(string color) { return(color.ToString()); }
/// <summary> /// Gets the number of mana symbols of the specified <see cref="ColorsEnum">color</see> /// </summary> /// <param name='color'> /// Color. /// </param> public int this[ColorsEnum color] { get { return(coloredSymbols[Conversions.ColorsEnumToIndex(color)]); } private set { coloredSymbols[Conversions.ColorsEnumToIndex(color)] = value; } }