SignToolsGUI/GUI.cs

1053 lines
44 KiB
C#

using LZ4;
using ProtoBuf;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Windows.Forms;
namespace SignToolsGUI
{
public partial class GUI : Form
{
WorldSerialization worldSerialization = new WorldSerialization();
uint Version;
int SupportedFrames = 0;
public static Dictionary<string, List<byte[]>> SerializedImageData = new Dictionary<string, List<byte[]>>();
public static Dictionary<string, List<byte[]>> ModdedSerializedImageData = new Dictionary<string, List<byte[]>>();
Dictionary<string, uint> SerializedSkinData = new Dictionary<string, uint>();
Dictionary<string, uint> ModdedSerializedSkinData = new Dictionary<string, uint>();
public static Dictionary<string, string> PluginsData = new Dictionary<string, string>();
uint[] signids = { 1447270506, 4057957010, 120534793, 58270319, 4290170446, 3188315846, 3215377795, 1960724311, 3159642196, 3725754530, 1957158128, 637495597, 1283107100, 4006597758, 3715545584, 3479792512, 3618197174, 550204242 };
uint[] Neons = { 708840119, 3591916872, 3919686896, 2628005754, 3168507223 };
uint[] skinnableids = { 1844023509, 177343599, 3994459244, 4196580066, 3110378351, 2206646561, 2931042549, 159326486, 2245774897, 1560881570, 3647679950, 170207918, 202293038, 1343928398, 43442943, 201071098, 1418678061, 2662124780, 2057881102, 2335812770, 2905007296, 3884356627 };
private Dictionary<string, SignSize> _signSizes = new Dictionary<string, SignSize>
{
{"4006597758", new SignSize(64, 64)},
{"3215377795", new SignSize(256, 128)},
{"3159642196", new SignSize(128, 512)},
{"1960724311", new SignSize(128, 256)},
{"3725754530", new SignSize(1024, 512)},
{"1957158128", new SignSize(512, 512)},
{"1447270506", new SignSize(128, 64)},
{"3715545584", new SignSize(256, 128)},
{"3479792512", new SignSize(256, 128)},
{"3618197174", new SignSize(512, 128)},
{"637495597", new SignSize(64, 256)},
{"3188315846", new SignSize(64, 256)},
{"58270319", new SignSize(128, 64)},
{"4290170446", new SignSize(256, 256)},
{"120534793", new SignSize(256, 128)},
{"4057957010", new SignSize(256, 128)},
{"550204242", new SignSize(128, 256)},
{"1283107100", new SignSize(256, 128)},
{"708840119", new SignSize(250, 250)},
{"3168507223", new SignSize(250, 250)},
{"3591916872", new SignSize(215, 125)},
{"2628005754", new SignSize(215, 125)},
{"3919686896", new SignSize(125, 125)},
};
private Dictionary<string, string> _Names = new Dictionary<string, string>
{
{"4006597758", "spinner.wheel"},
{"3215377795", "sign.pictureframe.landscape"},
{"3159642196", "sign.pictureframe.tall"},
{"1960724311", "sign.pictureframe.portrait"},
{"3725754530", "sign.pictureframe.xxl"},
{"1957158128", "sign.pictureframe.xl"},
{"1447270506", "sign.small.wood"},
{"3715545584", "sign.medium.wood"},
{"3479792512", "sign.large.wood"},
{"3618197174", "sign.huge.wood"},
{"637495597", "sign.hanging.banner.large"},
{"3188315846", "sign.pole.banner.large"},
{"58270319", "sign.post.single"},
{"4290170446", "sign.post.double"},
{"120534793", "sign.post.town"},
{"4057957010", "sign.post.town.roof"},
{"550204242", "sign.hanging"},
{"1283107100", "sign.hanging.ornate"},
{"1844023509", "Fridge" },
{"177343599", "Lockers" },
{"3994459244", "Reactive.Target" },
{"4196580066", "Rug" },
{"3110378351", "Rug.Bear" },
{"2206646561", "Box.Large" },
{"2931042549","Furnace" },
{"159326486", "Sleeping.Bag" },
{"2245774897","VendingMachine" },
{"1560881570","Box.Small" },
{"3647679950","GarageDoor" },
{"170207918","ArmourDoor" },
{"202293038","MetalDoor" },
{"1343928398","WoodDoor" },
{"43442943","Double.WoodDoor" },
{"201071098","Double.ArmourDoor" },
{"1418678061","Double.MetalDoor" },
{"2662124780","Table" },
{"2057881102","Barricade.Concrete" },
{"2335812770","Barricade.Sandbags" },
{"2905007296","Waterpurifier" },
{"708840119", "sign.neon.xl.animated" },
{"3591916872","sign.neon.125x215.animated"},
{"3919686896","sign.neon.125x125"},
{"2628005754","sign.neon.125x215"},
{"3168507223","sign.neon.xl"},
{"3884356627","assets/spray.decal" }
};
public String Blanked = "iVBORw0KGgoAAAANSUhEUgAAANcAAAB9CAYAAAAx+vY9AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAB/SURBVHhe7cGBAAAAAMOg+VNf4QBVAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8aqR4AAFsKyZjAAAAAElFTkSuQmCC";
private class SignSize
{
public int Width;
public int Height;
public SignSize(int width, int height)
{
Width = width;
Height = height;
}
}
public GUI()
{
InitializeComponent();
}
public static string Base64Encode(string plainText)
{
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
return System.Convert.ToBase64String(plainTextBytes);
}
public static string Base64Decode(string base64EncodedData)
{
var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
}
void XMLDecode(string SerialData)
{
string[] DataParse = SerialData.Split(new string[] { "<position>" }, StringSplitOptions.None);
foreach (string xmldata in DataParse)
{
if (xmldata.Contains("xml version")) continue;
string x = xmldata.Split(new string[] { "</x><y>" }, StringSplitOptions.None)[0].Replace("<x>", "");
string y = xmldata.Split(new string[] { "</y><z>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>", "");
string z = xmldata.Split(new string[] { "</z></position>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>" + y + "</y><z>", "");
string texture = xmldata.Split(new string[] { "<texture>" }, StringSplitOptions.None)[1].Replace("</texture>", "").Replace("</SerializedImageData>", "");
if(texture.Length < 50)
{
continue;
}
string[] imageFrames = texture.Split(new string[] { "<frame>" }, StringSplitOptions.None);
List<byte[]> ImageData = new List<byte[]>();
foreach (string imageframe in imageFrames)
{
if(imageframe != "")
ImageData.Add(Convert.FromBase64String(imageframe.Replace("<frame>", "")));
}
try
{
SerializedImageData.Add("(" + x + ", " + y + ", " + z + ")", ImageData);
}
catch { }
}
}
void XMLDecodePlugins(string PluginData)
{
string[] DataParse = PluginData.Split(new string[] { "<name>" }, StringSplitOptions.None);
foreach (string xmldata in DataParse)
{
if (xmldata.Contains("xml version")) continue;
string Name = xmldata.Split(new string[] { "</name>" }, StringSplitOptions.None)[0];
string Data = xmldata.Split(new string[] { "</data>" }, StringSplitOptions.None)[0].Split(new string[] { "<data>" }, StringSplitOptions.None)[1];
if (!PluginsData.ContainsKey(Name))
{
PluginsData.Add(Name, Base64Decode(Data));
}
}
}
void XMLDecodeSkin(string SerialData)
{
string[] DataParse = SerialData.Split(new string[] { "<position>" }, StringSplitOptions.None);
foreach (string xmldata in DataParse)
{
if (xmldata.Contains("xml version")) continue;
string x = xmldata.Split(new string[] { "</x><y>" }, StringSplitOptions.None)[0].Replace("<x>", "");
string y = xmldata.Split(new string[] { "</y><z>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>", "");
string z = xmldata.Split(new string[] { "</z></position>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>" + y + "</y><z>", "");
uint skinid = uint.Parse(xmldata.Split(new string[] { "<skin>" }, StringSplitOptions.None)[1].Replace("</skin>", "").Replace("</SerializedSkinData>", ""));
SerializedSkinData.Add("(" + x + ", " + y + ", " + z + ")", skinid);
}
}
string XMLEncode()
{
string XMLData = @"<? xml version=""1.0""?><SerializedImageData>";
string SerialData = "";
foreach (KeyValuePair<string, List<byte[]>> _sign in ModdedSerializedImageData)
{
string[] xmlbreakdown = _sign.Key.Replace("(", "").Replace(" ", "").Replace(")", "").Split(',');
SerialData += "<position>" +
"<x>" + xmlbreakdown[0] + "</x>" +
"<y>" + xmlbreakdown[1] + "</y>" +
"<z>" + xmlbreakdown[2] + "</z>" +
"</position>" +
"<texture>";
for (int ids = 0; ids < _sign.Value.Count; ids++)
{
try
{
SerialData += Convert.ToBase64String(_sign.Value[ids]) + "<frame>";
}
catch
{
SerialData += Blanked + "<frame>";
}
}
SerialData += "</texture>";
}
XMLData = XMLData + SerialData + "</SerializedImageData>";
return XMLData;
}
string XMLEncodePlugin()
{
string XMLData = @"<? xml version=""1.0""?><SerializedPluginData>";
string SerialData = "";
foreach (KeyValuePair<string, string> _plugins in PluginsData)
{
SerialData += "<name>" + _plugins.Key + "</name>" +
"<data>" + Base64Encode(_plugins.Value) + "</data>";
}
XMLData += SerialData + "</SerializedPluginData>";
return XMLData;
}
string XMLEncodeSkin()
{
string XMLData = @"<? xml version=""1.0""?><SerializedSkinData>";
string SerialData = "";
foreach (KeyValuePair<string, uint> _skin in ModdedSerializedSkinData)
{
string[] xmlbreakdown = _skin.Key.Replace("(", "").Replace(" ", "").Replace(")", "").Split(',');
SerialData += ("<position>" +
"<x>" + xmlbreakdown[0] + "</x>" +
"<y>" + xmlbreakdown[1] + "</y>" +
"<z>" + xmlbreakdown[2] + "</z>" +
"</position>" +
"<skin>" +
_skin.Value +
"</skin>");
}
XMLData = XMLData + SerialData + "</SerializedSkinData>";
return XMLData;
}
private void DisableButtons()
{
SaveMap.Enabled = false;
Locations.Enabled = false;
AddImage.Enabled = false;
ImagePreview.Enabled = false;
RemoveImage.Enabled = false;
}
private bool isSign(PrefabData sign)
{
//Checks prefab has a valid sign id
return (signids.Contains(sign.id) || Neons.Contains(sign.id));
}
private bool isSkinnable(PrefabData entity)
{
//Checks prefab has a valid skinnable id
return (skinnableids.Contains(entity.id));
}
byte[] ImageResize(byte[] imageBytes, int width, int height)
{
//Resize image to sign size.
Bitmap resizedImage = new Bitmap(width, height),
sourceImage = new Bitmap(new MemoryStream(imageBytes));
Graphics.FromImage(resizedImage).DrawImage(sourceImage, new Rectangle(0, 0, width, height),
new Rectangle(0, 0, sourceImage.Width, sourceImage.Height), GraphicsUnit.Pixel);
var ms = new MemoryStream();
resizedImage.Save(ms, ImageFormat.Png);
return ms.ToArray();
}
public static bool OpenProcessing = false;
private void OpenMap_Click(object sender, EventArgs e)
{
PluginsData.Clear();
worldSerialization.Clear();
Locations.Items.Clear();
SerializedImageData.Clear();
ModdedSerializedImageData.Clear();
SkinLocations.Items.Clear();
SerializedSkinData.Clear();
ModdedSerializedSkinData.Clear();
ImagePreview.Image = null;
SaveMap.Enabled = false;
Locations.Enabled = false;
AddImage.Enabled = false;
ImagePreview.Enabled = false;
SignType.Enabled = false;
RemoveImage.Enabled = false;
SkinLocations.Enabled = false;
AddSkin.Enabled = false;
RemoveSkin.Enabled = false;
Export.Enabled = false;
Import.Enabled = false;
Framenumber.Enabled = false;
FrameUp.Enabled = false;
Framedown.Enabled = false;
Plugins.Enabled = false;
OpenFileDialog openFileDialog1 = new OpenFileDialog
{
Title = "Rust Map File",
CheckFileExists = true,
CheckPathExists = true,
DefaultExt = "map",
Filter = "map files (*.map)|*.map",
FilterIndex = 2,
RestoreDirectory = true,
ReadOnlyChecked = true,
ShowReadOnly = true
};
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
mapdir.Text = openFileDialog1.FileName;
// try
// {
worldSerialization.Load(mapdir.Text);
Version = worldSerialization.Version;
//Check for exsisting
for (int i = worldSerialization.world.maps.Count - 1; i >= 0; i--)
{
MapData mapdata = worldSerialization.world.maps[i];
if (mapdata.name == Base64Encode("SerializedImageData"))
{
try
{
XMLDecode(System.Text.Encoding.UTF8.GetString(mapdata.data));
}
catch { }
}
else if (mapdata.name == Base64Encode("SerializedSkinData"))
{
try
{
XMLDecodeSkin(System.Text.Encoding.UTF8.GetString(mapdata.data));
}
catch { }
}
else if (mapdata.name == Base64Encode("SerializedPluginData"))
{
try
{
XMLDecodePlugins(System.Text.Encoding.UTF8.GetString(mapdata.data));
}
catch { }
}
}
//Scan all prefab in map file.
for (int i = worldSerialization.world.prefabs.Count - 1; i >= 0; i--)
{
PrefabData prefabdata = worldSerialization.world.prefabs[i];
if (isSign(prefabdata))
{
string location = "(" + prefabdata.position.x.ToString("0.0") + ", " + prefabdata.position.y.ToString("0.0") + ", " + prefabdata.position.z.ToString("0.0") + ")";
if (location.Contains("NaN") || location.Contains("0.0, 0.0, 0.0"))
{
continue;
}
if (SerializedImageData.ContainsKey(location))
{
if (!ModdedSerializedImageData.ContainsKey(location))
{
ModdedSerializedImageData.Add(location, SerializedImageData[location]);
Locations.Items.Add(location + " " + prefabdata.id.ToString());
}
}
else
{
List<byte[]> blank = new List<byte[]>();
if (!ModdedSerializedImageData.ContainsKey(location))
{
ModdedSerializedImageData.Add(location, blank);
Locations.Items.Add(location + " " + prefabdata.id.ToString());
}
}
}
else if (isSkinnable(prefabdata))
{
string location = "(" + prefabdata.position.x.ToString("0.0") + ", " + prefabdata.position.y.ToString("0.0") + ", " + prefabdata.position.z.ToString("0.0") + ")";
if (location.Contains("NaN") || location.Contains("0.0, 0.0, 0.0"))
{
continue;
}
if (SerializedSkinData.ContainsKey(location))
{
if (!ModdedSerializedSkinData.ContainsKey(location))
{
ModdedSerializedSkinData.Add(location, SerializedSkinData[location]);
SkinLocations.Items.Add(location + " " + prefabdata.id.ToString());
}
}
else
{
if (!ModdedSerializedSkinData.ContainsKey(location))
{
ModdedSerializedSkinData.Add(location, 0);
SkinLocations.Items.Add(location + " " + prefabdata.id.ToString());
}
}
}
}
if (Locations.Items.Count != 0)
{
Locations.Text = Locations.Items[0].ToString();
}
else if (SkinLocations.Items.Count != 0)
{
Locations.Text = SkinLocations.Items[0].ToString();
}
else
{
MessageBox.Show("No signs or skinnable items are on this map");
worldSerialization.Clear();
Locations.Items.Clear();
SerializedImageData.Clear();
ModdedSerializedImageData.Clear();
SkinLocations.Items.Clear();
SerializedSkinData.Clear();
ModdedSerializedSkinData.Clear();
return;
}
//}
//catch
//{
// MessageBox.Show("Failed to open map");
// DisableButtons();
// return;
//}
SaveMap.Enabled = true;
Locations.Enabled = true;
AddImage.Enabled = true;
ImagePreview.Enabled = true;
SignType.Enabled = true;
RemoveImage.Enabled = true;
SkinLocations.Enabled = true;
AddSkin.Enabled = true;
RemoveSkin.Enabled = true;
Export.Enabled = true;
Import.Enabled = true;
FrameUp.Enabled = true;
Framedown.Enabled = true;
Plugins.Enabled = true;
SignPosLable.Text = "Sign Positions: " + Locations.Items.Count.ToString();
SkinPosLabel.Text = "Skin Positions: " + SkinLocations.Items.Count.ToString();
}
}
private void Selection(object sender, EventArgs e)
{
try
{
string[] selected = Locations.GetItemText(Locations.SelectedItem).Split(')');
SignType.Text = selected[1].Replace(" ", "");
if (SignType.Text == "3591916872")
{
SupportedFrames = 2;
Framenumber.Text = "0";
Framenumber.Enabled = true;
FrameUp.Enabled = true;
Framedown.Enabled = true;
}
else if (SignType.Text == "708840119")
{
SupportedFrames = 4;
Framenumber.Text = "0";
Framenumber.Enabled = true;
FrameUp.Enabled = true;
Framedown.Enabled = true;
}
else
{
SupportedFrames = 0;
Framenumber.Text = "0";
Framenumber.Enabled = false;
FrameUp.Enabled = false;
Framedown.Enabled = false;
}
name.Text = _Names[SignType.Text];
Size size = new Size(_signSizes[SignType.Text].Width, _signSizes[SignType.Text].Height);
ImagePreview.Size = size;
if (ModdedSerializedImageData.ContainsKey(selected[0] + ")"))
{
if (ModdedSerializedImageData[selected[0] + ")"].Count != 0)
{
ImagePreview.Image = ByteToImage(ModdedSerializedImageData[selected[0] + ")"][int.Parse(Framenumber.Text)]);
}
else
{
ImagePreview.Image = null;
}
}
}
catch
{ }
}
private void Selection2(object sender, EventArgs e)
{
Framenumber.Enabled = false;
FrameUp.Enabled = false;
Framedown.Enabled = false;
Framenumber.Text = "0";
string[] selected = SkinLocations.GetItemText(SkinLocations.SelectedItem).Split(')');
try
{
SignType.Text = selected[1].Replace(" ", "");
name.Text = _Names[SignType.Text];
}
catch { return; }
Size size = new Size(1024, 512);
ImagePreview.Size = size;
try
{
if (ModdedSerializedSkinData[selected[0] + ")"] != 0)
{
if (ModdedSerializedSkinData.ContainsKey(selected[0] + ")"))
{
ImagePreview.Image = GetThumbNail(ModdedSerializedSkinData[selected[0] + ")"]);
return;
}
}
}
catch { }
ImagePreview.Image = null;
}
private Bitmap GetThumbNail(uint skinid)
{
try
{
WebClient wc = new WebClient();
string html = wc.DownloadString("https://steamcommunity.com/sharedfiles/filedetails/?id=" + skinid);
string[] thumbnailparse = html.Split(new string[] { "workshopItemPreviewImageEnlargeable" }, StringSplitOptions.None);
string[] thumbimage = thumbnailparse[2].Split(new string[] { "/>" }, StringSplitOptions.None);
string[] imageparse = thumbimage[0].Split(new string[] { "https://" }, StringSplitOptions.None);
string image = "";
try
{
image = "https://" + imageparse[3].Replace(@"""", "");
}
catch
{
try
{
image = "https://" + imageparse[2].Replace(@"""", "");
}
catch
{
try
{
image = "https://" + imageparse[1].Replace(@"""", "");
}
catch { }
}
}
try
{
byte[] imagedata = wc.DownloadData(image);
if (imagedata.Length > 0)
{
return ByteToImage(imagedata);
}
}
catch { }
}
catch { }
return null;
}
public static void CopyTo(Stream src, Stream dest)
{
byte[] bytes = new byte[4096];
int cnt;
while ((cnt = src.Read(bytes, 0, bytes.Length)) != 0)
{
dest.Write(bytes, 0, cnt);
}
}
public static byte[] Zip(string str)
{
var bytes = Encoding.UTF8.GetBytes(str);
using (var msi = new MemoryStream(bytes))
using (var mso = new MemoryStream())
{
using (var gs = new GZipStream(mso, CompressionMode.Compress))
{
CopyTo(msi, gs);
}
return mso.ToArray();
}
}
public static string Unzip(byte[] bytes)
{
using (var msi = new MemoryStream(bytes))
using (var mso = new MemoryStream())
{
using (var gs = new GZipStream(msi, CompressionMode.Decompress))
{
//gs.CopyTo(mso);
CopyTo(gs, mso);
}
return Encoding.UTF8.GetString(mso.ToArray());
}
}
public static Bitmap ByteToImage(byte[] blob)
{
MemoryStream mStream = new MemoryStream();
byte[] pData = blob;
mStream.Write(pData, 0, Convert.ToInt32(pData.Length));
Bitmap bm = new Bitmap(mStream, false);
mStream.Dispose();
return bm;
}
private void AddImage_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog1 = new OpenFileDialog
{
Title = "Image File",
CheckFileExists = true,
CheckPathExists = true,
DefaultExt = "png",
Filter = "png files (*.png)|*.png",
FilterIndex = 2,
RestoreDirectory = true,
ReadOnlyChecked = true,
ShowReadOnly = true
};
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
byte[] NewImage = ImageResize(File.ReadAllBytes(openFileDialog1.FileName), ImagePreview.Width, ImagePreview.Height);
string[] selected = Locations.GetItemText(Locations.SelectedItem).Split(')');
if (ModdedSerializedImageData.ContainsKey(selected[0] + ")"))
{
try
{
ModdedSerializedImageData[selected[0] + ")"][int.Parse(Framenumber.Text)] = NewImage;
ImagePreview.Image = ByteToImage(ModdedSerializedImageData[selected[0] + ")"][int.Parse(Framenumber.Text)]);
}
catch
{
while(ModdedSerializedImageData[selected[0] + ")"].Count < SupportedFrames+1)
{
ModdedSerializedImageData[selected[0] + ")"].Add(Convert.FromBase64String(Blanked));
}
try
{
ModdedSerializedImageData[selected[0] + ")"][int.Parse(Framenumber.Text)] = NewImage;
ImagePreview.Image = ByteToImage(ModdedSerializedImageData[selected[0] + ")"][int.Parse(Framenumber.Text)]);
}
catch { }
}
}
}
}
public static string XMLData;
public static string XMLDataSkin;
public static string XMLDataPlugins;
public static bool SaveProcessing = false;
private void SaveMap_Click(object sender, EventArgs e)
{
//Thread this stuff as showing save file dialog
SaveProcessing = false;
new Thread(() =>
{
SaveProcessing = true;
Thread.CurrentThread.IsBackground = true;
XMLData = XMLEncode();
XMLDataSkin = XMLEncodeSkin();
XMLDataPlugins = XMLEncodePlugin();
SaveProcessing = false;
}).Start();
SaveFileDialog saveFileDialog1 = new SaveFileDialog
{
Title = "Save Edited Map",
DefaultExt = ".map",
Filter = "map file (*.map)|*.map|All files (*.*)|*.*",
FilterIndex = 1,
RestoreDirectory = true,
};
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
//Check if mapdata already has image data
MapData sd = worldSerialization.GetMap(Base64Encode("SerializedImageData"));
MapData ssd = worldSerialization.GetMap(Base64Encode("SerializedSkinData"));
MapData spd = worldSerialization.GetMap(Base64Encode("SerializedPluginData"));
while(SaveProcessing)
{
Thread.Sleep(1000);
}
if (sd == null)
{
worldSerialization.AddMap(Base64Encode("SerializedImageData"),Encoding.UTF8.GetBytes(XMLData));
}
else
{
sd.data = Encoding.UTF8.GetBytes(XMLData);
}
if (ssd == null)
{
worldSerialization.AddMap(Base64Encode("SerializedSkinData"), Encoding.UTF8.GetBytes(XMLDataSkin));
}
else
{
ssd.data = Encoding.UTF8.GetBytes(XMLDataSkin);
}
if (spd == null)
{
worldSerialization.AddMap(Base64Encode("SerializedPluginData"), Encoding.UTF8.GetBytes(XMLDataPlugins));
}
else
{
spd.data = Encoding.UTF8.GetBytes(XMLDataPlugins);
}
if (File.Exists(saveFileDialog1.FileName))
{
File.Delete(saveFileDialog1.FileName);
}
using (FileStream fileStream = new FileStream(saveFileDialog1.FileName, FileMode.CreateNew, FileAccess.Write, FileShare.None))
{
using (BinaryWriter binaryWriter = new BinaryWriter(fileStream))
{
binaryWriter.Write(Version);
using (LZ4Stream stream = new LZ4Stream(fileStream, LZ4StreamMode.Compress))
{
WorldData.Serialize(stream, worldSerialization.world);
}
}
}
MessageBox.Show("Saved file","Saved");
}
}
private void RemoveImage_Click(object sender, EventArgs e)
{
string[] selected = Locations.GetItemText(Locations.SelectedItem).Split(')');
ModdedSerializedImageData[selected[0] + ")"][int.Parse(Framenumber.Text)] = new byte[0];
ImagePreview.Image = null;
}
private static void NumbersOnly_KeyPress(object sender, KeyPressEventArgs e)
{
if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar))
{
e.Handled = true;
}
}
private static DialogResult ShowInputDialog(ref string input)
{
System.Drawing.Size size = new System.Drawing.Size(200, 70);
Form inputBox = new Form();
inputBox.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
inputBox.ClientSize = size;
inputBox.Text = "Skin ID";
System.Windows.Forms.TextBox textBox = new TextBox();
textBox.Size = new System.Drawing.Size(size.Width - 10, 23);
textBox.Location = new System.Drawing.Point(5, 5);
textBox.Text = input;
textBox.KeyPress += new System.Windows.Forms.KeyPressEventHandler(NumbersOnly_KeyPress);
inputBox.Controls.Add(textBox);
Button okButton = new Button();
okButton.DialogResult = System.Windows.Forms.DialogResult.OK;
okButton.Name = "okButton";
okButton.Size = new System.Drawing.Size(75, 23);
okButton.Text = "&OK";
okButton.Location = new System.Drawing.Point(size.Width - 80 - 80, 39);
inputBox.Controls.Add(okButton);
Button cancelButton = new Button();
cancelButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
cancelButton.Name = "cancelButton";
cancelButton.Size = new System.Drawing.Size(75, 23);
cancelButton.Text = "&Cancel";
cancelButton.Location = new System.Drawing.Point(size.Width - 80, 39);
inputBox.Controls.Add(cancelButton);
inputBox.AcceptButton = okButton;
inputBox.CancelButton = cancelButton;
DialogResult result = inputBox.ShowDialog();
input = textBox.Text;
return result;
}
private void AddSkin_Click(object sender, EventArgs e)
{
string input = "0";
uint skinid = 0;
string[] selected = SkinLocations.GetItemText(SkinLocations.SelectedItem).Split(')');
if (ModdedSerializedSkinData.ContainsKey(selected[0] + ")"))
{
input = ModdedSerializedSkinData[selected[0] + ")"].ToString();
if(ShowInputDialog(ref input) == DialogResult.Cancel)
{
return;
}
try
{
skinid = uint.Parse(input);
}
catch { }
if (skinid != 0)
{
ModdedSerializedSkinData[selected[0] + ")"] = skinid;
ImagePreview.Image = GetThumbNail(skinid);
}
}
}
private void RemoveSkin_Click(object sender, EventArgs e)
{
string[] selected = SkinLocations.GetItemText(SkinLocations.SelectedItem).Split(')');
ModdedSerializedSkinData[selected[0] + ")"] = 0;
ImagePreview.Image = null;
}
private void Export_Click(object sender, EventArgs e)
{
SaveFileDialog saveFileDialog1 = new SaveFileDialog();
saveFileDialog1.Title = "Export Settings File";
saveFileDialog1.DefaultExt = "st";
saveFileDialog1.Filter = "SignTool (*.st)|*.st|All files (*.*)|*.*";
saveFileDialog1.FilterIndex = 1;
saveFileDialog1.RestoreDirectory = true;
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
string XMLData = XMLEncode() + XMLEncodeSkin();
File.WriteAllBytes(saveFileDialog1.FileName, Zip(XMLData));
MessageBox.Show("Saved Settings","Save");
}
}
private void Import_Click(object sender, EventArgs e)
{
OpenFileDialog openFileDialog1 = new OpenFileDialog
{
Title = "Import Settings File",
CheckFileExists = true,
CheckPathExists = true,
DefaultExt = "st",
Filter = "SignTool (*.st)|*.st|All files (*.*)|*.*",
FilterIndex = 1,
RestoreDirectory = true,
ReadOnlyChecked = true,
ShowReadOnly = true
};
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
string Settings = Unzip(File.ReadAllBytes(openFileDialog1.FileName));
string[] S = Settings.Split(new string[] { "</SerializedImageData>" }, StringSplitOptions.None);
MessageBox.Show("Missing " + LoadSettings(S[0], true).ToString() + " Painted signs");
MessageBox.Show("Missing " + LoadSettings(S[1], false).ToString() + " Skined items");
Selection(null, null);
}
}
private int LoadSettings(string settings, bool sign = true)
{
int missing = 0;
if (sign)
{
Dictionary<string, List<byte[]>> ImportedSigns = new Dictionary<string, List<byte[]>>();
string[] DataParse = settings.Split(new string[] { "<position>" }, StringSplitOptions.None);
foreach (string xmldata in DataParse)
{
if (xmldata.Contains("xml version")) continue;
string x = xmldata.Split(new string[] { "</x><y>" }, StringSplitOptions.None)[0].Replace("<x>", "");
string y = xmldata.Split(new string[] { "</y><z>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>", "");
string z = xmldata.Split(new string[] { "</z></position>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>" + y + "</y><z>", "");
string texture = xmldata.Split(new string[] { "<texture>" }, StringSplitOptions.None)[1].Replace("</texture>", "").Replace("</SerializedImageData>", "");
if (texture.Length < 50)
{
continue;
}
string[] imageFrames = texture.Split(new string[] { "<frame>" }, StringSplitOptions.None);
List<byte[]> ImageData = new List<byte[]>();
foreach (string imageframe in imageFrames)
{
if (imageframe != "")
ImageData.Add(Convert.FromBase64String(imageframe.Replace("<frame>", "")));
}
try
{
ImportedSigns.Add("(" + x + ", " + y + ", " + z + ")", ImageData);
}
catch { }
}
if (ImportedSigns.Count != 0)
{
foreach (KeyValuePair<string, List<byte[]>> importsign in ImportedSigns)
{
if (ModdedSerializedImageData.ContainsKey(importsign.Key))
{
ModdedSerializedImageData[importsign.Key] = importsign.Value;
}
else
{
missing++;
}
}
}
}
else
{
Dictionary<string, uint> ImportedSkins = new Dictionary<string, uint>();
string[] DataParse = settings.Split(new string[] { "<position>" }, StringSplitOptions.None);
foreach (string xmldata in DataParse)
{
if (xmldata.Contains("xml version")) continue;
string x = xmldata.Split(new string[] { "</x><y>" }, StringSplitOptions.None)[0].Replace("<x>", "");
string y = xmldata.Split(new string[] { "</y><z>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>", "");
string z = xmldata.Split(new string[] { "</z></position>" }, StringSplitOptions.None)[0].Replace("<x>" + x + "</x><y>" + y + "</y><z>", "");
string skin = xmldata.Split(new string[] { "<skin>" }, StringSplitOptions.None)[1].Replace("</skin>", "").Replace("</SerializedSkinData>", "");
ImportedSkins.Add("(" + x + ", " + y + ", " + z + ")", uint.Parse(skin));
}
if (ImportedSkins.Count != 0)
{
foreach (KeyValuePair<string, uint> importskin in ImportedSkins)
{
if (ModdedSerializedSkinData.ContainsKey(importskin.Key))
{
ModdedSerializedSkinData[importskin.Key] = importskin.Value;
}
else
{
missing++;
}
}
}
}
return missing;
}
private void Framenumber_TextChanged(object sender, EventArgs e)
{
int box_int = 0; Int32.TryParse(Framenumber.Text, out box_int);
if (box_int > SupportedFrames && Framenumber.Text != "") { Framenumber.Text = SupportedFrames.ToString(); }
else if (box_int < 0 && Framenumber.Text != "") { Framenumber.Text = "0"; }
string[] selected = Locations.GetItemText(Locations.SelectedItem).Split(')');
if (ModdedSerializedImageData.ContainsKey(selected[0] + ")"))
{
if (ModdedSerializedImageData[selected[0] + ")"].Count != 0)
{
try
{
ImagePreview.Image = ByteToImage(ModdedSerializedImageData[selected[0] + ")"][int.Parse(Framenumber.Text)]);
}
catch
{
ImagePreview.Image = ByteToImage(Convert.FromBase64String(Blanked));
}
}
else
{
ImagePreview.Image = null;
}
}
}
private void FrameUp_Click(object sender, EventArgs e)
{
Framenumber.Text = (int.Parse(Framenumber.Text) + 1).ToString();
}
private void Framedown_Click(object sender, EventArgs e)
{
Framenumber.Text = (int.Parse(Framenumber.Text) - 1).ToString();
}
private void Plugins_Click(object sender, EventArgs e)
{
Plugins plugins = new SignToolsGUI.Plugins();
plugins.StartPosition = FormStartPosition.CenterScreen;
plugins.ShowDialog();
}
private void scaleup_Click(object sender, EventArgs e)
{
scaletxt.Text = (double.Parse(scaletxt.Text) + .25).ToString();
}
private void scaledown_Click(object sender, EventArgs e)
{
scaletxt.Text = (double.Parse(scaletxt.Text) - .25).ToString();
if(scaletxt.Text == "0.")
{
scaletxt.Text = "0.25";
}
}
private void GUI_Load(object sender, EventArgs e)
{
}
}
}