public Configuration()
{
if (!File.Exists(FileName))
{
// Discord
EndPoints.Add(new Endpoint());
}
}
public Configuration()
{
if (!File.Exists(FileName))
{
// Discord
EndPoints.Add(new Endpoint());
ManagerUserIds.Add(0);
AdminUserIds.Add(0);
}
}
private void _path_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (e.ClickCount == 2)
{
if (EndPoints == null)
{
EndPoints = new List <ThumbPoint>();
}
var point = e.GetPosition(_canvas);
var tpoint = new ThumbPoint(point);
tpoint.DragDelta += Thumb_DragDelta;
tpoint.DragCompleted += Item_DragCompleted;
_canvas.Children.Add(tpoint);
EndPoints.Add(tpoint);
ControlPoints.Add(tpoint);
OrderControlPoints();
}
}
private void NodeDiscovered(object sender, NodeDiscoveredEventArgs e)
{
var existingNode = EndPoints.SingleOrDefault(node => node.Address == e.Node.Address);
if (existingNode != null)
{
existingNode.Id = e.Name;
}
else
{
var node = new EndPoint
{
Address = e.Node.Address,
Id = e.Name
};
EndPoints.Add(node);
}
}
private void DoParse(string configuration, bool ignoreUnknown)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (string.IsNullOrWhiteSpace(configuration))
{
throw new ArgumentException("is empty", configuration);
}
Clear();
// break it down by commas
var arr = configuration.Split(StringSplits.Comma);
Dictionary <string, string> map = null;
foreach (var paddedOption in arr)
{
var option = paddedOption.Trim();
if (string.IsNullOrWhiteSpace(option))
{
continue;
}
// check for special tokens
int idx = option.IndexOf('=');
if (idx > 0)
{
var key = option.Substring(0, idx).Trim();
var value = option.Substring(idx + 1).Trim();
switch (OptionKeys.TryNormalize(key))
{
case OptionKeys.SyncTimeout:
SyncTimeout = OptionKeys.ParseInt32(key, value, minValue: 1);
break;
case OptionKeys.AsyncTimeout:
AsyncTimeout = OptionKeys.ParseInt32(key, value, minValue: 1);
break;
case OptionKeys.AllowAdmin:
AllowAdmin = OptionKeys.ParseBoolean(key, value);
break;
case OptionKeys.AbortOnConnectFail:
AbortOnConnectFail = OptionKeys.ParseBoolean(key, value);
break;
case OptionKeys.ResolveDns:
ResolveDns = OptionKeys.ParseBoolean(key, value);
break;
case OptionKeys.ServiceName:
ServiceName = value;
break;
case OptionKeys.ClientName:
ClientName = value;
break;
case OptionKeys.ChannelPrefix:
ChannelPrefix = value;
break;
case OptionKeys.ConfigChannel:
ConfigurationChannel = value;
break;
case OptionKeys.KeepAlive:
KeepAlive = OptionKeys.ParseInt32(key, value);
break;
case OptionKeys.ConnectTimeout:
ConnectTimeout = OptionKeys.ParseInt32(key, value);
break;
case OptionKeys.ConnectRetry:
ConnectRetry = OptionKeys.ParseInt32(key, value);
break;
case OptionKeys.ConfigCheckSeconds:
ConfigCheckSeconds = OptionKeys.ParseInt32(key, value);
break;
case OptionKeys.Version:
DefaultVersion = OptionKeys.ParseVersion(key, value);
break;
case OptionKeys.Password:
Password = value;
break;
case OptionKeys.TieBreaker:
TieBreaker = value;
break;
case OptionKeys.Ssl:
Ssl = OptionKeys.ParseBoolean(key, value);
break;
case OptionKeys.SslHost:
SslHost = value;
break;
case OptionKeys.HighPrioritySocketThreads:
HighPrioritySocketThreads = OptionKeys.ParseBoolean(key, value);
break;
case OptionKeys.WriteBuffer:
#pragma warning disable CS0618 // Type or member is obsolete
WriteBuffer = OptionKeys.ParseInt32(key, value);
#pragma warning restore CS0618 // Type or member is obsolete
break;
case OptionKeys.Proxy:
Proxy = OptionKeys.ParseProxy(key, value);
break;
case OptionKeys.ResponseTimeout:
#pragma warning disable CS0618 // Type or member is obsolete
ResponseTimeout = OptionKeys.ParseInt32(key, value, minValue: 1);
#pragma warning restore CS0618 // Type or member is obsolete
break;
case OptionKeys.DefaultDatabase:
DefaultDatabase = OptionKeys.ParseInt32(key, value);
break;
case OptionKeys.PreserveAsyncOrder:
break;
case OptionKeys.SslProtocols:
SslProtocols = OptionKeys.ParseSslProtocols(key, value);
break;
default:
if (!string.IsNullOrEmpty(key) && key[0] == '$')
{
var cmdName = option.Substring(1, idx - 1);
if (Enum.TryParse(cmdName, true, out RedisCommand cmd))
{
if (map == null)
{
map = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
}
map[cmdName] = value;
}
}
else
{
if (!ignoreUnknown)
{
OptionKeys.Unknown(key);
}
}
break;
}
}
else
{
var ep = Format.TryParseEndPoint(option);
if (ep != null && !EndPoints.Contains(ep))
{
EndPoints.Add(ep);
}
}
}
if (map != null && map.Count != 0)
{
CommandMap = CommandMap.Create(map);
}
}
public ServerConfig(Uri uri)
{
Uri = uri;
EndPoints.Add(new IPEndPoint(IPAddress.Parse(uri.Host), uri.Port));
}
internal LineEndPointNode(LineEndPoint endPoint)
{
EndPoints.Add(endPoint);
}
private bool InitializePanel()
{
if (panel != null)
{
Walls.Clear();
StartPoints.Clear();
EndPoints.Clear();
renderedTetrisTextures.Clear();
PuzzleDimensions = new Point(panel.Width, panel.Height);
// Calculation of puzzle sizes for current screen size
int width = screenSize.X;
int height = screenSize.Y;
int maxPuzzleDimension = Math.Max(PuzzleDimensions.X, PuzzleDimensions.Y);
int screenMinSize = Math.Min(width, height);
int puzzleMaxSize = (int)(screenMinSize * PuzzleSpaceRatio(maxPuzzleDimension));
LineWidth = (int)(puzzleMaxSize * LineSizeRatio(maxPuzzleDimension));
BlockWidth = (int)(puzzleMaxSize * BlockSizeRatio(maxPuzzleDimension));
HalfLineWidthPoint = new Point(LineWidth / 2);
LineWidthPoint = new Point(LineWidth);
BlockSizePoint = new Point(BlockWidth);
int endAppendixLength = (int)(BlockWidth * endPointLegth);
int puzzleWidth = LineWidth * (PuzzleDimensions.X + 1) + BlockWidth * PuzzleDimensions.X;
int puzzleHeight = LineWidth * (PuzzleDimensions.Y + 1) + BlockWidth * PuzzleDimensions.Y;
int xMargin = (width - puzzleWidth) / 2;
int yMargin = (height - puzzleHeight) / 2;
Point margins = new Point(xMargin, yMargin);
PuzzleConfig = new Rectangle(xMargin, yMargin, puzzleWidth, puzzleHeight);
NodePadding = LineWidth + BlockWidth;
// Creating walls hitboxes
CreateHorizontalWalls(false); // Top walls
CreateHorizontalWalls(true); // Bottom walls
CreateVerticalWalls(false); // Left walls
CreateVerticalWalls(true); // Right walls
for (int i = 0; i < PuzzleDimensions.X; i++)
{
for (int j = 0; j < PuzzleDimensions.Y; j++)
{
Walls.Add(new Rectangle(xMargin + LineWidth * (i + 1) + BlockWidth * i, yMargin + LineWidth * (j + 1) + BlockWidth * j, BlockWidth, BlockWidth));
}
}
// Creating walls for broken edges
var brokenEdges = panel.Edges.Where(x => x.State == EdgeState.Broken);
foreach (Edge edge in brokenEdges)
{
Point nodeA = NodeIdToPoint(edge.Id % 100).Multiply(NodePadding) + margins;
Point nodeB = NodeIdToPoint(edge.Id / 100).Multiply(NodePadding) + margins;
Point middle = (nodeA + nodeB).Divide(2);
Walls.Add(new Rectangle(middle, new Point(LineWidth)));
}
// Creating hitboxes for starting nodes
foreach (Point start in GetStartNodes())
{
StartPoints.Add(new Rectangle(xMargin + start.X * NodePadding - LineWidth, yMargin + start.Y * NodePadding - LineWidth, LineWidth * 3, LineWidth * 3));
}
// Generate textures for tetris rules
CreateTetrisRuleTextures();
#region === Inner methods region ===
// Returns a coef k: Total free space in pixels * k = puzzle size in pixels
float PuzzleSpaceRatio(float puzzleDimension) => (float)(-0.0005 * Math.Pow(puzzleDimension, 4) + 0.0082 * Math.Pow(puzzleDimension, 3) - 0.0439 * Math.Pow(puzzleDimension, 2) + 0.1011 * puzzleDimension + 0.6875);
// Returns a coef k: Puzzle size in pixels * k = block size in pixels
float BlockSizeRatio(float puzzleDimension) => (float)(0.8563 * Math.Pow(puzzleDimension, -1.134));
// Returns a coef k: Puzzle size in pixels * k = line width in pixels
float LineSizeRatio(float puzzleDimension) => - 0.0064f * puzzleDimension + 0.0859f;
IEnumerable <Point> GetStartNodes() => panel.Nodes.Where(x => x.State == NodeState.Start).Select(x => NodeIdToPoint(x.Id));
IEnumerable <Point> GetEndNodesTop()
{
for (int i = 1; i < panel.Width; i++)
{
if (panel.Nodes[i].State == NodeState.Exit)
{
yield return(new Point(i, 0));
}
}
}
IEnumerable <Point> GetEndNodesBot()
{
for (int i = 1; i < panel.Width; i++)
{
int index = panel.Height * (panel.Width + 1) + i;
if (panel.Nodes[index].State == NodeState.Exit)
{
yield return(new Point(i, panel.Height));
}
}
}
IEnumerable <Point> GetEndNodesLeft()
{
for (int j = 0; j < panel.Height + 1; j++)
{
int index = j * (panel.Width + 1);
if (panel.Nodes[index].State == NodeState.Exit)
{
yield return(new Point(0, j));
}
}
}
IEnumerable <Point> GetEndNodesRight()
{
for (int j = 0; j < panel.Height + 1; j++)
{
int index = j * (panel.Width + 1) + panel.Width;
if (panel.Nodes[index].State == NodeState.Exit)
{
yield return(new Point(panel.Width, j));
}
}
}
void CreateHorizontalWalls(bool isBottom)
{
int yStartPoint = isBottom ? yMargin + puzzleHeight : 0;
var ends = isBottom ? GetEndNodesBot() : GetEndNodesTop();
if (ends.Count() == 0)
{
Walls.Add(new Rectangle(0, yStartPoint, width, yMargin));
}
else
{
Walls.Add(new Rectangle(0, yStartPoint + (isBottom ? endAppendixLength : 0), width, yMargin - endAppendixLength));
int lastXPoint = 0;
foreach (Point endPoint in ends)
{
int x = xMargin + endPoint.X * (NodePadding);
Walls.Add(new Rectangle(lastXPoint, isBottom ? yStartPoint : (yMargin - endAppendixLength), x - lastXPoint, endAppendixLength));
EndPoints.Add(new EndPoint(new Rectangle(x, isBottom ? yStartPoint + endAppendixLength - LineWidth : (yMargin - endAppendixLength), LineWidth, LineWidth), isBottom ? Facing.Down : Facing.Up));
lastXPoint = x + LineWidth;
}
Walls.Add(new Rectangle(lastXPoint, isBottom ? yStartPoint : (yMargin - endAppendixLength), width - lastXPoint, endAppendixLength));
}
}
void CreateVerticalWalls(bool isRight)
{
int xStartPoint = isRight ? xMargin + puzzleWidth : 0;
var ends = isRight ? GetEndNodesRight() : GetEndNodesLeft();
if (ends.Count() == 0)
{
Walls.Add(new Rectangle(xStartPoint, 0, xMargin, height));
}
else
{
Walls.Add(new Rectangle(xStartPoint + (isRight ? endAppendixLength : 0), 0, xMargin - endAppendixLength, height));
int lastYPoint = 0;
foreach (Point endPoint in ends)
{
int y = yMargin + endPoint.Y * (NodePadding);
Walls.Add(new Rectangle(isRight ? xStartPoint : (xMargin - endAppendixLength), lastYPoint, endAppendixLength, y - lastYPoint));
EndPoints.Add(new EndPoint(new Rectangle(isRight ? xStartPoint + endAppendixLength - LineWidth : xMargin - endAppendixLength, y, LineWidth, LineWidth), isRight ? Facing.Right : Facing.Left));
lastYPoint = y + LineWidth;
}
Walls.Add(new Rectangle(isRight ? xStartPoint : (xMargin - endAppendixLength), lastYPoint, endAppendixLength, height - lastYPoint));
}
}
void CreateTetrisRuleTextures()
{
// Render shape into texture for each tetris rule
var tetrisBlocks = panel.Blocks.Where(x => x.Rule is TetrisRule).ToList();
if (tetrisBlocks.Count > 0)
{
int maxDimension = tetrisBlocks.Select(x => x.Rule as TetrisRule).Select(x => Math.Max(x.Shape.GetLength(0), x.Shape.GetLength(1))).Max();
if (maxDimension < 3)
{
maxDimension++;
}
tetrisTextureSize = new Point((maxDimension + 1) * texTetris[0].Width);
foreach (Block block in tetrisBlocks)
{
TetrisRule rule = block.Rule as TetrisRule;
bool[,] shape = rule.Shape;
// If shape is rotatable, then rotate it randomly before render
if (rule is TetrisRotatableRule r)
{
shape = TetrisRotatableRule.RotateShapeCW(shape, rnd.Next(0, 4));
}
// Draw shape on a texture
RenderTarget2D texture = CreateTetrisTexture(shape, rule is TetrisRotatableRule, rule.IsSubtractive);
// Save it to the dictionary
renderedTetrisTextures.Add(block.Id, texture);
}
}
}
#endregion
return(true);
}
return(false);
}
