public override void FillCircle(RawColor color, Vector2f center, float radius)
{
using (System.Drawing.Brush brush2 = CreateBrush(color))
{
InternalGraphics.FillEllipse(brush2, center.X - radius, center.Y - radius, radius * 2, radius * 2);
}
}
public void DrawString(string s, Font font, RawColor color, Vector2f point, Vector2f align)
{
Vector2f size = Graphics.MeasureString(s, font);
Vector2f newPoint = new Vector2f(point.X - size.X * align.X, point.Y - size.Y * align.Y);
Graphics.DrawString(s, font, color, newPoint);
}
protected override bool PerformDropIn(Object dropInItem, Farmer farmer)
{
if (FirstDroppedItem == null)
{
FirstDroppedItem = dropInItem;
PlaySound(Sound.Ship);
}
else
{
SecondDroppedItem = dropInItem;
var q1 = FirstDroppedItem.quality;
var q2 = SecondDroppedItem.quality;
var itemQuality = Math.Max(0, q1 + q2 - 1);
var itemPrice = (FirstDroppedItem.price * (4 + q1) + SecondDroppedItem.price * (4 + q2)) / 4;
var random = GetRandom();
var postfix = $"{FirstDroppedItem.Name.First()}{SecondDroppedItem.Name.First()}-{(char)random.Next('A', 'Z')}{random.Next(1, 9)}{random.Next(0, 9)}";
var hue = random.Next(0, 359); // TODO: Not random color.
var color = RawColor.FromHSL(hue, 0.75, 0.55).ToXnaColor();
PutItem(NewMachinesModConfig.ExperementalLiquidID, 1, itemQuality, $"{{0}} {postfix}", itemPrice, color); // TODO: From config?
minutesUntilReady = GetMinutesUntilReady(GetOutputItem(SecondDroppedItem)); // TODO: From config?
PlaySound(Sound.Ship);
PlaySound(Sound.Bubbles);
}
return(true);
}
/*private Bitmap PixelsToBitmap(RawColor[,] pix)
* {
* Bitmap bmp = new Bitmap(pix.GetLength(0), pix.GetLength(1));
* }*/
int DistanceSquared(RawColor c1, RawColor c2)
{
int dR = c1.R - c2.R;
int dG = c1.G - c2.G;
int dB = c1.B - c2.B;
return(dR * dR + dG * dG + dB * dB);
}
bool IsGray(RawColor c)
{
int sum = c.R + c.G + c.B;
int sqrSum = (c.R * c.R + c.G * c.G + c.B * c.B) * 3;
int var9 = sqrSum - sum * sum; //Var9=9*Variance
return(var9 < 3000);
}
public void Clear(RawColor color)
{
VkClearColorValue clearValue = new VkClearColorValue(color.R, color.G, color.B, color.A);
VkImageSubresourceRange clearRange = new VkImageSubresourceRange(VkImageAspectFlags.Color, 0, 1, 0, 1);
vkCmdClearColorImage(CommandBuffer, NativeDevice.NativeSwapChain.Images[(int)imageIndex], VkImageLayout.ColorAttachmentOptimal, &clearValue, 1, &clearRange);
}
private void RenderBoardAction(Vector2i position, int actionIndex)
{
Graphics.FillRectangle(RawColor.FromRGB(0xC57B10), Square(position, 0.4f));
CreateBoardAction action = (CreateBoardAction)Tree.Replay.Actions[actionIndex];
Vector2f pixelPosition = ToGraphic(new Vector2f(position.X, position.Y));
if (action.Width == action.Height)
{
DrawString(action.Width.ToString(), font, RawColor.Black, pixelPosition, new Vector2f(0.5f, 0.5f));
}
}
public void CheckHexConversion()
{
var raw = RawColor.FromHex("12AB34");
Assert.AreEqual(18, raw.R);
Assert.AreEqual(171, raw.G);
Assert.AreEqual(52, raw.B);
var hex = raw.ToHex();
Assert.AreEqual("12AB34", hex);
}
public void CheckHsbConversion()
{
var c1 = new RawColor(18, 171, 52);
double h, s, l;
c1.ToHSL(out h, out s, out l);
var c2 = RawColor.FromHSL(h, s, l);
Assert.AreEqual(c1.R, c2.R, 1);
Assert.AreEqual(c1.G, c2.G, 1);
Assert.AreEqual(c1.B, c2.B, 1);
}
public static Color?Parse(string colorName)
{
if (Regex.Match(colorName, @"#?[\dA-Fa-f]{6}").Success)
{
return(RawColor.FromHex(colorName.Substring(1)).ToXnaColor());
}
else
{
var propertyInfo = typeof(Color).GetProperty(colorName, BindingFlags.Static | BindingFlags.Public);
return((Color?)propertyInfo?.GetValue(null));
}
}
private Color?GetColor(OutputItem outputItem, Object dropInItem)
{
var color = outputItem?.Color;
if (string.IsNullOrWhiteSpace(color))
{
return(null);
}
return((color != "@")
? RawColor.FromHex(color).ToXnaColor()
: DominantColorFinder.GetDominantColor(dropInItem.ParentSheetIndex, Game1.objectSpriteSheet, 16, 16));
}
RawColor[] RadiusColor(Pixels pix, Point center, int[,] radiusData, int maxRadius)
{
int[] counts = new int[maxRadius + 1];
int[] sumR = new int[maxRadius + 1];
int[] sumG = new int[maxRadius + 1];
int[] sumB = new int[maxRadius + 1];
RawColor[] result = new RawColor[maxRadius + 1];
int halfSize = (radiusData.GetLength(0) - 1) / 2;
int dx = halfSize - center.X;
int dy = halfSize - center.Y;
int left = Math.Max(0, center.X - halfSize);
int top = Math.Max(0, center.Y - halfSize);
int right = Math.Min(pix.Width, center.X + halfSize + 1);
int bottom = Math.Min(pix.Height, center.Y + halfSize + 1);
for (int y = top; y < bottom; y++)
{
for (int x = left; x < right; x++)
{
RawColor c = pix.Data[x, y];
int radius = radiusData[x + dx, y + dy];
counts[radius]++;
sumR[radius] += c.R;
sumG[radius] += c.G;
sumB[radius] += c.B;
}
}
RawColor undefined = RawColor.Transparent;
for (int i = 0; i < maxRadius + 1; i++)
{
if (counts[i] == 0)
{
result[i] = undefined;
}
else
{
result[i] = RawColor.FromRGB(
(byte)(sumR[i] / counts[i]),
(byte)(sumG[i] / counts[i]),
(byte)(sumB[i] / counts[i]));
}
}
return(result);
}
private void CountPixels(Pixels pix, System.Drawing.Rectangle rect, Predicate <RawColor> filter, out float[] cols, out float[] rows)
{
int[] colsI = new int[pix.Width];
int[] rowsI = new int[pix.Height];
for (int y = rect.Top; y < rect.Bottom; y++)
{
for (int x = rect.Left; x < rect.Right; x++)
{
RawColor c = pix.Data[x, y];
if (filter(c))
{
colsI[x]++;
rowsI[y]++;
}
}
}
cols = new float[pix.Width];
rows = new float[pix.Height];
for (int x = 0; x < cols.Length; x++)
{
if (x < rect.Left || x > rect.Right - 1)
{
cols[x] = float.NaN;
}
else
{
cols[x] = (float)colsI[x] / rect.Height;
}
}
for (int y = 0; y < rows.Length; y++)
{
if (y < rect.Top || y > rect.Bottom - 1)
{
rows[y] = float.NaN;
}
else
{
rows[y] = (float)rowsI[y] / rect.Width;
}
}
}
private Color?ConvertColor(string color)
{
if (color == null)
{
return(null);
}
if (color != "@")
{
return(RawColor.FromHex(color).ToXnaColor());
}
if (heldObject == null)
{
return(null);
}
var heldColor = heldObject.GetColor();
if (heldColor != null)
{
return(heldColor);
}
return(DominantColorFinder.GetDominantColor(heldObject.ParentSheetIndex, Game1.objectSpriteSheet, 16, 16));
}
public void RenderStone(Vector2f position, StoneColor color, float diameter, bool faded)
{
RawColor rawColor;
switch (color)
{
case StoneColor.Black:
rawColor = RawColor.Black;
break;
case StoneColor.White:
rawColor = RawColor.White;
break;
default:
rawColor = RawColor.Transparent;
break;
}
if (faded)
{
rawColor = RawColor.FromARGB(140, rawColor);
}
Graphics.FillCircle(rawColor, ToGraphic(position), 0.5f * diameter * BlockSize);
}
public abstract void FillCircle(RawColor color, Vector2f center, float radius);
public abstract void DrawString(string text, Font font, RawColor color, Vector2f position);
public Pen(RawColor color, float lineWidth)
: this()
{
Color = color;
LineWidth = lineWidth;
}
bool IsBoard(RawColor c)
{
return(DistanceSquared(c, BoardColor) < 400);
}
private StoneColor GetStoneColor(RawColor[] circles, double blockSize)
{
int black = 0;
int white = 0;
int outerRadius = (int)(blockSize / 2);
int innerRadius = (int)(blockSize / 4);
for (int r = innerRadius; r < outerRadius; r++)
if (circles[r] != RawColor.Transparent && IsGray(circles[r]))
{
if (circles[r].GetUnweightedBrightness() < 0.45)
black++;
if (circles[r].GetUnweightedBrightness() > 0.55)
white++;
}
if (white > (outerRadius - innerRadius) / 2)
return StoneColor.White;
if (black > (outerRadius - innerRadius) / 2)
return StoneColor.Black;
return StoneColor.None;
}
bool IsBoard(RawColor c)
{
return DistanceSquared(c, BoardColor) < 400;
}
public override void FillCircle(RawColor color, Vector2f center, float radius)
{
using (System.Drawing.Brush brush2 = CreateBrush(color))
{
InternalGraphics.FillEllipse(brush2, center.X - radius, center.Y - radius, radius * 2, radius * 2);
}
}
public abstract void FillCircle(RawColor color, Vector2f center, float radius);
public abstract void FillRectangle(RawColor color, RectangleF rect);
public abstract void DrawString(string text, Font font, RawColor color, Vector2f position);
public static unsafe XColor GetDominantColor(int spriteIndex, Texture2D texture, int width, int height)
{
XColor cachedColor;
if (ColorCache.TryGetValue(spriteIndex, out cachedColor))
{
return(cachedColor);
}
var rect = TextureInfo.Default[TextureType.Items].GetSourceRect(spriteIndex);
var size = width * height;
var data = new XColor[size];
texture.GetData(0, rect, data, 0, data.Length);
const byte empty = 0;
const byte inner = 1;
const byte edge = 2;
var alpha = new byte[size];
var colors = new Dictionary <int, int>();
fixed(byte *pAlpha0 = alpha)
fixed(XColor * pData0 = data)
{
var pAlpha = pAlpha0;
var pData = pData0;
for (var i = 0; i < size; ++i)
{
var c = *pData;
* pAlpha = (c.A >= 128)? inner : empty;
++pData;
++pAlpha;
}
pAlpha = pAlpha0 + width;
var hi = height - 1;
var wi = width - 1;
for (var y = 1; y < hi; ++y)
{
++pAlpha;
for (var x = 1; x < wi; ++x, ++pAlpha)
{
if (*(pAlpha - width) == empty || *(pAlpha + width) == empty || *(pAlpha - 1) == empty || *(pAlpha + width) == empty)
{
*pAlpha = edge;
}
}
++pAlpha;
}
pAlpha = pAlpha0 + width;
pData = pData0 + width;
for (var y = 1; y < hi; ++y)
{
++pAlpha;
++pData;
for (var x = 1; x < wi; ++x, ++pAlpha, ++pData)
{
if (*pAlpha != 1)
{
continue;
}
var xColor = *pData;
var c = WColor.FromArgb(xColor.R, xColor.G, xColor.B);
var l = c.GetBrightness();
if (l <= 0.15f || 0.85f <= l)
{
continue;
}
var s = c.GetSaturation();
if (s <= 0.25f)
{
continue;
}
var h = c.GetHue();
var kh = (int)((h + 5) / 10); // 0..36
var ks = (int)((s + 0.17f) * 3); // 0..3
var kl = (int)((l + 0.17f) * 3); // 0..3
var key = (kh << 4) | (ks << 2) | kl;
int value;
if (colors.TryGetValue(key, out value))
{
colors[key] = value + 1;
}
else
{
colors.Add(key, 1);
}
}
}
}
if (!colors.Any())
{
Log.Error("No dominant color found!");
cachedColor = XColor.Gray;
}
else
{
var dominantColors = colors.OrderByDescending(x => x.Value).Take(3).ToArray();
var dominantColor = dominantColors[0];
if (IsGreenColor(dominantColor))
{
var notGreenColors = dominantColors.Where(c => !IsGreenColor(c)).Take(2).ToArray();
if (notGreenColors.Any())
{
var altColor1 = notGreenColors[0];
var altColor2 = (notGreenColors.Length > 2)? notGreenColors[1] : altColor1;
if ((altColor1.Value + altColor2.Value) * 4 >= dominantColor.Value * 3)
{
dominantColor = altColor1;
}
}
}
var dominantColorKey = dominantColor.Key;
var finalH = Math.Min(Math.Max(0, (dominantColorKey >> 4) * 10 - 5), 359);
var finalL = Math.Min(Math.Max(0, 0.40 + (dominantColorKey & 3) * 0.1), 1);
cachedColor = RawColor.FromHSL(finalH, 0.80, finalL).ToXnaColor();
}
ColorCache.Add(spriteIndex, cachedColor);
return(cachedColor);
}
public abstract void FillRectangle(RawColor color, RectangleF rect);
bool IsFadedWhite(RawColor c)
{
return DistanceSquared(c, BoardColor) < 400;
}
public Pen(RawColor color, float lineWidth)
: this()
{
Color = color;
LineWidth = lineWidth;
}
protected override void deserialize(BaseItem item, List <SyncPropertyNames> changedProperties)
{
Class c = item as Class;
byte[] rawColor = ColorHelper.ToBytes(c.Color);
if (changedProperties != null)
{
if (CourseNumber != c.CourseNumber)
{
changedProperties.Add(SyncPropertyNames.CourseNumber);
}
var gradeScales = GetGradeScales();
if ((gradeScales == null && c.GradeScales != null) ||
(gradeScales != null && c.GradeScales == null) ||
(gradeScales != null && c.GradeScales != null && !gradeScales.SequenceEqual(c.GradeScales)))
{
changedProperties.Add(SyncPropertyNames.GradeScales);
}
if (ShouldAverageGradeTotals != c.ShouldAverageGradeTotals)
{
changedProperties.Add(SyncPropertyNames.ShouldAverageGradeTotals);
}
if (Credits != c.Credits)
{
changedProperties.Add(SyncPropertyNames.Credits);
}
if (Position != c.Position)
{
changedProperties.Add(SyncPropertyNames.Position);
}
if (!RawColor.SequenceEqual(rawColor))
{
changedProperties.Add(SyncPropertyNames.Color);
}
if (DoesRoundGradesUp != c.DoesRoundGradesUp)
{
changedProperties.Add(SyncPropertyNames.DoesRoundGradesUp);
}
if (GpaType != c.GpaType)
{
changedProperties.Add(SyncPropertyNames.GpaType);
}
if (PassingGrade != c.PassingGrade)
{
changedProperties.Add(SyncPropertyNames.PassingGrade);
}
if (OverriddenGrade != c.OverriddenGrade)
{
changedProperties.Add(SyncPropertyNames.OverriddenGrade);
}
if (OverriddenGPA != c.OverriddenGPA)
{
changedProperties.Add(SyncPropertyNames.OverriddenGPA);
}
if (StartDate != c.StartDate.ToUniversalTime())
{
changedProperties.Add(SyncPropertyNames.StartDate);
}
if (EndDate != c.EndDate.ToUniversalTime())
{
changedProperties.Add(SyncPropertyNames.EndDate);
}
}
CourseNumber = c.CourseNumber;
SetGradeScales(c.GradeScales);
ShouldAverageGradeTotals = c.ShouldAverageGradeTotals;
Credits = c.Credits;
Position = c.Position;
RawColor = rawColor;
DoesRoundGradesUp = c.DoesRoundGradesUp;
GpaType = c.GpaType;
PassingGrade = c.PassingGrade;
OverriddenGPA = c.OverriddenGPA;
OverriddenGrade = c.OverriddenGrade;
StartDate = c.StartDate.ToUniversalTime();
EndDate = c.EndDate.ToUniversalTime();
base.deserialize(c, changedProperties);
}
private bool GetCircleMarker(RawColor[] circles, double blockSize, StoneColor stoneColor)
{
int blackRing = 0;
int whiteRing = 0;
for (int r = 3; r < (int)blockSize / 3; r++)
if (circles[r] != RawColor.Transparent && IsGray(circles[r]))
{
if (circles[r].GetUnweightedBrightness() < 0.35)
blackRing++;
if (circles[r].GetUnweightedBrightness() > 0.65)
whiteRing++;
}
switch (stoneColor)
{
case StoneColor.None:
case StoneColor.White:
return blackRing > 0;
case StoneColor.Black:
return whiteRing > 0;
default:
throw new NotImplementedException();
}
}
private bool GetSquareMarker(RawColor[] squares, double blockSize, StoneColor stoneColor)
{
int blackSquare = 0;
int whiteSquare = 0;
for (int r = (int)blockSize / 4; r < (int)blockSize / 2; r++)
if (squares[r] != RawColor.Transparent && IsGray(squares[r]))
{
if (squares[r].GetUnweightedBrightness() < 0.2)
blackSquare++;
if (squares[r].GetUnweightedBrightness() > 0.8)
whiteSquare++;
}
switch (stoneColor)
{
case StoneColor.None:
case StoneColor.White:
return blackSquare > 0;
case StoneColor.Black:
return whiteSquare > 0;
default:
throw new NotImplementedException();
}
}
RawColor[] RadiusColor(Pixels pix, Point center, int[,] radiusData, int maxRadius)
{
int[] counts = new int[maxRadius + 1];
int[] sumR = new int[maxRadius + 1];
int[] sumG = new int[maxRadius + 1];
int[] sumB = new int[maxRadius + 1];
RawColor[] result = new RawColor[maxRadius + 1];
int halfSize = (radiusData.GetLength(0) - 1) / 2;
int dx = halfSize - center.X;
int dy = halfSize - center.Y;
int left = Math.Max(0, center.X - halfSize);
int top = Math.Max(0, center.Y - halfSize);
int right = Math.Min(pix.Width, center.X + halfSize + 1);
int bottom = Math.Min(pix.Height, center.Y + halfSize + 1);
for (int y = top; y < bottom; y++)
for (int x = left; x < right; x++)
{
RawColor c = pix.Data[x, y];
int radius = radiusData[x + dx, y + dy];
counts[radius]++;
sumR[radius] += c.R;
sumG[radius] += c.G;
sumB[radius] += c.B;
}
RawColor undefined = RawColor.Transparent;
for (int i = 0; i < maxRadius + 1; i++)
{
if (counts[i] == 0)
result[i] = undefined;
else
{
result[i] = RawColor.FromRGB(
(byte)(sumR[i] / counts[i]),
(byte)(sumG[i] / counts[i]),
(byte)(sumB[i] / counts[i]));
}
}
return result;
}
bool IsFadedBlack(RawColor c)
{
return(DistanceSquared(c, BoardColor) < 400);
}
public void DrawString(string s, Font font, RawColor color, Vector2f point, Vector2f align)
{
Vector2f size = Graphics.MeasureString(s, font);
Vector2f newPoint = new Vector2f(point.X - size.X * align.X, point.Y - size.Y * align.Y);
Graphics.DrawString(s, font, color, newPoint);
}
bool IsGray(RawColor c)
{
int sum = c.R + c.G + c.B;
int sqrSum = (c.R * c.R + c.G * c.G + c.B * c.B) * 3;
int var9 = sqrSum - sum * sum;//Var9=9*Variance
return var9 < 3000;
}
public Pen(RawColor color)
: this(color, 1)
{
}
private static System.Drawing.Brush CreateBrush(RawColor color)
{
return new System.Drawing.SolidBrush(color.Convert());
}
public static System.Drawing.Color Convert(this RawColor color)
{
return(System.Drawing.Color.FromArgb((int)color.ARGB));
}
public Pen(RawColor color)
: this(color, 1)
{
}
private static System.Drawing.Brush CreateBrush(RawColor color)
{
return(new System.Drawing.SolidBrush(color.Convert()));
}
protected override void deserialize(BaseItem item, List <PropertyNames> changedProperties)
{
Class c = item as Class;
Color color = ColorTranslator.FromHtml(c.Color);
byte[] rawColor = new byte[]
{
color.R, color.G, color.B
};
if (changedProperties != null)
{
if (CourseNumber != c.CourseNumber)
{
changedProperties.Add(PropertyNames.CourseNumber);
}
if ((GradeScales == null && c.GradeScales != null) ||
(GradeScales != null && c.GradeScales == null) ||
(GradeScales != null && c.GradeScales != null && !GradeScales.SequenceEqual(c.GradeScales)))
{
changedProperties.Add(PropertyNames.GradeScales);
}
if (ShouldAverageGradeTotals != c.ShouldAverageGradeTotals)
{
changedProperties.Add(PropertyNames.ShouldAverageGradeTotals);
}
if (Credits != c.Credits)
{
changedProperties.Add(PropertyNames.Credits);
}
if (Position != c.Position)
{
changedProperties.Add(PropertyNames.Position);
}
if (!RawColor.SequenceEqual(rawColor))
{
changedProperties.Add(PropertyNames.Color);
}
if (DoesRoundGradesUp != c.DoesRoundGradesUp)
{
changedProperties.Add(PropertyNames.DoesRoundGradesUp);
}
}
CourseNumber = c.CourseNumber;
GradeScales = c.GradeScales;
ShouldAverageGradeTotals = c.ShouldAverageGradeTotals;
Credits = c.Credits;
Position = c.Position;
RawColor = rawColor;
DoesRoundGradesUp = c.DoesRoundGradesUp;
base.deserialize(c, changedProperties);
}
/*private Bitmap PixelsToBitmap(RawColor[,] pix)
{
Bitmap bmp = new Bitmap(pix.GetLength(0), pix.GetLength(1));
}*/
int DistanceSquared(RawColor c1, RawColor c2)
{
int dR = c1.R - c2.R;
int dG = c1.G - c2.G;
int dB = c1.B - c2.B;
return dR * dR + dG * dG + dB * dB;
}
