1053 lines
44 KiB
C#
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)
|
|
{
|
|
|
|
}
|
|
}
|
|
}
|