Exemple #1
0
 public int GetDistance(Position position)
 {
     int dx = Math.Abs(position.X - X);
     int dy = Math.Abs(position.Y - Y);
     int dz = Math.Abs(position.Z - Z);
     int distance = Math.Max(Math.Max(dx, dy), dz);
     return distance;
 }
Exemple #2
0
 public override void FilterMovementMap(Position initialPosition, PlayerColour colour, HashSet<Position> map)
 {
     int direction = colour == PlayerColour.Black ? 1 : -1;
     foreach (Position position in map)
     {
         int yDirection = direction * (position.Y - initialPosition.Y);
         if (yDirection < 1 && initialPosition.GetDistance(position) > 1)
             map.Remove(position);
     }
 }
Exemple #3
0
 public override void FilterMovementMap(Position initialPosition, PlayerColour colour, HashSet<Position> map)
 {
     foreach (Position position in map)
     {
         int axesUsed = 0;
         if (position.X != initialPosition.X)
             axesUsed++;
         if (position.Y != initialPosition.Y)
             axesUsed++;
         if (position.Z != initialPosition.Z)
             axesUsed++;
         if (axesUsed!= 2)
             map.Remove(position);
     }
 }
Exemple #4
0
 public override void FilterMovementMap(Position initialPosition, PlayerColour colour, HashSet<Position> map)
 {
     foreach (Position position in map)
     {
         if (initialPosition.GetDistance(position) == 2)
             map.Remove(position);
     }
 }
Exemple #5
0
 public virtual void FilterMovementMap(Position initialPosition, PlayerColour colour, HashSet<Position> map)
 {
 }
Exemple #6
0
        void RenderBoard()
        {
            const ConsoleColor labelColour = ConsoleColor.White;
            const ConsoleColor boardColour = ConsoleColor.DarkGray;
            const ConsoleColor blackColour = ConsoleColor.Red;
            const ConsoleColor whiteColour = ConsoleColor.Yellow;

            Dictionary<PieceTypeIdentifier, string> pieceSymbols = new Dictionary<PieceTypeIdentifier, string>()
            {
                {PieceTypeIdentifier.Pawn, "P"},
                {PieceTypeIdentifier.Martyr, "M"},
                {PieceTypeIdentifier.Guardian, "G"},
                {PieceTypeIdentifier.Lance, "C"},
                {PieceTypeIdentifier.Serpent, "S"},
            };

            const string emptyHex = "o";
            const string genericFiller = "--";
            const string verticalFillerLeft = "- ";
            const string verticalFillerRight = " -";

            string space = "";
            for (int i = 0; i < GameConstants.GridSizeX * 2; i++)
                space += " ";
            string xLabels = GetXLabels();
            Write(space + xLabels + "\n", labelColour);
            for (int row = GameConstants.GridSizeY; row >= 1; row--)
            {
                string leftLabel = row.ToString();
                while (leftLabel.Length < row * 2)
                    leftLabel = " " + leftLabel;
                leftLabel += " ";
                string rightLabel = " " + row.ToString();
                Write(leftLabel, labelColour);
                for (int column = 1; column <= GameConstants.GridSizeX; column++)
                {
                    Position position = new Position(row, column);
                    Hex hex = Messenger.Game.GetHex(position);
                    if (hex.Piece == null)
                        Write(emptyHex, boardColour);
                    else
                    {
                        Piece piece = hex.Piece;
                        ConsoleColor colour = piece.Owner.Colour == PlayerColour.Black ? blackColour : whiteColour;
                        string symbol = pieceSymbols[piece.Type.Identifier];
                        Write(symbol, colour);
                    }
                    if (column < GameConstants.GridSizeX)
                    {
                        if (column == GameConstants.GridSizeX / 2)
                            Write(verticalFillerLeft, boardColour);
                        else if (column == GameConstants.GridSizeX / 2 + 1)
                            Write(verticalFillerRight, boardColour);
                        else
                            Write(genericFiller, boardColour);
                    }
                }
                Write(rightLabel + "\n", labelColour);
            }
            Write("  " + xLabels + "\n", labelColour);
            Console.ForegroundColor = ConsoleColor.Gray;
        }
Exemple #7
0
 public Hex(Position position)
 {
     Position = position;
     Piece = null;
     Neighbours = new List<Hex>();
 }
Exemple #8
0
 public PiecePromotion(Position location, PieceTypeIdentifier promotion)
 {
     Position = location;
     Type = promotion;
 }
Exemple #9
0
 public PieceMove(Position source, Position destination)
 {
     Source = source;
     Destination = destination;
 }
Exemple #10
0
 public void PromotePiece(Position position, PieceTypeIdentifier type)
 {
     position.CheckValidity();
     if (CurrentTurnActions >= GameConstants.ActionsPerTurn)
         throw new GameException("You may not perform any more actions this turn");
     Hex hex = GetHex(position);
     Piece piece = hex.Piece;
     if (piece == null)
         throw new GameException("There is no piece to promote, the specified hex is empty");
     if (piece.Type.Identifier != PieceTypeIdentifier.Pawn)
         throw new GameException("Only pawns may be promoted");
     if (!piece.CanMove)
         throw new GameException("This piece has already been moved this turn and can hence not be promoted");
     if(type == PieceTypeIdentifier.Pawn)
         throw new GameException("Invalid promotion identifier");
     bool isClear = true;
     foreach (Hex neighbour in hex.Neighbours)
     {
         Piece neighbourPiece = neighbour.Piece;
         if (neighbourPiece != null && !object.ReferenceEquals(neighbourPiece.Owner, CurrentTurnPlayer))
         {
             isClear = false;
             break;
         }
     }
     if (!isClear)
         throw new GameException("You cannot promote a piece that is in direct proximity of an opponent's piece");
     Piece newPiece = new Piece(GameConstants.Pieces[type], CurrentTurnPlayer);
     hex.Piece = newPiece;
     newPiece.Hex = hex;
     newPiece.CanMove = false;
     piece.Hex = null;
     CurrentTurnActions++;
 }
