public void SetValues(List<KeyValuePair<string, int>> values, int ofTotal)
{
m_Slices = new List<SliceSettings>(values.Count);
float tally = 0.0f;
for (int i = 0; i < values.Count; i++)
{
if (values[i].Value == 0)
continue;
SliceSettings slice = new SliceSettings();
slice.startValue = tally;
tally += values[i].Value / (float)ofTotal;
if (tally > 1.0f) {
Debug.Log("SHOULD NEVER HAPPEN");
tally = 1.0f;
}
slice.endValue = tally;
Color32 c = Config.instance.GetTypeColor(values[i].Key);
slice.innerColor = c;
slice.outterColor = c;
m_Slices.Add(slice);
}
Invalidate();
}
public void SetValues(List <KeyValuePair <string, int> > values, int ofTotal)
{
m_Slices = new List <SliceSettings>(values.Count);
float tally = 0.0f;
for (int i = 0; i < values.Count; i++)
{
if (values[i].Value == 0)
{
continue;
}
SliceSettings slice = new SliceSettings();
slice.startValue = tally;
tally += values[i].Value / (float)ofTotal;
if (tally > 1.0f)
{
Debug.Log("SHOULD NEVER HAPPEN");
tally = 1.0f;
}
slice.endValue = tally;
Color32 c = Config.instance.GetTypeColor(values[i].Key);
slice.innerColor = c;
slice.outterColor = c;
m_Slices.Add(slice);
}
Invalidate();
}
public static Sprite GetPiece(int value, SliceSettings settings)
{
if (settings.CachedPieces.ContainsKey(value))
{
return(settings.CachedPieces[value]);
}
var piece = GeneratePiece(value, settings);
settings.CachedPieces.Add(value, piece);
return(piece);
}
public int[] GetSlices(SliceSettings settings, Bitmap image)
{
var sliceCount = settings.SliceCount;
var imageHeight = image.Height;
var resultSlices = new List <int>();
for (var i = 1; i <= sliceCount; i++)
{
resultSlices.Add((int)((double)imageHeight * i / sliceCount));
}
return(resultSlices.ToArray());
}
public static Piece[] SliceImage(Sprite image, int[,] connectionsMap, Sprite connection)
{
var puzzleWidth = connectionsMap.GetLength(0);
var puzzleHeight = connectionsMap.GetLength(1);
var pieces = new Piece[puzzleWidth * puzzleHeight];
var order = 0;
Vector3 imagePivot = new Vector3(image.pivot.x / image.rect.width, image.pivot.y / image.rect.height);
var imageWorldSize = new Vector3(image.rect.width, image.rect.height) / image.pixelsPerUnit;
var pieceWorldSize = new Vector3(imageWorldSize.x / puzzleWidth, imageWorldSize.y / puzzleHeight);
var offset = Vector3.Scale(imageWorldSize, imagePivot);
var halfPieceSize = pieceWorldSize * 0.5f;
var puzzleSize = new Vector2Int((int)image.rect.width / puzzleWidth, (int)image.rect.height / puzzleHeight);
var sliceSettings = new SliceSettings()
{
ConnectionSprite = connection,
Connections = GenerateConnections(connection),
PieceTextureSize = puzzleSize,
PieceTemplate = template,
CachedPieces = new Dictionary <int, Sprite>()
};
for (int ix = 0; ix < puzzleWidth; ++ix)
{
for (int iy = 0; iy < puzzleHeight; ++iy)
{
var piece = Object.Instantiate(template);
piece.SpriteRenderer.sprite = image;
piece.Collider.size = pieceWorldSize;
piece.Position = new Vector2Int(ix, iy);
piece.Mask.sprite = GetPiece(connectionsMap[ix, iy], sliceSettings);
piece.SpriteRenderer.transform.localPosition = offset - new Vector3(ix * pieceWorldSize.x, iy * pieceWorldSize.y) - halfPieceSize; // + offset;// - halfPieceSize;
piece.SortingOrder = order;
pieces[iy * puzzleWidth + ix] = piece;
++order;
}
}
return(pieces);
}
private static (int Min, int Max) GetMinMaxHeight(SliceSettings settings, int imageHeight, int previousSlice)
{
if (settings.TrueSliceMaxHeight == 0)
{
var sliceStep = imageHeight / settings.SliceCount;
var nextSliceCenter = previousSlice + sliceStep;
var min = AdditionalMath.Clamp(previousSlice, imageHeight,
nextSliceCenter - settings.TrueSliceMaxDistance / 2);
var max = AdditionalMath.Clamp(previousSlice, imageHeight,
nextSliceCenter + settings.TrueSliceMaxDistance / 2);
return(imageHeight - max < settings.TrueSliceMinHeight ? (imageHeight, imageHeight) : (min, max));
}
else
{
var min = AdditionalMath.Clamp(previousSlice, imageHeight, previousSlice + settings.TrueSliceMinHeight);
var max = AdditionalMath.Clamp(previousSlice, imageHeight, previousSlice + settings.TrueSliceMaxHeight);
return(imageHeight - max < settings.TrueSliceMinHeight ? (imageHeight, imageHeight) : (min, max));
}
}
private static Vector2Int GetTextureSize(int value, SliceSettings settings)
{
var result = settings.PieceTextureSize;
if (value.Contains(PieceValues.Left))
{
result.x += settings.Connections[PieceValues.Left].width;
}
if (value.Contains(PieceValues.Right))
{
result.x += settings.Connections[PieceValues.Right].width;
}
if (value.Contains(PieceValues.Top))
{
result.y += settings.Connections[PieceValues.Top].height;
}
if (value.Contains(PieceValues.Bottom))
{
result.y += settings.Connections[PieceValues.Bottom].height;
}
return(result);
}
public int[] GetSlices(SliceSettings settings, Bitmap image)
{
var previousSlice = 0;
var imageHeight = image.Height;
var resultSlices = new List <int>();
var imageData = GetByteArrayFromBitmap(image);
while (previousSlice != imageHeight)
{
var(minSlice, maxSlice) = GetMinMaxHeight(settings, image.Height, previousSlice);
var slice = GetSlice(image, minSlice, maxSlice, settings.TrueSliceHeight,
settings.TrueSliceColorDifference, imageData);
if (slice == -1)
{
slice = minSlice + (maxSlice - minSlice) / 2;
}
previousSlice = slice;
resultSlices.Add(previousSlice);
}
return(resultSlices.ToArray());
}
public StartSettings()
{
ConcatSettings = new ConcatSettings();
SliceSettings = new SliceSettings();
}
public static Sprite GeneratePiece(int value, SliceSettings settings)
{
var connections = settings.Connections;
var x = value.Contains(PieceValues.Left) ? connections[PieceValues.Left].width : 0;
var y = value.Contains(PieceValues.Bottom) ? connections[PieceValues.Bottom].height : 0;
var middleX = x + settings.PieceTextureSize.x / 2;
var middleY = y + settings.PieceTextureSize.y / 2;
var texSize = GetTextureSize(value, settings);
var tex = new Texture2D(texSize.x, texSize.y, textureFormat, false);
tex.filterMode = FilterMode.Point;
tex.Fill(alphaColor);
tex.Fill(new Rect(x, y, settings.PieceTextureSize.x, settings.PieceTextureSize.y), pieceColor);
if (value.Contains(PieceValues.Right))
{
var startX = x + settings.PieceTextureSize.x;
var startY = middleY - connections[PieceValues.Right].height / 2;
tex.DrawTexture(connections[PieceValues.Right], new Vector2Int(startX, startY));
}
else if (value.Contains(PieceValues.RightNeighbord))
{
var startX = texSize.x - connections[PieceValues.Left].width;
var startY = middleY - connections[PieceValues.Left].height / 2;
tex.Cut(connections[PieceValues.Left], new Vector2Int(startX, startY));
}
if (value.Contains(PieceValues.Left))
{
var startX = 0;
var startY = middleY - connections[PieceValues.Left].height / 2;
tex.DrawTexture(connections[PieceValues.Left], new Vector2Int(startX, startY));
}
else if (value.Contains(PieceValues.LeftNeighbord))
{
var startX = 0;
var startY = middleY - connections[PieceValues.Right].height / 2;
tex.Cut(connections[PieceValues.Right], new Vector2Int(startX, startY));
}
if (value.Contains(PieceValues.Top))
{
var startX = middleX - connections[PieceValues.Top].width / 2;
var startY = y + settings.PieceTextureSize.y;
tex.DrawTexture(connections[PieceValues.Top], new Vector2Int(startX, startY));
}
else if (value.Contains(PieceValues.TopNeighbord))
{
var startX = middleX - connections[PieceValues.Bottom].width / 2;
var startY = texSize.y - connections[PieceValues.Bottom].height;
tex.Cut(connections[PieceValues.Bottom], new Vector2Int(startX, startY));
}
if (value.Contains(PieceValues.Bottom))
{
var startX = middleX - connections[PieceValues.Bottom].width / 2;
var startY = 0;
tex.DrawTexture(connections[PieceValues.Bottom], new Vector2Int(startX, startY));
}
else if (value.Contains(PieceValues.BottomNeighbord))
{
var startX = middleX - connections[PieceValues.Top].width / 2;
var startY = 0;
tex.Cut(connections[PieceValues.Top], new Vector2Int(startX, startY));
}
tex.Apply();
var pivot = GetPivot(value, settings.PieceTextureSize, texSize);
var sprite = Sprite.Create(tex, new Rect(0, 0, tex.width, tex.height), pivot);
return(sprite);
}
