public static bool TryParse
(
string?input,
[NotNullWhen(true)] out Colour?colour
)
{
colour = null;
if (input.IsNullOrWhitespace())
{
return(false);
}
// First, break the input up into parts based on spaces
var parts = input.Split(' ');
// Check for a modifier
ShadeModifier?modifier = null;
if (Enum.TryParse(parts[0], true, out ShadeModifier realModifier))
{
modifier = realModifier;
parts = parts.Skip(1).ToArray();
}
// Then check for a known shade
if (!Enum.TryParse(string.Join(string.Empty, parts), true, out Shade shade))
{
colour = null;
return(false);
}
colour = new Colour(shade, modifier);
return(true);
}
public THISListDIEExpression(
SkipWhitespaceToken a,
ColourToken target1Colour,
NameToken target1,
SkipWhitespaceToken b,
CommaToken c,
SkipWhitespaceToken d,
ColourToken target2Colour,
NameToken target2,
SkipWhitespaceToken e,
SquareCloseToken f,
SkipWhitespaceToken g,
DotToken h,
SkipWhitespaceToken i,
DIEToken j,
SkipWhitespaceToken k,
RoundOpenToken l,
SkipWhitespaceToken m,
RoundCloseToken n,
SkipWhitespaceToken o,
SemicolonToken p)
{
Target1 = target1.Name;
Target1Colour = target1Colour.Colour;
Target2 = target2.Name;
Target2Colour = target2Colour.Colour;
}
public Pair meet(int id, Colour c)
{
Future newPair;
lock (this) {
if (meetingsLeft == 0)
{
throw new Exception("Finished");
}
else
{
if (firstColour == null)
{
firstColour = c;
firstId = id;
current = new Future();
}
else
{
Colour newColour = doCompliment(c, firstColour.Value);
current.Item = new Pair(id == firstId, newColour);
firstColour = null;
meetingsLeft--;
}
newPair = current;
}
}
return(newPair.Item);
}
public bool PlaceOn(IField field, Colour?colour = null)
{
if (colour != null)
{
var jake = this.Type switch
{
PieceType.Pawn => (IPiece) new Pawn(colour.Value),
PieceType.Rook => new Rook(colour.Value),
PieceType.Knight => new Knight(colour.Value),
PieceType.Bishop => new Bishop(colour.Value),
PieceType.Queen => new Queen(colour.Value),
PieceType.King => new King(colour.Value),
_ => throw new Exception("foutje bedankt!"),
};
field.Piece = jake;
jake.Position = field;
}
else
{
field.Piece = this;
Position = field;
}
return(true);
}
public static _ATHToken Read(string source, ref int position)
{
Colour?colour = null;
if (source[position] == '#')
{
position++;
var r = byte.Parse(source.Substring(position, 2), System.Globalization.NumberStyles.AllowHexSpecifier);
position += 2;
var g = byte.Parse(source.Substring(position, 2), System.Globalization.NumberStyles.AllowHexSpecifier);
position += 2;
var b = byte.Parse(source.Substring(position, 2), System.Globalization.NumberStyles.AllowHexSpecifier);
position += 2;
colour = new Colour(r, g, b);
}
var name = new StringBuilder();
while (source.Length > position && char.IsLetterOrDigit(source, position))
{
name.Append(source[position]);
position++;
}
if (name.Length > 0)
{
return(new MaybeColouredNameToken(colour, name.ToString()));
}
else
{
throw new TokenException("Name expected at " + position + ".");
}
}
public static AppearanceComponent CopyFrom(AppearanceComponent other)
{
return(new AppearanceComponent(other.Transformation, other.Chirality)
{
BaseColour = Colour.CopyFrom(other.BaseColour),
Pattern = other.Pattern,
PatternColour = other.PatternColour is null ? null : Colour.CopyFrom(other.PatternColour),
});
public bool IsSameColourAs(Colour?other)
{
if (other is null)
{
return(false);
}
return(this.Shade == other.Shade && this.Modifier == other.Modifier);
}
public Block(Colour?left, Colour?right, Colour?top, Colour?bottom, Colour?front, Colour?back)
{
Left = left;
Right = right;
Top = top;
Bottom = bottom;
Front = front;
Back = back;
}
internal Slot(Node node, string name, SlotType type, InOut mode, Colour?colour = null)
{
Name = name;
Colour = colour ?? DefaultColour;
Type = type;
Mode = mode;
Node = node;
Index = mode == InOut.In ? node.InSlotCount++ : node.OutSlotCount++;
}
public void Reset()
{
for (var x = 0; x < BoardSize; x++)
{
for (var y = 0; y < BoardSize; y++)
{
_pieces[x, y] = null;
}
}
ColourOfSquareZeroZero = null;
}
public UserUpdateEvent(
IUser user,
string userName = null,
Colour?colour = null,
int?rank = null,
string nickName = null,
UserPermissions?perms = null,
UserStatus?status = null,
string statusMessage = null
) : base(user ?? throw new ArgumentNullException(nameof(user)))
{
OldUserName = user.UserName;
if (!OldUserName.Equals(userName))
{
NewUserName = userName;
}
OldColour = user.Colour;
if (!OldColour.Equals(colour))
{
NewColour = colour;
}
OldRank = user.Rank;
if (OldRank != rank)
{
NewRank = rank;
}
OldNickName = user.NickName;
if (!OldNickName.Equals(nickName))
{
NewNickName = nickName;
}
OldPerms = user.Permissions;
if (OldPerms != perms)
{
NewPerms = perms;
}
OldStatus = user.Status;
if (OldStatus != status)
{
NewStatus = status;
}
OldStatusMessage = user.StatusMessage;
if (!OldStatusMessage.Equals(statusMessage))
{
NewStatusMessage = statusMessage;
}
}
public ImportExpression(
SkipWhitespaceToken a,
MaybeColouredNameToken type,
SkipWhitespaceToken b,
MaybeColouredNameToken name,
SkipWhitespaceToken c,
SemicolonToken d)
{
Type = type.Name;
TypeColour = type.Colour;
Name = name.Name;
NameColour = name.Colour;
}
public DIEExpression(
MaybeColouredNameToken target,
SkipWhitespaceToken a,
DotToken b,
SkipWhitespaceToken c,
DIEToken d,
SkipWhitespaceToken e,
RoundOpenToken f,
SkipWhitespaceToken g,
RoundCloseToken h,
SkipWhitespaceToken i,
SemicolonToken j)
{
Target = target.Name;
TargetColour = target.Colour;
}
private static void PrintColour(Colour?colour)
{
Console.BackgroundColor = colour switch
{
Colour.Blue => ConsoleColor.DarkBlue,
Colour.Green => ConsoleColor.DarkGreen,
Colour.Red => ConsoleColor.DarkRed,
Colour.Orange => ConsoleColor.Red,
Colour.Yellow => ConsoleColor.DarkYellow,
Colour.White => ConsoleColor.White,
_ => Console.BackgroundColor
};
Console.Write(" ");
Console.ResetColor();
}
}
public UserUpdateEvent(
IUser user,
string userName = null,
Colour?colour = null,
int?rank = null,
string nickName = null,
UserPermissions?perms = null,
UserStatus?status = null,
string statusMessage = null
) : base(null, user ?? throw new ArgumentNullException(nameof(user)))
{
UserName = userName;
Colour = colour;
Rank = rank;
NickName = nickName;
Perms = perms;
Status = status;
StatusMessage = statusMessage;
}
private void WriteRect(Point2D pos, Colour fill, Colour?stroke = null)
{
XmlWriter.WriteStartElement("rect");
//x="10" y="10" width="30" height="30" stroke="black"
XmlWriter.WriteAttributeString("x", (pos.X * _unitWidth).ToString());
XmlWriter.WriteAttributeString("y", (pos.Y * _unitHeight).ToString());
XmlWriter.WriteAttributeString("width", _unitWidth.ToString());
XmlWriter.WriteAttributeString("height", _unitHeight.ToString());
if (stroke.HasValue)
{
XmlWriter.WriteAttributeString("stroke", ColourStr(stroke.Value));
XmlWriter.WriteAttributeString("stroke-width", "1");
}
XmlWriter.WriteAttributeString("fill", ColourStr(fill));
XmlWriter.WriteEndElement();
}
public Colour GetNextColour()
{
if(playerSelectedNextColour.HasValue && CanDrawColour(playerSelectedNextColour.Value))
{
return playerSelectedNextColour.Value;
}
playerSelectedNextColour = null;
if(lineCounts.OrangeLines > 0)
playerSelectedNextColour = Colour.Orange;
else if(lineCounts.BlueLines > 0)
playerSelectedNextColour = Colour.Blue;
else if(lineCounts.GreenLines > 0)
playerSelectedNextColour = Colour.Green;
else if(lineCounts.PurpleLines > 0)
playerSelectedNextColour = Colour.Purple;
else
playerSelectedNextColour = Colour.None;
return playerSelectedNextColour.Value;
}
public MaybeColouredNameToken(Colour?colour, string name)
{
Colour = colour;
Name = name;
}
public void OnColourSelected(Colour newColour, int remainingLineCount)
{
//Debug.Log("Colour selected = " + newColour);
playerSelectedNextColour = newColour;
}
public Vertex(Vector3 position, Vector3 normal, Colour?colour, UV?uv)
: this(position, normal, colour ?? Colour.White, uv ?? UV.Zero, uv != null)
{
}
public Instruction(InstructionType type, Colour?colour)
{
this.Type = type;
this.Colour = colour;
}
public bool PlacePieceAt(RotatedPiece rotatedPiece, int x, int y)
{
if (x < 0 || x >= BoardSize)
{
throw new ArgumentOutOfRangeException("x");
}
if (y < 0 || y >= BoardSize)
{
throw new ArgumentOutOfRangeException("y");
}
if (x + rotatedPiece.Width > BoardSize)
{
return(false);
}
if (y + rotatedPiece.Height > BoardSize)
{
return(false);
}
// Check for any overlap with existing pieces before setting any squares.
for (var pieceX = 0; pieceX < rotatedPiece.Width; pieceX++)
{
for (var pieceY = 0; pieceY < rotatedPiece.Height; pieceY++)
{
var square = rotatedPiece.SquareAt(pieceX, pieceY);
if (square != null)
{
if (_pieces[x + pieceX, y + pieceY] != null)
{
return(false);
}
}
}
}
if (ColourOfSquareZeroZero.HasValue)
{
var colourOfSquareZeroZero = ColourOfSquareZeroZero.Value;
// Check that each square of the piece to be placed has
// the appropriate colour for its intended board position.
for (var pieceX = 0; pieceX < rotatedPiece.Width; pieceX++)
{
for (var pieceY = 0; pieceY < rotatedPiece.Height; pieceY++)
{
var square = rotatedPiece.SquareAt(pieceX, pieceY);
if (square != null)
{
var boardX = x + pieceX;
var boardY = y + pieceY;
var expectedColour = colourOfSquareZeroZero.RelativeColour(boardX, boardY);
if (square.Colour != expectedColour)
{
return(false);
}
}
}
}
}
Square firstSquare = null;
// It's now OK to go ahead and set the squares for the new piece.
for (var pieceX = 0; pieceX < rotatedPiece.Width; pieceX++)
{
for (var pieceY = 0; pieceY < rotatedPiece.Height; pieceY++)
{
var square = rotatedPiece.SquareAt(pieceX, pieceY);
if (square != null)
{
// Remember the first square in case we haven't set _colourOfSquareZeroZero yet.
if (firstSquare == null)
{
firstSquare = square;
}
_pieces[x + pieceX, y + pieceY] = new PieceHolder {
RotatedPiece = rotatedPiece, Square = square
};
}
}
}
if (!ColourOfSquareZeroZero.HasValue && firstSquare != null)
{
var boardX = x + firstSquare.X;
var boardY = y + firstSquare.Y;
ColourOfSquareZeroZero = firstSquare.Colour.RelativeColour(boardX, boardY);
}
return(true);
}
public void ForceColourOfSquareZeroZeroToBeWhite()
{
ColourOfSquareZeroZero = Colour.White;
}
public void ForceColourOfSquareZeroZeroToBeBlack()
{
ColourOfSquareZeroZero = Colour.Black;
}
public bool PlacePieceAt(RotatedPiece rotatedPiece, int x, int y)
{
if (x < 0 || x >= BoardSize) throw new ArgumentOutOfRangeException("x");
if (y < 0 || y >= BoardSize) throw new ArgumentOutOfRangeException("y");
if (x + rotatedPiece.Width > BoardSize) return false;
if (y + rotatedPiece.Height > BoardSize) return false;
// Check for any overlap with existing pieces before setting any squares.
for (var pieceX = 0; pieceX < rotatedPiece.Width; pieceX++) {
for (var pieceY = 0; pieceY < rotatedPiece.Height; pieceY++) {
var square = rotatedPiece.SquareAt(pieceX, pieceY);
if (square != null) {
if (_pieces[x + pieceX, y + pieceY] != null)
return false;
}
}
}
if (ColourOfSquareZeroZero.HasValue) {
var colourOfSquareZeroZero = ColourOfSquareZeroZero.Value;
// Check that each square of the piece to be placed has
// the appropriate colour for its intended board position.
for (var pieceX = 0; pieceX < rotatedPiece.Width; pieceX++) {
for (var pieceY = 0; pieceY < rotatedPiece.Height; pieceY++) {
var square = rotatedPiece.SquareAt(pieceX, pieceY);
if (square != null) {
var boardX = x + pieceX;
var boardY = y + pieceY;
var expectedColour = colourOfSquareZeroZero.RelativeColour(boardX, boardY);
if (square.Colour != expectedColour)
return false;
}
}
}
}
Square firstSquare = null;
// It's now OK to go ahead and set the squares for the new piece.
for (var pieceX = 0; pieceX < rotatedPiece.Width; pieceX++) {
for (var pieceY = 0; pieceY < rotatedPiece.Height; pieceY++) {
var square = rotatedPiece.SquareAt(pieceX, pieceY);
if (square != null) {
// Remember the first square in case we haven't set _colourOfSquareZeroZero yet.
if (firstSquare == null)
firstSquare = square;
_pieces[x + pieceX, y + pieceY] = new PieceHolder { RotatedPiece = rotatedPiece, Square = square };
}
}
}
if (!ColourOfSquareZeroZero.HasValue && firstSquare != null) {
var boardX = x + firstSquare.X;
var boardY = y + firstSquare.Y;
ColourOfSquareZeroZero = firstSquare.Colour.RelativeColour(boardX, boardY);
}
return true;
}
public Scene(Colour?clearColour = null)
{
Entities = new EntityList(this);
ClearColour = clearColour ?? Colour.Grey;
}
private static HeldRule CreateHeldRule(Colour?colour, WeightMap <HeldSolution, string> weights, Random random)
{
return(new HeldRule(colour, weights.Roll(GetHeldSolutions(), random)));
}
public HeldRule(Colour?colour, HeldSolution solution)
{
this.Colour = colour;
this.Solution = solution;
}
public void ForceColourOfSquareZeroZeroToBeBlack()
{
ColourOfSquareZeroZero = Colour.Black;
}
public void Reset()
{
for (var x = 0; x < BoardSize; x++) {
for (var y = 0; y < BoardSize; y++) {
_pieces[x, y] = null;
}
}
ColourOfSquareZeroZero = null;
}
public void Update(
IUser user,
string userName = null,
Colour?colour = null,
int?rank = null,
UserPermissions?perms = null,
UserStatus?status = null,
string statusMessage = null,
string nickName = null
)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
lock (Sync) {
if (userName != null && user.UserName == userName)
{
userName = null;
}
if (colour.HasValue && user.Colour.Equals(colour))
{
colour = null;
}
if (rank.HasValue && user.Rank == rank.Value)
{
rank = null;
}
if (nickName != null)
{
string prevNickName = user.NickName ?? string.Empty;
if (nickName == prevNickName)
{
nickName = null;
}
else
{
string nextUserName = userName ?? user.UserName;
if (nickName == nextUserName)
{
nickName = null;
}
else
{
// cleanup
}
}
}
if (perms.HasValue && user.Permissions == perms.Value)
{
perms = null;
}
if (status.HasValue && user.Status == status.Value)
{
status = null;
}
if (statusMessage != null && user.StatusMessage == statusMessage)
{
statusMessage = null;
}
else
{
// cleanup
}
Dispatcher.DispatchEvent(this, new UserUpdateEvent(user, userName, colour, rank, nickName, perms, status, statusMessage));
}
}
public void CubeStarts_With_CorrectFaceEdgeColours(Side faceSide, Side edgeSide, Colour?colour)
{
var face = cube.GetFace(faceSide);
Assert.AreEqual(9, face.Length);
for (var i = 0; i < 3; i++)
{
Block block;
switch (edgeSide)
{
case Side.Left when faceSide == Side.Front:
block = face[i, 0];
Assert.AreEqual(colour, block.Left);
break;
case Side.Left when faceSide == Side.Back:
block = face[i, 2];
Assert.AreEqual(colour, block.Left);
break;
case Side.Right when faceSide == Side.Front:
block = face[i, 2];
Assert.AreEqual(colour, block.Right);
break;
case Side.Right when faceSide == Side.Back:
block = face[i, 0];
Assert.AreEqual(colour, block.Right);
break;
case Side.Top:
block = face[0, i];
Assert.AreEqual(colour, block.Top);
break;
case Side.Bottom:
block = face[2, i];
Assert.AreEqual(colour, block.Bottom);
break;
}
}
}
