void HandleAdd(Player p, string[] args)
{
if (args.Length != 4)
{
Help(p); return;
}
ImagePalette palette = ImagePalette.Find(args[1]);
if (palette == null)
{
p.Message("Palette {0} does not exist.", args[1]); return;
}
BlockID block;
if (!CommandParser.GetBlock(p, args[2], out block))
{
return;
}
ColorDesc rgb = default(ColorDesc);
if (!CommandParser.GetHex(p, args[3], ref rgb))
{
return;
}
PaletteEntry entry = new PaletteEntry(rgb.R, rgb.G, rgb.B, block);
AddEntry(p, palette, entry);
}
private void GrowPalette()
{
// Decode the indices
int[] indices = new int[_size];
for (int i = 0; i < _size; i++)
{
indices[i] = (int)_data.GetBits(i * indicesLength, indicesLength).Data;
}
// Create a new palette, double the size
indicesLength = indicesLength << 1;
PaletteEntry[] newPalette = new PaletteEntry[(int)MathF.Pow(2, indicesLength)];
int k = 0;
for (int i = 0; i < palette.Length; i++)
{
if (palette[i] != null && palette[i].refcount > 0)
{
newPalette[k++] = palette[i];
}
}
palette = newPalette;
_data = new BitBuffer(_size * indicesLength);
for (int i = 0; i < indices.Length; i++)
{
_data.SetBits(i * indicesLength, indicesLength, new BitArray32((uint)indices[i]));
}
}
private void GrowPalette()
{
// decode the indices
int[] indices = new int[size];
for (int i = 0; i < indices.Length; i++)
{
indices[i] = data.Get(i, indicesLength);
}
// Create new palette, doubling it in size
indicesLength = indicesLength << 1;
PaletteEntry[] newPalette = new PaletteEntry[indicesLength];
System.Array.Copy(palette, 0, newPalette, 0, paletteCount);
palette = newPalette;
// Allocate new BitBuffer
data = new BitBuffer(size * newPalette.Length); // this is bits, not bytes!
Debug.Log("New Palette size: " + newPalette.Length);
Debug.Log("New ByteBitBuffer size: " + size * newPalette.Length + " bytes");
// Encode the indices
for (int i = 0; i < indices.Length; i++)
{
data.Set(i, indicesLength, indices[i]);
}
}
static PaletteEntry Multiply(PaletteEntry entry, ColorDesc rgb)
{
entry.R = (byte)(entry.R * rgb.R / 255);
entry.G = (byte)(entry.G * rgb.G / 255);
entry.B = (byte)(entry.B * rgb.B / 255);
return(entry);
}
void CalcLayerColors()
{
PaletteEntry[] front = new PaletteEntry[Palette.Entries.Length];
PaletteEntry[] back = new PaletteEntry[Palette.Entries.Length];
ColorDesc sun, dark, bright;
if (!Colors.TryParseHex(Level.Config.LightColor, out sun))
{
sun = Colors.ParseHex("FFFFFF");
}
if (!Colors.TryParseHex(Level.Config.ShadowColor, out dark))
{
dark = Colors.ParseHex("9B9B9B");
}
bright = Colors.ParseHex("FFFFFF");
for (int i = 0; i < Palette.Entries.Length; i++)
{
PaletteEntry entry = Palette.Entries[i];
BlockDefinition def = Level.GetBlockDef(entry.Block);
if (def != null && def.FullBright)
{
front[i] = Multiply(entry, bright);
back[i] = Multiply(entry, bright);
}
else
{
front[i] = Multiply(entry, sun);
back[i] = Multiply(entry, dark);
}
}
selector.SetPalette(front, back);
}
public void ColorTest()
{
PaletteEntry paletteEntry = new PaletteEntry(10, Color.FromArgb(128, 10, 20, 30));
Assert.AreEqual(Color.FromArgb(128, 10, 20, 30), paletteEntry.Color);
paletteEntry.Color = Colors.Cyan;
Assert.AreEqual(Colors.Cyan, paletteEntry.Color);
}
public void ValueTest()
{
PaletteEntry paletteEntry = new PaletteEntry(10, Color.FromArgb(128, 10, 20, 30));
Assert.AreEqual(10, paletteEntry.Value);
paletteEntry.Value = -10;
Assert.AreEqual(-10, paletteEntry.Value);
}
// Shrink the palette (and thus the BitBuffer) every now and then.
// You may need to apply heuristics to determine when to do this.
public void FitPalette()
{
// Remove old entries...
for (int i = 0; i < palette.Length; i++)
{
if (palette[i].refcount == 0)
{
palette[i].blockID = 0;
paletteCount -= 1;
}
}
// Is the palette less than half of its closest power-of-two?
if (paletteCount > Mathf.Pow(paletteCount, 2f) / 2)
{
// NO: The palette cannot be shrunk!
return;
}
// decode all indices
int[] indices = new int[size];
for (int i = 0; i < indices.Length; i++)
{
indices[i] = data.Get(i, indicesLength);
}
// Create new palette, halfing it in size
indicesLength = indicesLength >> 1;
PaletteEntry[] newPalette = new PaletteEntry[Mathf.FloorToInt(Mathf.Pow(2f, (float)indicesLength))];
// We gotta compress the palette entries!
int paletteCounter = 0;
for (int pi = 0; pi < palette.Length; pi++, paletteCounter++)
{
PaletteEntry entry = newPalette[paletteCounter] = palette[pi];
// Re-encode the indices (find and replace; with limit)
for (int di = 0, fc = 0; di < indices.Length && fc < entry.refcount; di++)
{
if (pi == indices[di])
{
indices[di] = paletteCounter;
fc += 1;
}
}
}
// Allocate new BitBuffer
data = new BitBuffer(size * newPalette.Length); // this is bits, not bytes!
// Encode the indices
for (int i = 0; i < indices.Length; i++)
{
data.Set(i, indicesLength, indices[i]);
}
}
public BlockStorage(int size)
{
this._size = size;
this.indicesLength = 1;
this.paletteCount = 0;
this.palette = new PaletteEntry[1 << indicesLength];
this._data = new BitBuffer(size * indicesLength);
palette[0] = new PaletteEntry(size, 0);
}
public void ToStringTest()
{
PaletteEntry paletteEntry1 = new PaletteEntry();
PaletteEntry paletteEntry2 = new PaletteEntry(1, Colors.Black);
string s1 = paletteEntry1.ToString();
string s2 = paletteEntry2.ToString();
Assert.IsNotNull(s1);
Assert.IsNotNull(s2);
Assert.AreNotEqual(s1, s2);
}
public void GetHashCodeTest()
{
PaletteEntry paletteEntry = new PaletteEntry();
PaletteEntry paletteEntry2 = new PaletteEntry(0, Colors.Black);
PaletteEntry paletteEntry3 = new PaletteEntry(1, new Color());
Assert.AreNotEqual(paletteEntry.GetHashCode(), paletteEntry2.GetHashCode());
Assert.AreNotEqual(paletteEntry.GetHashCode(), paletteEntry3.GetHashCode());
Assert.AreNotEqual(paletteEntry2.GetHashCode(), paletteEntry3.GetHashCode());
}
public void ConstructorTest2()
{
PaletteEntry paletteEntry = new PaletteEntry(0, new Color());
Assert.AreEqual(0, paletteEntry.Value);
Assert.AreEqual(new Color(), paletteEntry.Color);
paletteEntry = new PaletteEntry(1, Colors.Red);
Assert.AreEqual(1, paletteEntry.Value);
Assert.AreEqual(Colors.Red, paletteEntry.Color);
}
Color GetSeriesColor(Series series, ChartControl chartControl)
{
int seriesIndex = chartControl.Series.IndexOf(series);
string paletteName = chartControl.PaletteName;
Palette currentPalette = chartControl.PaletteRepository[paletteName];
PaletteEntry paletteEntryAccordingToSeries = currentPalette[seriesIndex];
Color result = paletteEntryAccordingToSeries.Color;
return(result);
}
public void Set(int index, byte r, byte g, byte b, int priority) {
_entries[index] = new PaletteEntry();
_entries[index].Index = index;
_entries[index].Color.A = 255;
_entries[index].Color.R = r;
_entries[index].Color.G = g;
_entries[index].Color.B = b;
_entries[index].Priority = priority;
_isCompiled = false;
}
private static void CreateStudyProgressPalette()
{
var entry1 = new PaletteEntry(Color.FromArgb(124, 186, 180), Color.FromArgb(127, 192, 185));
var entry2 = new PaletteEntry(Color.FromArgb(146, 199, 226), Color.FromArgb(117, 181, 214));
var entry3 = new PaletteEntry(Color.FromArgb(183, 140, 155), Color.FromArgb(200, 164, 176));
var entry4 = new PaletteEntry(Color.FromArgb(242, 202, 132), Color.FromArgb(246, 211, 149));
var entry5 = new PaletteEntry(Color.FromArgb(167, 202, 116), Color.FromArgb(172, 206, 118));
studyProgressPalette = new Palette(StudyProgressPaletteName,
new[] { entry1, entry2, entry3, entry4, entry5 });
}
private static void CreateStudyProgressPalette()
{
var entry1 = new PaletteEntry(Color.FromArgb(124, 186, 180), Color.FromArgb(127, 192, 185));
var entry2 = new PaletteEntry(Color.FromArgb(146, 199, 226), Color.FromArgb(117, 181, 214));
var entry3 = new PaletteEntry(Color.FromArgb(183, 140, 155), Color.FromArgb(200, 164, 176));
var entry4 = new PaletteEntry(Color.FromArgb(242, 202, 132), Color.FromArgb(246, 211, 149));
var entry5 = new PaletteEntry(Color.FromArgb(167, 202, 116), Color.FromArgb(172, 206, 118));
studyProgressPalette = new Palette(StudyProgressPaletteName,
new[] {entry1, entry2, entry3, entry4, entry5});
}
// Shrink the palette because it may be too big (old entries removed)
private void FitPalette()
{
for (int i = 0; i < palette.Length; i++)
{
// Remove old entries
if (palette[i] != null && palette[i].refcount == 0)
{
palette[i] = null;
paletteCount -= 1;
}
}
if (paletteCount > PowerOfTwo(paletteCount) / 2)
{
// Cannot shrink palette
return;
}
int[] indices = new int[_size];
for (int i = 0; i < _size; i++)
{
indices[i] = (int)_data.GetBits(i * indicesLength, indicesLength).Data;
}
indicesLength = indicesLength >> 1;
PaletteEntry[] newPalette = new PaletteEntry[(int)MathF.Pow(2, indicesLength)];
int paletteCounter = 0;
for (int pi = 0; pi < palette.Length; pi++, paletteCounter++)
{
PaletteEntry entry = newPalette[paletteCounter] = palette[pi];
for (int di = 0, fc = 0; di < indicesLength && fc < entry.refcount; di++)
{
if (pi == indices[di])
{
indices[di] = paletteCounter;
fc += 1;
}
}
}
// allocate a new bitbuffer
_data = new BitBuffer(_size * indicesLength);
// Reencode indices
for (int i = 0; i < indices.Length; i++)
{
_data.SetBits(i * indicesLength, indicesLength, new BitArray32((uint)indices[i]));
}
}
public void SetBlock(int index, int blockID)
{
int paletteIndex = data.Get(index, indicesLength /*, true*/);
if (paletteIndex < 0 || paletteIndex > palette.Length - 1)
{
Debug.LogError("paletteIndex: " + paletteIndex);
return;
}
PaletteEntry current = palette[paletteIndex];
// Whatever block is there will cease to exist in but a moment...
current.refcount -= 1;
// The following steps/choices *must* be ordered like they are.
// --- Is the block-type already in the palette?
int currentPaletteIndex = System.Array.FindIndex <PaletteEntry>(palette, entry => { return(entry.blockID.Equals(blockID)); });
if (currentPaletteIndex != -1)
{
//Debug.LogError("Already in palette: " + type.ToString());
// YES: Use the existing palette entry.
data.Set(index, indicesLength, currentPaletteIndex);
palette[currentPaletteIndex].refcount += 1;
return;
}
// --- Can we overwrite the current palette entry?
if (current.refcount == 0)
{
Debug.Log("Overwrite current palette entry");
// YES, we can!
current.blockID = blockID;
current.refcount = 1;
return;
}
Debug.Log("Add new Palette:" + blockID.ToString());
// --- A new palette entry is needed!
// Get the first free palette entry, possibly growing the palette!
int newEntry = NewPaletteEntry();
palette[newEntry] = new PaletteEntry {
refcount = 1, blockID = blockID
};
data.Set(index, indicesLength, newEntry /*, true*/);
paletteCount += 1;
}
/// <summary>
/// Returns a PaletteEntry array from a quantized image
/// </summary>
/// <typeparam name="TPixel"></typeparam>
/// <param name="quantized">Quantized image</param>
/// <returns>Array of Palette Entries</returns>
private PaletteEntry[] GetPalette <TPixel>(IndexedImageFrame <TPixel> quantized) where TPixel : unmanaged, IPixel <TPixel>
{
ReadOnlySpan <TPixel> sourcePalette = quantized.Palette.Span;
int paletteLength = sourcePalette.Length;
PaletteEntry[] destinationPalette = new PaletteEntry[paletteLength];
for (int i = 0; i < paletteLength; i++)
{
Rgba32 rgba = new Rgba32();
sourcePalette[i].ToRgba32(ref rgba);
destinationPalette[i] = new PaletteEntry(rgba.A, rgba.R, rgba.G, rgba.B);
}
return(destinationPalette);
}
public void EqualsTest()
{
PaletteEntry paletteEntry = new PaletteEntry();
PaletteEntry paletteEntry2 = new PaletteEntry(0, Colors.Black);
PaletteEntry paletteEntry3 = new PaletteEntry(1, new Color());
Assert.IsTrue(paletteEntry.Equals(paletteEntry));
Assert.IsTrue(paletteEntry.Equals((object)paletteEntry));
Assert.IsFalse(paletteEntry.Equals(paletteEntry2));
Assert.IsFalse(paletteEntry.Equals(paletteEntry3));
Assert.IsFalse(paletteEntry2.Equals(paletteEntry3));
Assert.IsFalse(paletteEntry.Equals(null));
Assert.IsFalse(paletteEntry.Equals(new Color()));
}
static void AddEntry(Player p, ImagePalette palette, PaletteEntry entry)
{
PaletteEntry[] entries = palette.Entries;
List <PaletteEntry> newEntries = new List <PaletteEntry>();
if (entries != null)
{
newEntries.AddRange(entries);
}
newEntries.Add(entry);
palette.Entries = newEntries.ToArray();
palette.Save();
p.Message("Added block to entries of palette {0}", palette.Name);
}
private RadCartesianChartView createChart()
{
//Create the Chart View
RadCartesianChartView chart = new RadCartesianChartView(this.Activity);
LinearAxis verticalAxis = new LinearAxis();
//The values in the linear axis will not have values after the decimal point.
verticalAxis.LabelFormat = "%.0f";
CategoricalAxis horizontalAxis = new CategoricalAxis();
chart.VerticalAxis = verticalAxis;
chart.HorizontalAxis = horizontalAxis;
for (int i = 0; i < 3; i++)
{
//Create the bar series and attach axes and value bindings.
AreaSeries areaSeries = new AreaSeries();
//We want to stack the different area series.
areaSeries.CombineMode = ChartSeriesCombineMode.Stack;
areaSeries.ValueBinding = new ValueBinding();
areaSeries.CategoryBinding = new CategoryBinding();
//Bind series to data
areaSeries.Data = this.getData();
//Add series to chart
chart.Series.Add(areaSeries);
}
ChartPalette defaultPaletteClone = new ChartPalette(chart.Palette);
// We acquire the palette entry containing the settings for the third series in the chart setup.
PaletteEntry areaSeriesEntry = defaultPaletteClone.GetEntry(ChartPalette.AreaFamily, 2);
//We set the fill color of the third series to be cyan.
areaSeriesEntry.Fill = Color.Cyan;
//We reset the chart palette by applying the new one.
chart.Palette = defaultPaletteClone;
return(chart);
}
private static PaletteEntry GetClosestPaletteEntry(PaletteEntry[] palette, HdrColor color)
{
PaletteEntry closestEntry = null;
var closestDistance = double.PositiveInfinity;
for (var palleteIndex = 0; palleteIndex < palette.Length; palleteIndex++)
{
var currentEntry = palette[palleteIndex];
var currentDistance = (currentEntry.Color - color).Length;
if (currentDistance < closestDistance)
{
closestEntry = currentEntry;
closestDistance = currentDistance;
}
}
return(closestEntry);
}
// Setting the wrong bit :eyesBlur:
public void SetBlock(int index, int blockType)
{
// Get the type of block at that position
int paletteIndex = (int)_data.GetBits(index * indicesLength, indicesLength).Data;
PaletteEntry current = palette[paletteIndex];
// That block at the position no longer exists, so one less reference of the block in the palette
current.refcount -= 1;
// Is the block type already in the palette
int replace = -1;
for (int i = 0; i < palette.Length; i++)
{
if (palette[i] != null && palette[i].type == blockType)
{
replace = i;
break;
}
}
if (replace != -1)
{
_data.SetBits(index * indicesLength, indicesLength, new BitArray32((uint)replace));
palette[replace].refcount += 1;
return;
}
// Otherwise if we can overwrite the current palette entry
if (current.refcount == 0)
{
current.type = blockType;
current.refcount = 1;
return;
}
// A new palette entry is needed!
int newEntry = NewPaletteEntry();
palette[newEntry] = new PaletteEntry(1, blockType);
_data.SetBits(index * indicesLength, indicesLength, new BitArray32((uint)newEntry));
paletteCount += 1;
}
private static PaletteEntry[] GeneratePalette(HdrColor[] subPixelColors)
{
var palette = new PaletteEntry[1 << subPixelColors.Length];
for (var paletteIndex = 0; paletteIndex < palette.Length; paletteIndex++)
{
var currentColor = new HdrColor();
var outputColor = new bool[subPixelColors.Length];
for (var subPixelIndex = 0; subPixelIndex < subPixelColors.Length; subPixelIndex++)
{
if (((paletteIndex >> subPixelIndex) & 1) == 1)
{
currentColor += subPixelColors[subPixelIndex];
outputColor[subPixelIndex] = true;
}
}
palette[paletteIndex] = new PaletteEntry(currentColor, outputColor);
}
return(palette);
}
void CalcLayerColors()
{
PaletteEntry[] front = new PaletteEntry[Palette.Entries.Length];
PaletteEntry[] back = new PaletteEntry[Palette.Entries.Length];
ColorDesc sun = Colors.ParseHex("FFFFFF");
ColorDesc dark = Colors.ParseHex("9B9B9B");
if (Utils.IsValidHex(Level.Config.LightColor))
{
sun = Colors.ParseHex(Level.Config.LightColor);
}
if (Utils.IsValidHex(Level.Config.ShadowColor))
{
dark = Colors.ParseHex(Level.Config.ShadowColor);
}
for (int i = 0; i < Palette.Entries.Length; i++)
{
PaletteEntry entry = Palette.Entries[i];
ExtBlock block = ExtBlock.FromRaw(entry.Raw);
BlockDefinition def = Level.GetBlockDef(block);
if (def != null && def.FullBright)
{
front[i] = Multiply(entry, Colors.ParseHex("FFFFFF"));
back[i] = Multiply(entry, Colors.ParseHex("FFFFFF"));
}
else
{
front[i] = Multiply(entry, sun);
back[i] = Multiply(entry, dark);
}
}
selector.SetPalette(front, back);
}
static string FormatEntry(PaletteEntry e, Player p)
{
return(Block.GetName(p, e.Block) + " - " + Utils.Hex(e.R, e.G, e.B));
}
public void ConstructorTest()
{
PaletteEntry paletteEntry = new PaletteEntry();
Assert.AreEqual(0, paletteEntry.Value);
Assert.AreEqual(new Color(), paletteEntry.Color);
}
public static void Render(Stream s)
{
using (BinaryReader r = new BinaryReader(s)) {
byte flags = r.ReadByte();
byte width = r.ReadByte();
byte height = r.ReadByte();
byte paletteCount = r.ReadByte();
PaletteEntry[] palette = new PaletteEntry[paletteCount];
for (int k = 0; k < paletteCount; k++)
{
char character = r.ReadChar();
byte attributes = r.ReadByte();
palette[k] = new PaletteEntry {
Character = character, Attributes = attributes
};
}
byte frameCount = r.ReadByte();
ushort frameLength = (ushort)(width * height);
// Load image into memory buffer
int[] indices = new int[frameLength];
int i = 0;
while (r.BaseStream.Position < r.BaseStream.Length)
{
byte n = r.ReadByte();
if (n == 0) // New frame - not supported
{
return;
}
else
{
byte paletteIndex = r.ReadByte();
for (int k = 0; k < n; k++)
{
if (i >= frameLength)
{
return;
}
indices[i] = paletteIndex;
i++;
}
}
}
// Render to console (multi-platform)
ConsoleColor originalForeground = Console.ForegroundColor;
ConsoleColor originalBackground = Console.BackgroundColor;
int cursorLeft = ((Console.BufferWidth - width) >> 1);
for (int y = 0; y < height; y++)
{
Console.CursorLeft = cursorLeft;
for (int x = 0; x < width; x++)
{
ref PaletteEntry entry = ref palette[indices[x + y * width]];
Console.ForegroundColor = (ConsoleColor)(entry.Attributes & 0x0F);
Console.BackgroundColor = (ConsoleColor)((entry.Attributes >> 4) & 0x0F);
Console.Write(entry.Character);
}
Console.CursorTop++;
}
Console.SetCursorPosition(0, Console.CursorTop + 1);
Console.ForegroundColor = originalForeground;
Console.BackgroundColor = originalBackground;
Console.ResetColor();
}
/// <summary>
/// Saves a texture to a file.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="format">The format.</param>
/// <param name="palette">The palette.</param>
/// <returns>A <see cref="SharpDX.Result" /> object describing the result of the operation.</returns>
/// <unmanaged>HRESULT D3DXSaveTextureToFileW([In] const wchar_t* pDestFile,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
public static void ToFile(BaseTexture texture, string fileName, ImageFileFormat format, PaletteEntry[] palette)
{
D3DX9.SaveTextureToFileW(fileName, format, texture, palette);
}
/// <summary>
/// Saves a texture to a stream.
/// </summary>
/// <param name="texture">The texture.</param>
/// <param name="format">The format.</param>
/// <param name="palette">The palette.</param>
/// <returns>A <see cref="DataStream"/> containing the saved texture.</returns>
/// <unmanaged>HRESULT D3DXSaveTextureToFileInMemory([Out] ID3DXBuffer** ppDestBuf,[In] D3DXIMAGE_FILEFORMAT DestFormat,[In] IDirect3DBaseTexture9* pSrcTexture,[In, Buffer] const PALETTEENTRY* pSrcPalette)</unmanaged>
public static DataStream ToStream(BaseTexture texture, ImageFileFormat format, PaletteEntry[] palette)
{
return new DataStream(D3DX9.SaveTextureToFileInMemory(format, texture, palette));
}
/// <summary>
/// Filters mipmap levels of a texture.
/// </summary>
/// <param name="sourceLevel">The source level.</param>
/// <param name="filter">The filter.</param>
/// <param name="palette">The palette.</param>
/// <returns>
/// A <see cref="SharpDX.Result"/> object describing the result of the operation.
/// </returns>
/// <unmanaged>HRESULT D3DXFilterTexture([In] IDirect3DBaseTexture9* pBaseTexture,[In, Buffer] const PALETTEENTRY* pPalette,[In] unsigned int SrcLevel,[In] D3DX_FILTER Filter)</unmanaged>
public void FilterTexture(int sourceLevel, Filter filter, PaletteEntry[] palette)
{
D3DX9.FilterTexture(this, palette, sourceLevel, filter);
}
static string FormatEntry(PaletteEntry e, Level lvl)
{
ExtBlock block = ExtBlock.FromRaw(e.Raw);
return(lvl.BlockName(block) + " - " + Utils.Hex(e.R, e.G, e.B));
}
void Export()
{
string path = EditorUtility.SaveFilePanelInProject("Export structure...", "struct_file", "json", "Export...");
if (path.Length == 0)
{
return;
}
JsonStructure toExport = new JsonStructure();
if (structure.structureUID == string.Empty)
{
Debug.LogError("Missing Structure ID! Check Structure Details category.");
return;
}
toExport.uniqueName = structure.structureUID;
toExport.width = (int)size.x;
toExport.height = (int)size.y;
toExport.length = (int)size.z;
toExport.palette = new List <JsonPaletteEntry>();
foreach (PaletteEntry entry in structure.palette)
{
if (!entry.isValid)
{
Debug.LogError("Invalid palette entry! Check Palette category.");
return;
}
toExport.palette.Add(new JsonPaletteEntry(entry.isOreDict? "ore" : entry.mod, entry.name, entry.identifier, entry.meta));
}
Block master = structure.validFullBlocks.FirstOrDefault(x => x.pos == structure.masterPos);
if (master == null)
{
Debug.LogError("Master block not set or missing palette value! Check Composition category.");
return;
}
PaletteEntry masterPaletteEntry = structure.palette.FirstOrDefault(x => x.identifier == master.paletteValue);
if (masterPaletteEntry == null)
{
Debug.LogError("Master block is missing valid palette value! Check Composition and Palette categories.");
return;
}
toExport.master = new JsonMaster(
calculator.BlockPosToLocalX(master.pos),
calculator.BlockPosToLocalY(master.pos),
calculator.BlockPosToLocalZ(master.pos),
masterPaletteEntry.isOreDict ? "ore" :
masterPaletteEntry.mod, masterPaletteEntry.name, masterPaletteEntry.meta);
toExport.pointsOfInterest = new List <JsonPoI>();
foreach (PoI poi in structure.pointsOfInterest)
{
if (structure.ignoredPositions2.Contains(poi.pos) || !structure.validFullBlocks.Any(x => x.pos == poi.pos))
{
continue;
}
toExport.pointsOfInterest.Add(new JsonPoI()
{
position = poi.pos, name = poi.id, facing = poi.facing
});
}
int firstDimension = AABBGenerator.FirstDimension((int)size.x, (int)size.y, (int)size.z, editorSettings.axisOrder);
int secondDimension = AABBGenerator.SecondDimension((int)size.x, (int)size.y, (int)size.z, editorSettings.axisOrder);
int thirdDimension = AABBGenerator.ThirdDimension((int)size.x, (int)size.y, (int)size.z, editorSettings.axisOrder);
toExport.structure = new List <string>();
string emptyLine = new string(' ', firstDimension);
for (int line = 0; line < secondDimension * thirdDimension; line++)
{
toExport.structure.Add(emptyLine);
}
foreach (Block block in structure.validFullBlocks)
{
if (structure.ignoredPositions2.Contains(block.pos))
{
continue;
}
if (block.IsInvalid())
{
Debug.LogError(string.Format("Block {0} is missing valid palette value! Check Composition and Palette categories.", block.pos));
return;
}
int firstPos = AABBGenerator.RelativeX(block.pos, editorSettings.axisOrder, size);
int secondPos = AABBGenerator.RelativeZ(block.pos, editorSettings.axisOrder, size);
int thirdPos = AABBGenerator.RelativeY(block.pos, editorSettings.axisOrder, size);
//Debug.Log(string.Format("{0}, {1}, {2}, {3}, {4}", firstPos, secondPos, thirdPos, toExport.structure[thirdPos * secondDimension + secondPos].Length, block.paletteValue));
toExport.structure[thirdPos * secondDimension + secondPos] = ReplaceAt(toExport.structure[thirdPos * secondDimension + secondPos], firstPos, block.paletteValue);
}
toExport.AABB = new List <byte>();
List <Box>[] orderedList = new List <Box> [(int)(size.x * size.y * size.z)];
foreach (BlockPosition aabb in structure.allSubAABBs)
{
if (orderedList[aabb.pos] == null)
{
orderedList[aabb.pos] = new List <Box>();
}
orderedList[aabb.pos].Add(aabb.normalizedBox);
}
Box fullBox = new Box(0, 0, 0, 16, 16, 16);
StringBuilder builder = new StringBuilder();
for (int index = 0; index < orderedList.Length; index++)
{
if (structure.ignoredPositions2.Contains(index) || orderedList[index] == null) //no collision boxes
{
builder.Append("null");
}
else if (orderedList[index].Count == 1 && orderedList[index][0] == fullBox) //full collision box
{
builder.Append("[]");
}
else //partial collision boxes
{
List <string> floats = new List <string>();
foreach (Box box in orderedList[index])
{
floats.Add(box.ToString(editorSettings.outputFormat));
}
builder.Append("[" + string.Join(",", floats) + "]");
}
builder.Append(",");
}
builder.Length -= 1;
string json = JsonUtility.ToJson(toExport, false);
json = json.Insert(json.LastIndexOf('[') + 1, builder.ToString());
using (StreamWriter writer = new StreamWriter(path)) {
writer.Write(json);
writer.Flush();
writer.Close();
}
}
private RadPieChartView createChart()
{
InitChartData();
RadPieChartView pieChartView = new RadPieChartView(this);
CustomPieSeries pieSeries = new CustomPieSeries();
pieSeries.ValueBinding = new MonthResultDataBinding("Result");
pieSeries.Data = (Java.Lang.IIterable) this.monthResults;
pieSeries.ShowLabels = true;
pieSeries.LabelValueToStringConverter = new ValueToStringConverter();
pieSeries.LabelOffset = -50;
ChartPalette customPalette = pieChartView.Palette;
PaletteEntry paid = customPalette.GetEntry(ChartPalette.PieFamily, 0);
paid.Fill = Color.ParseColor("#00757D");
PaletteEntry remaining = customPalette.GetEntry(ChartPalette.PieFamily, 1);
remaining.Fill = Color.ParseColor("#75c283");
PaletteEntry overdue = customPalette.GetEntry(ChartPalette.PieFamily, 2);
overdue.Fill = Color.ParseColor("#f14844");
//pieChartView.Palette = customPalette;
SliceStyle blueStyle = new SliceStyle();
blueStyle.FillColor = Color.ParseColor("#00757D");
blueStyle.StrokeColor = Color.ParseColor("#00757D");
blueStyle.StrokeWidth = 2;
blueStyle.ArcColor = Color.White;
blueStyle.ArcWidth = 2;
SliceStyle greenStyle = new SliceStyle();
greenStyle.FillColor = Color.ParseColor("#75c283");
greenStyle.StrokeColor = Color.ParseColor("#75c283");
greenStyle.StrokeWidth = 2;
greenStyle.ArcColor = Color.White;
greenStyle.ArcWidth = 2;
SliceStyle redStyle = new SliceStyle();
redStyle.FillColor = Color.ParseColor("#f14844");
redStyle.StrokeColor = Color.ParseColor("#f14844");
redStyle.StrokeWidth = 2;
redStyle.ArcColor = Color.White;
redStyle.ArcWidth = 2;
List <SliceStyle> styles = new List <SliceStyle>();
if (this.IsBlue && this.IsGreen && this.IsRed)
{
styles.Add(blueStyle);
styles.Add(greenStyle);
styles.Add(redStyle);
}
else if (this.IsBlue && this.IsGreen)
{
styles.Add(blueStyle);
styles.Add(greenStyle);
}
else if (this.IsBlue && this.IsRed)
{
styles.Add(blueStyle);
styles.Add(redStyle);
}
else if (this.IsGreen && this.IsRed)
{
styles.Add(greenStyle);
styles.Add(redStyle);
}
else if (this.IsBlue)
{
styles.Add(blueStyle);
}
else if (this.IsGreen)
{
styles.Add(greenStyle);
}
else if (this.IsRed)
{
styles.Add(redStyle);
}
pieSeries.SliceStyles = styles;
pieChartView.Series.Add(pieSeries);
return(pieChartView);
}