Exemple #11
0
 public Hex GetHex(Position position)
 {
     position.CheckValidity();
     int index = position.X + position.Y * GameConstants.GridSizeX;
     return _Grid[index];
 }
Exemple #12
0
 List<Hex> GetZoneOfControl(Player player)
 {
     int initial;
     int direction;
     if (player.Colour == PlayerColour.Black)
     {
         initial = 0;
         direction = 1;
     }
     else
     {
         initial = GameConstants.GridSizeY - 1;
         direction = -1;
     }
     List<Hex> zone = new List<Hex>();
     for (int x = 0; x < GameConstants.GridSizeX; x++)
     {
         int? maximum = null;
         for (int y = initial; y >= 0 && y < GameConstants.GridSizeY; y += direction)
         {
             Position position = new Position(x, y);
             if (!position.IsValid())
                 break;
             Hex hex = GetHex(position);
             Piece piece = hex.Piece;
             if (piece == null)
                 continue;
             else if (object.ReferenceEquals(piece.Owner, player))
                 maximum = y;
             else
                 break;
         }
         if (maximum == null)
             continue;
         for (int y = initial; ; y += direction)
         {
             Position position = new Position(x, y);
             Hex hex = GetHex(position);
             zone.Add(hex);
             if (y == maximum)
                 break;
         }
     }
     return zone;
 }
Exemple #13
0
 void DeployPawns(Player player)
 {
     int firstRankY;
     int secondRankY;
     int secondRankInitialX;
     int secondRankFinalX;
     if(player.Colour == PlayerColour.Black)
     {
         firstRankY = 2;
         secondRankY = 1;
         secondRankInitialX = 6;
         secondRankFinalX = 12;
     }
     else
     {
         firstRankY = 6;
         secondRankY = 7;
         secondRankInitialX = 0;
         secondRankFinalX = 6;
     }
     for (int x = 0; x < GameConstants.GridSizeX; x++)
     {
         Position position = new Position(x, firstRankY);
         DeployPawn(position, player);
     }
     for (int x = secondRankInitialX; x <= secondRankFinalX; x++)
     {
         Position position = new Position(x, secondRankY);
         DeployPawn(position, player);
     }
 }
Exemple #14
0
 void DeployPawn(Position position, Player player)
 {
     Hex hex = GetHex(position);
     Piece piece = new Piece(GameConstants.Pieces[PieceTypeIdentifier.Pawn], player);
     player.Pieces.Add(piece);
     hex.Piece = piece;
 }
Exemple #15
0
 void CreateGrid()
 {
     _Grid = new List<Hex>();
     for (int y = 0; y < GameConstants.GridSizeY; y++)
     {
         for (int x = 0; x < GameConstants.GridSizeX; x++)
         {
             Position position = new Position(x, y);
             Hex hex = new Hex(position);
             _Grid.Add(hex);
         }
     }
     foreach (Hex hex in _Grid)
     {
         foreach (Position offset in Position.NeighbourOffsets)
         {
             Position position = hex.Position + offset;
             if (position.IsValid())
             {
                 Hex neighbour = GetHex(position);
                 hex.Neighbours.Add(hex);
             }
         }
     }
 }
Exemple #16
0
 public PiecePlacement(PieceTypeIdentifier type, Position position)
 {
     Type = type;
     Position = position;
 }
Exemple #17
0
 public void MovePiece(Position source, Position destination)
 {
     source.CheckValidity();
     destination.CheckValidity();
     if (source.Equals(destination))
         throw new GameException("Tried to move a piece to its current location");
     if (CurrentTurnActions >= GameConstants.ActionsPerTurn)
         throw new GameException("You have already performed the maximum number of actions in this turn");
     Hex sourceHex = GetHex(source);
     Hex destinationHex = GetHex(destination);
     Piece attacker = sourceHex.Piece;
     Piece defender = destinationHex.Piece;
     if (attacker == null)
         throw new GameException("There is no piece on the specified hex");
     if (attacker.Owner != CurrentTurnPlayer)
         throw new GameException("Tried to move a piece of the opponent");
     if (!attacker.CanMove)
         throw new GameException("Tried to move a piece that had already been used in this turn");
     if (!PieceCanReachHex(attacker, destinationHex))
         throw new GameException("The piece is unable to reach the destination");
     if (defender != null)
     {
         if (attacker.Owner == defender.Owner)
             throw new GameException("You cannot capture your own pieces");
         int attackSum = GetAttackSum(attacker, defender);
         if (attackSum < defender.Type.Defence)
             throw new GameException("Your attack is too weak to capture this piece");
         attacker.Owner.Captures.Add(defender.Type);
         defender.Owner.Pieces.Remove(defender);
     }
     attacker.Hex = destinationHex;
     sourceHex.Piece = null;
     destinationHex.Piece = attacker;
     attacker.CanMove = false;
     CurrentTurnActions++;
 }