immortaly007/badeend-go
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[TASK] Show collected duck stickers

Browse Source
This commit is contained in:
Bas Dado
2019-08-24 00:31:21 +02:00
parent 279c5fbbbe
commit c8ab81a848
43 changed files with 4969 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Assets/PlayerPrefsEditor/Editor/Mac.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 1b15603e344fd7447ad6eede3ff52c67
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

966
Assets/PlayerPrefsEditor/Editor/Mac/Plist.cs Normal file
View File

@@ -0,0 +1,966 @@
//
// PlistCS Property List (plist) serialization and parsing library.
//
// https://github.com/animetrics/PlistCS
//
// Copyright (c) 2011 Animetrics Inc. (marc@animetrics.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
// Sabresaurus Note: parseBinaryReal has been modified from its state, please see the method's code for details
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml;
namespace Sabresaurus.PlayerPrefsExtensions
{
public static class Plist
{
private static List<int> offsetTable = new List<int>();
private static List<byte> objectTable = new List<byte>();
private static int refCount;
private static int objRefSize;
private static int offsetByteSize;
private static long offsetTableOffset;
#region Public Functions
public static object readPlist(string path)
{
using (FileStream f = new FileStream(path, FileMode.Open, FileAccess.Read))
{
return readPlist(f, plistType.Auto);
}
}
public static object readPlistSource(string source)
{
return readPlist(System.Text.Encoding.UTF8.GetBytes(source));
}
public static object readPlist(byte[] data)
{
return readPlist(new MemoryStream(data), plistType.Auto);
}
public static plistType getPlistType(Stream stream)
{
byte[] magicHeader = new byte[8];
stream.Read(magicHeader, 0, 8);
if (BitConverter.ToInt64(magicHeader, 0) == 3472403351741427810)
{
return plistType.Binary;
}
else
{
return plistType.Xml;
}
}
public static object readPlist(Stream stream, plistType type)
{
if (type == plistType.Auto)
{
type = getPlistType(stream);
stream.Seek(0, SeekOrigin.Begin);
}
if (type == plistType.Binary)
{
using (BinaryReader reader = new BinaryReader(stream))
{
byte[] data = reader.ReadBytes((int) reader.BaseStream.Length);
return readBinary(data);
}
}
else
{
XmlDocument xml = new XmlDocument();
xml.XmlResolver = null;
xml.Load(stream);
return readXml(xml);
}
}
public static void writeXml(object value, string path)
{
using (StreamWriter writer = new StreamWriter(path))
{
writer.Write(writeXml(value));
}
}
public static void writeXml(object value, Stream stream)
{
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write(writeXml(value));
}
}
public static string writeXml(object value)
{
using (MemoryStream ms = new MemoryStream())
{
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Encoding = new System.Text.UTF8Encoding(false);
xmlWriterSettings.ConformanceLevel = ConformanceLevel.Document;
xmlWriterSettings.Indent = true;
using (XmlWriter xmlWriter = XmlWriter.Create(ms, xmlWriterSettings))
{
xmlWriter.WriteStartDocument();
//xmlWriter.WriteComment("DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" " + "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\"");
xmlWriter.WriteDocType("plist", "-//Apple Computer//DTD PLIST 1.0//EN", "http://www.apple.com/DTDs/PropertyList-1.0.dtd", null);
xmlWriter.WriteStartElement("plist");
xmlWriter.WriteAttributeString("version", "1.0");
compose(value, xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
xmlWriter.Close();
return System.Text.Encoding.UTF8.GetString(ms.ToArray());
}
}
}
public static void writeBinary(object value, string path)
{
using (BinaryWriter writer = new BinaryWriter(new FileStream(path, FileMode.Create)))
{
writer.Write(writeBinary(value));
}
}
public static void writeBinary(object value, Stream stream)
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
writer.Write(writeBinary(value));
}
}
public static byte[] writeBinary(object value)
{
offsetTable.Clear();
objectTable.Clear();
refCount = 0;
objRefSize = 0;
offsetByteSize = 0;
offsetTableOffset = 0;
//Do not count the root node, subtract by 1
int totalRefs = countObject(value) - 1;
refCount = totalRefs;
objRefSize = RegulateNullBytes(BitConverter.GetBytes(refCount)).Length;
composeBinary(value);
writeBinaryString("bplist00", false);
offsetTableOffset = (long)objectTable.Count;
offsetTable.Add(objectTable.Count - 8);
offsetByteSize = RegulateNullBytes(BitConverter.GetBytes(offsetTable[offsetTable.Count-1])).Length;
List<byte> offsetBytes = new List<byte>();
offsetTable.Reverse();
for (int i = 0; i < offsetTable.Count; i++)
{
offsetTable[i] = objectTable.Count - offsetTable[i];
byte[] buffer = RegulateNullBytes(BitConverter.GetBytes(offsetTable[i]), offsetByteSize);
Array.Reverse(buffer);
offsetBytes.AddRange(buffer);
}
objectTable.AddRange(offsetBytes);
objectTable.AddRange(new byte[6]);
objectTable.Add(Convert.ToByte(offsetByteSize));
objectTable.Add(Convert.ToByte(objRefSize));
var a = BitConverter.GetBytes((long) totalRefs + 1);
Array.Reverse(a);
objectTable.AddRange(a);
objectTable.AddRange(BitConverter.GetBytes((long)0));
a = BitConverter.GetBytes(offsetTableOffset);
Array.Reverse(a);
objectTable.AddRange(a);
return objectTable.ToArray();
}
#endregion
#region Private Functions
private static object readXml(XmlDocument xml)
{
XmlNode rootNode = xml.DocumentElement.ChildNodes[0];
return parse(rootNode);
}
private static object readBinary(byte[] data)
{
offsetTable.Clear();
List<byte> offsetTableBytes = new List<byte>();
objectTable.Clear();
refCount = 0;
objRefSize = 0;
offsetByteSize = 0;
offsetTableOffset = 0;
List<byte> bList = new List<byte>(data);
List<byte> trailer = bList.GetRange(bList.Count - 32, 32);
parseTrailer(trailer);
objectTable = bList.GetRange(0, (int)offsetTableOffset);
offsetTableBytes = bList.GetRange((int)offsetTableOffset, bList.Count - (int)offsetTableOffset - 32);
parseOffsetTable(offsetTableBytes);
return parseBinary(0);
}
private static Dictionary<string, object> parseDictionary(XmlNode node)
{
XmlNodeList children = node.ChildNodes;
if (children.Count % 2 != 0)
{
throw new DataMisalignedException("Dictionary elements must have an even number of child nodes");
}
Dictionary<string, object> dict = new Dictionary<string, object>();
for (int i = 0; i < children.Count; i += 2)
{
XmlNode keynode = children[i];
XmlNode valnode = children[i + 1];
if (keynode.Name != "key")
{
throw new ApplicationException("expected a key node");
}
object result = parse(valnode);
if (result != null)
{
dict.Add(keynode.InnerText, result);
}
}
return dict;
}
private static List<object> parseArray(XmlNode node)
{
List<object> array = new List<object>();
foreach (XmlNode child in node.ChildNodes)
{
object result = parse(child);
if (result != null)
{
array.Add(result);
}
}
return array;
}
private static void composeArray(List<object> value, XmlWriter writer)
{
writer.WriteStartElement("array");
foreach (object obj in value)
{
compose(obj, writer);
}
writer.WriteEndElement();
}
private static object parse(XmlNode node)
{
switch (node.Name)
{
case "dict":
return parseDictionary(node);
case "array":
return parseArray(node);
case "string":
return node.InnerText;
case "integer":
// int result;
//int.TryParse(node.InnerText, System.Globalization.NumberFormatInfo.InvariantInfo, out result);
return Convert.ToInt32(node.InnerText, System.Globalization.NumberFormatInfo.InvariantInfo);
case "real":
return Convert.ToDouble(node.InnerText,System.Globalization.NumberFormatInfo.InvariantInfo);
case "false":
return false;
case "true":
return true;
case "null":
return null;
case "date":
return XmlConvert.ToDateTime(node.InnerText, XmlDateTimeSerializationMode.Utc);
case "data":
return Convert.FromBase64String(node.InnerText);
}
throw new ApplicationException(String.Format("Plist Node `{0}' is not supported", node.Name));
}
private static void compose(object value, XmlWriter writer)
{
if (value == null || value is string)
{
writer.WriteElementString("string", value as string);
}
else if (value is int || value is long)
{
writer.WriteElementString("integer", ((int)value).ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
else if (value is System.Collections.Generic.Dictionary<string, object> ||
value.GetType().ToString().StartsWith("System.Collections.Generic.Dictionary`2[System.String"))
{
//Convert to Dictionary<string, object>
Dictionary<string, object> dic = value as Dictionary<string, object>;
if (dic == null)
{
dic = new Dictionary<string, object>();
IDictionary idic = (IDictionary)value;
foreach (var key in idic.Keys)
{
dic.Add(key.ToString(), idic[key]);
}
}
writeDictionaryValues(dic, writer);
}
else if (value is List<object>)
{
composeArray((List<object>)value, writer);
}
else if (value is byte[])
{
writer.WriteElementString("data", Convert.ToBase64String((Byte[])value));
}
else if (value is float || value is double)
{
writer.WriteElementString("real", ((double)value).ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
else if (value is DateTime)
{
DateTime time = (DateTime)value;
string theString = XmlConvert.ToString(time, XmlDateTimeSerializationMode.Utc);
writer.WriteElementString("date", theString);//, "yyyy-MM-ddTHH:mm:ssZ"));
}
else if (value is bool)
{
writer.WriteElementString(value.ToString().ToLower(), "");
}
else
{
throw new Exception(String.Format("Value type '{0}' is unhandled", value.GetType().ToString()));
}
}
private static void writeDictionaryValues(Dictionary<string, object> dictionary, XmlWriter writer)
{
writer.WriteStartElement("dict");
foreach (string key in dictionary.Keys)
{
object value = dictionary[key];
writer.WriteElementString("key", key);
compose(value, writer);
}
writer.WriteEndElement();
}
private static int countObject(object value)
{
int count = 0;
switch (value.GetType().ToString())
{
case "System.Collections.Generic.Dictionary`2[System.String,System.Object]":
Dictionary<string, object> dict = (Dictionary<string, object>)value;
foreach (string key in dict.Keys)
{
count += countObject(dict[key]);
}
count += dict.Keys.Count;
count++;
break;
case "System.Collections.Generic.List`1[System.Object]":
List<object> list = (List<object>)value;
foreach (object obj in list)
{
count += countObject(obj);
}
count++;
break;
default:
count++;
break;
}
return count;
}
private static byte[] writeBinaryDictionary(Dictionary<string, object> dictionary)
{
List<byte> buffer = new List<byte>();
List<byte> header = new List<byte>();
List<int> refs = new List<int>();
for (int i = dictionary.Count - 1; i >= 0; i--)
{
var o = new object[dictionary.Count];
dictionary.Values.CopyTo(o, 0);
composeBinary(o[i]);
offsetTable.Add(objectTable.Count);
refs.Add(refCount);
refCount--;
}
for (int i = dictionary.Count - 1; i >= 0; i--)
{
var o = new string[dictionary.Count];
dictionary.Keys.CopyTo(o, 0);
composeBinary(o[i]);//);
offsetTable.Add(objectTable.Count);
refs.Add(refCount);
refCount--;
}
if (dictionary.Count < 15)
{
header.Add(Convert.ToByte(0xD0 | Convert.ToByte(dictionary.Count)));
}
else
{
header.Add(0xD0 | 0xf);
header.AddRange(writeBinaryInteger(dictionary.Count, false));
}
foreach (int val in refs)
{
byte[] refBuffer = RegulateNullBytes(BitConverter.GetBytes(val), objRefSize);
Array.Reverse(refBuffer);
buffer.InsertRange(0, refBuffer);
}
buffer.InsertRange(0, header);
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
private static byte[] composeBinaryArray(List<object> objects)
{
List<byte> buffer = new List<byte>();
List<byte> header = new List<byte>();
List<int> refs = new List<int>();
for (int i = objects.Count - 1; i >= 0; i--)
{
composeBinary(objects[i]);
offsetTable.Add(objectTable.Count);
refs.Add(refCount);
refCount--;
}
if (objects.Count < 15)
{
header.Add(Convert.ToByte(0xA0 | Convert.ToByte(objects.Count)));
}
else
{
header.Add(0xA0 | 0xf);
header.AddRange(writeBinaryInteger(objects.Count, false));
}
foreach (int val in refs)
{
byte[] refBuffer = RegulateNullBytes(BitConverter.GetBytes(val), objRefSize);
Array.Reverse(refBuffer);
buffer.InsertRange(0, refBuffer);
}
buffer.InsertRange(0, header);
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
private static byte[] composeBinary(object obj)
{
byte[] value;
switch (obj.GetType().ToString())
{
case "System.Collections.Generic.Dictionary`2[System.String,System.Object]":
value = writeBinaryDictionary((Dictionary<string, object>)obj);
return value;
case "System.Collections.Generic.List`1[System.Object]":
value = composeBinaryArray((List<object>)obj);
return value;
case "System.Byte[]":
value = writeBinaryByteArray((byte[])obj);
return value;
case "System.Double":
value = writeBinaryDouble((double)obj);
return value;
case "System.Int32":
value = writeBinaryInteger((int)obj, true);
return value;
case "System.String":
value = writeBinaryString((string)obj, true);
return value;
case "System.DateTime":
value = writeBinaryDate((DateTime)obj);
return value;
case "System.Boolean":
value = writeBinaryBool((bool)obj);
return value;
default:
return new byte[0];
}
}
public static byte[] writeBinaryDate(DateTime obj)
{
List<byte> buffer =new List<byte>(RegulateNullBytes(BitConverter.GetBytes(PlistDateConverter.ConvertToAppleTimeStamp(obj)), 8));
buffer.Reverse();
buffer.Insert(0, 0x33);
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
public static byte[] writeBinaryBool(bool obj)
{
List<byte> buffer = new List<byte>(new byte[1] { (bool)obj ? (byte)9 : (byte)8 });
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
private static byte[] writeBinaryInteger(int value, bool write)
{
List<byte> buffer = new List<byte>(BitConverter.GetBytes((long) value));
buffer =new List<byte>(RegulateNullBytes(buffer.ToArray()));
while (buffer.Count != Math.Pow(2, Math.Log(buffer.Count) / Math.Log(2)))
buffer.Add(0);
int header = 0x10 | (int)(Math.Log(buffer.Count) / Math.Log(2));
buffer.Reverse();
buffer.Insert(0, Convert.ToByte(header));
if (write)
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
private static byte[] writeBinaryDouble(double value)
{
List<byte> buffer =new List<byte>(RegulateNullBytes(BitConverter.GetBytes(value), 4));
while (buffer.Count != Math.Pow(2, Math.Log(buffer.Count) / Math.Log(2)))
buffer.Add(0);
int header = 0x20 | (int)(Math.Log(buffer.Count) / Math.Log(2));
buffer.Reverse();
buffer.Insert(0, Convert.ToByte(header));
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
private static byte[] writeBinaryByteArray(byte[] value)
{
List<byte> buffer = new List<byte>(value);
List<byte> header = new List<byte>();
if (value.Length < 15)
{
header.Add(Convert.ToByte(0x40 | Convert.ToByte(value.Length)));
}
else
{
header.Add(0x40 | 0xf);
header.AddRange(writeBinaryInteger(buffer.Count, false));
}
buffer.InsertRange(0, header);
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
private static byte[] writeBinaryString(string value, bool head)
{
List<byte> buffer = new List<byte>();
List<byte> header = new List<byte>();
foreach (char chr in value.ToCharArray())
buffer.Add(Convert.ToByte(chr));
if (head)
{
if (value.Length < 15)
{
header.Add(Convert.ToByte(0x50 | Convert.ToByte(value.Length)));
}
else
{
header.Add(0x50 | 0xf);
header.AddRange(writeBinaryInteger(buffer.Count, false));
}
}
buffer.InsertRange(0, header);
objectTable.InsertRange(0, buffer);
return buffer.ToArray();
}
private static byte[] RegulateNullBytes(byte[] value)
{
return RegulateNullBytes(value, 1);
}
private static byte[] RegulateNullBytes(byte[] value, int minBytes)
{
Array.Reverse(value);
List<byte> bytes = new List<byte>(value);
for (int i = 0; i < bytes.Count; i++)
{
if (bytes[i] == 0 && bytes.Count > minBytes)
{
bytes.Remove(bytes[i]);
i--;
}
else
break;
}
if (bytes.Count < minBytes)
{
int dist = minBytes - bytes.Count;
for (int i = 0; i < dist; i++)
bytes.Insert(0, 0);
}
value = bytes.ToArray();
Array.Reverse(value);
return value;
}
private static void parseTrailer(List<byte> trailer)
{
offsetByteSize = BitConverter.ToInt32(RegulateNullBytes(trailer.GetRange(6, 1).ToArray(), 4), 0);
objRefSize = BitConverter.ToInt32(RegulateNullBytes(trailer.GetRange(7, 1).ToArray(), 4), 0);
byte[] refCountBytes = trailer.GetRange(12, 4).ToArray();
Array.Reverse(refCountBytes);
refCount = BitConverter.ToInt32(refCountBytes, 0);
byte[] offsetTableOffsetBytes = trailer.GetRange(24, 8).ToArray();
Array.Reverse(offsetTableOffsetBytes);
offsetTableOffset = BitConverter.ToInt64(offsetTableOffsetBytes, 0);
}
private static void parseOffsetTable(List<byte> offsetTableBytes)
{
for (int i = 0; i < offsetTableBytes.Count; i += offsetByteSize)
{
byte[] buffer = offsetTableBytes.GetRange(i, offsetByteSize).ToArray();
Array.Reverse(buffer);
offsetTable.Add(BitConverter.ToInt32(RegulateNullBytes(buffer, 4), 0));
}
}
private static object parseBinaryDictionary(int objRef)
{
Dictionary<string, object> buffer = new Dictionary<string, object>();
List<int> refs = new List<int>();
int refCount = 0;
int refStartPosition;
refCount = getCount(offsetTable[objRef], out refStartPosition);
if (refCount < 15)
refStartPosition = offsetTable[objRef] + 1;
else
refStartPosition = offsetTable[objRef] + 2 + RegulateNullBytes(BitConverter.GetBytes(refCount), 1).Length;
for (int i = refStartPosition; i < refStartPosition + refCount * 2 * objRefSize; i += objRefSize)
{
byte[] refBuffer = objectTable.GetRange(i, objRefSize).ToArray();
Array.Reverse(refBuffer);
refs.Add(BitConverter.ToInt32(RegulateNullBytes(refBuffer, 4), 0));
}
for (int i = 0; i < refCount; i++)
{
buffer.Add((string)parseBinary(refs[i]), parseBinary(refs[i + refCount]));
}
return buffer;
}
private static object parseBinaryArray(int objRef)
{
List<object> buffer = new List<object>();
List<int> refs = new List<int>();
int refCount = 0;
int refStartPosition;
refCount = getCount(offsetTable[objRef], out refStartPosition);
if (refCount < 15)
refStartPosition = offsetTable[objRef] + 1;
else
//The following integer has a header aswell so we increase the refStartPosition by two to account for that.
refStartPosition = offsetTable[objRef] + 2 + RegulateNullBytes(BitConverter.GetBytes(refCount), 1).Length;
for (int i = refStartPosition; i < refStartPosition + refCount * objRefSize; i += objRefSize)
{
byte[] refBuffer = objectTable.GetRange(i, objRefSize).ToArray();
Array.Reverse(refBuffer);
refs.Add(BitConverter.ToInt32(RegulateNullBytes(refBuffer, 4), 0));
}
for (int i = 0; i < refCount; i++)
{
buffer.Add(parseBinary(refs[i]));
}
return buffer;
}
private static int getCount(int bytePosition, out int newBytePosition)
{
byte headerByte = objectTable[bytePosition];
byte headerByteTrail = Convert.ToByte(headerByte & 0xf);
int count;
if (headerByteTrail < 15)
{
count = headerByteTrail;
newBytePosition = bytePosition + 1;
}
else
count = (int)parseBinaryInt(bytePosition + 1, out newBytePosition);
return count;
}
private static object parseBinary(int objRef)
{
byte header = objectTable[offsetTable[objRef]];
switch (header & 0xF0)
{
case 0:
{
//If the byte is
//0 return null
//9 return true
//8 return false
return (objectTable[offsetTable[objRef]] == 0) ? (object)null : ((objectTable[offsetTable[objRef]] == 9) ? true : false);
}
case 0x10:
{
return parseBinaryInt(offsetTable[objRef]);
}
case 0x20:
{
return parseBinaryReal(offsetTable[objRef]);
}
case 0x30:
{
return parseBinaryDate(offsetTable[objRef]);
}
case 0x40:
{
return parseBinaryByteArray(offsetTable[objRef]);
}
case 0x50://String ASCII
{
return parseBinaryAsciiString(offsetTable[objRef]);
}
case 0x60://String Unicode
{
return parseBinaryUnicodeString(offsetTable[objRef]);
}
case 0xD0:
{
return parseBinaryDictionary(objRef);
}
case 0xA0:
{
return parseBinaryArray(objRef);
}
}
throw new Exception("This type is not supported");
}
public static object parseBinaryDate(int headerPosition)
{
byte[] buffer = objectTable.GetRange(headerPosition + 1, 8).ToArray();
Array.Reverse(buffer);
double appleTime = BitConverter.ToDouble(buffer, 0);
DateTime result = PlistDateConverter.ConvertFromAppleTimeStamp(appleTime);
return result;
}
private static object parseBinaryInt(int headerPosition)
{
int output;
return parseBinaryInt(headerPosition, out output);
}
private static object parseBinaryInt(int headerPosition, out int newHeaderPosition)
{
byte header = objectTable[headerPosition];
int byteCount = (int)Math.Pow(2, header & 0xf);
byte[] buffer = objectTable.GetRange(headerPosition + 1, byteCount).ToArray();
Array.Reverse(buffer);
//Add one to account for the header byte
newHeaderPosition = headerPosition + byteCount + 1;
return BitConverter.ToInt32(RegulateNullBytes(buffer, 4), 0);
}
private static object parseBinaryReal(int headerPosition)
{
byte header = objectTable[headerPosition];
int byteCount = (int)Math.Pow(2, header & 0xf);
byte[] buffer = objectTable.GetRange(headerPosition + 1, byteCount).ToArray();
Array.Reverse(buffer);
// Sabresaurus Note: This wasn't producing the right results with doubles, needed singles anyway, so I
// added this line. (original line is commented out)
return BitConverter.ToSingle(buffer, 0);
// return BitConverter.ToDouble(RegulateNullBytes(buffer, 8), 0);
}
private static object parseBinaryAsciiString(int headerPosition)
{
int charStartPosition;
int charCount = getCount(headerPosition, out charStartPosition);
var buffer = objectTable.GetRange(charStartPosition, charCount);
return buffer.Count > 0 ? Encoding.ASCII.GetString(buffer.ToArray()) : string.Empty;
}
private static object parseBinaryUnicodeString(int headerPosition)
{
int charStartPosition;
int charCount = getCount(headerPosition, out charStartPosition);
charCount = charCount * 2;
byte[] buffer = new byte[charCount];
byte one, two;
for (int i = 0; i < charCount; i+=2)
{
one = objectTable.GetRange(charStartPosition+i,1)[0];
two = objectTable.GetRange(charStartPosition + i+1, 1)[0];
if (BitConverter.IsLittleEndian)
{
buffer[i] = two;
buffer[i + 1] = one;
}
else
{
buffer[i] = one;
buffer[i + 1] = two;
}
}
return Encoding.Unicode.GetString(buffer);
}
private static object parseBinaryByteArray(int headerPosition)
{
int byteStartPosition;
int byteCount = getCount(headerPosition, out byteStartPosition);
return objectTable.GetRange(byteStartPosition, byteCount).ToArray();
}
#endregion
}
public enum plistType
{
Auto, Binary, Xml
}
public static class PlistDateConverter
{
public static long timeDifference = 978307200;
public static long GetAppleTime(long unixTime)
{
return unixTime - timeDifference;
}
public static long GetUnixTime(long appleTime)
{
return appleTime + timeDifference;
}
public static DateTime ConvertFromAppleTimeStamp(double timestamp)
{
DateTime origin = new DateTime(2001, 1, 1, 0, 0, 0, 0);
return origin.AddSeconds(timestamp);
}
public static double ConvertToAppleTimeStamp(DateTime date)
{
DateTime begin = new DateTime(2001, 1, 1, 0, 0, 0, 0);
TimeSpan diff = date - begin;
return Math.Floor(diff.TotalSeconds);
}
}
}

11
Assets/PlayerPrefsEditor/Editor/Mac/Plist.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 69fd4b81f600d46008cd7a0740a37348
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

955
Assets/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs Normal file
View File

@@ -0,0 +1,955 @@
using System;
using System.Collections.Generic;
using System.IO;
using UnityEditor;
using UnityEngine;
using Sabresaurus.PlayerPrefsExtensions;
public class PlayerPrefsEditor : EditorWindow
{
// Represents a PlayerPref key-value record
[Serializable]
private struct PlayerPrefPair
{
public string Key
{
get;
set;
}
public object Value
{
get;
set;
}
}
readonly DateTime MISSING_DATETIME = new DateTime(1601,1,1);
// Natively player prefs can be one of these three types
enum PlayerPrefType { Float = 0, Int, String };
// The actual cached store of player pref records fetched from registry or plist
List<PlayerPrefPair> deserializedPlayerPrefs = new List<PlayerPrefPair>();
// When a search is in effect the search results are cached in this list
List<PlayerPrefPair> filteredPlayerPrefs = new List<PlayerPrefPair>();
// Track last successful deserialisation to prevent doing this too often. On OSX this uses the player prefs file
// last modified time, on Windows we just poll repeatedly and use this to prevent polling again too soon.
DateTime? lastDeserialization = null;
// The view position of the player prefs scroll view
Vector2 scrollPosition;
// The scroll position from last frame (used with scrollPosition to detect user scrolling)
Vector2 lastScrollPosition;
// Prevent OnInspector() forcing a repaint every time it's called
int inspectorUpdateFrame = 0;
// Automatically attempt to decrypt keys and values that are detected as encrypted
bool automaticDecryption = false;
// Filter the keys by search
string searchFilter = string.Empty;
// Because of some issues with deleting from OnGUI, we defer it to OnInspectorUpdate() instead
string keyQueuedForDeletion = null;
// Company and product name for importing player prefs from other projects
string importCompanyName = "";
string importProductName = "";
#region Adding New PlayerPref
// This is the current type of player pref that the user is about to create
PlayerPrefType newEntryType = PlayerPrefType.String;
// Whether the player pref should be encrypted
bool newEntryIsEncrypted = false;
// The identifier of the new player pref
string newEntryKey = "";
// Value of the player pref about to be created (must be tracked differently for each type)
float newEntryValueFloat = 0;
int newEntryValueInt = 0;
string newEntryValueString = "";
#endregion
[MenuItem("Window/Player Prefs Editor")]
private static void Init()
{
// Get existing open window or if none, make a new one:
PlayerPrefsEditor editor = (PlayerPrefsEditor)EditorWindow.GetWindow(typeof(PlayerPrefsEditor));
// Require the editor window to be at least 300 pixels wide
Vector2 minSize = editor.minSize;
minSize.x = 230;
editor.minSize = minSize;
editor.importCompanyName = PlayerSettings.companyName;
editor.importProductName = PlayerSettings.productName;
}
/// <summary>
/// This returns an array of the stored PlayerPrefs from the file system (OSX) or registry (Windows), to allow
/// us to to look up what's actually in the PlayerPrefs. This is used as a kind of lookup table.
/// </summary>
private PlayerPrefPair[] RetrieveSavedPrefs(string companyName, string productName)
{
if(Application.platform == RuntimePlatform.OSXEditor)
{
// From Unity docs: On Mac OS X PlayerPrefs are stored in ~/Library/Preferences folder, in a file named unity.[company name].[product name].plist, where company and product names are the names set up in Project Settings. The same .plist file is used for both Projects run in the Editor and standalone players.
// Construct the plist filename from the project's settings
string plistFilename = string.Format("unity.{0}.{1}.plist", companyName, productName);
// Now construct the fully qualified path
string playerPrefsPath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Library/Preferences"), plistFilename);
// Parse the player prefs file if it exists
if(File.Exists(playerPrefsPath))
{
// Parse the plist then cast it to a Dictionary
object plist = Plist.readPlist(playerPrefsPath);
Dictionary<string, object> parsed = plist as Dictionary<string, object>;
// Convert the dictionary data into an array of PlayerPrefPairs
PlayerPrefPair[] tempPlayerPrefs = new PlayerPrefPair[parsed.Count];
int i = 0;
foreach (KeyValuePair<string, object> pair in parsed)
{
if(pair.Value.GetType () == typeof(double))
{
// Some float values may come back as double, so convert them back to floats
tempPlayerPrefs[i] = new PlayerPrefPair() { Key = pair.Key, Value = (float)(double)pair.Value };
}
else
{
tempPlayerPrefs[i] = new PlayerPrefPair() { Key = pair.Key, Value = pair.Value };
}
i++;
}
// Return the results
return tempPlayerPrefs;
}
else
{
// No existing player prefs saved (which is valid), so just return an empty array
return new PlayerPrefPair[0];
}
}
else if(Application.platform == RuntimePlatform.WindowsEditor)
{
// From Unity docs: On Windows, PlayerPrefs are stored in the registry under HKCU\Software\[company name]\[product name] key, where company and product names are the names set up in Project Settings.
#if UNITY_5_5_OR_NEWER
// From Unity 5.5 editor player prefs moved to a specific location
Microsoft.Win32.RegistryKey registryKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software\\Unity\\UnityEditor\\" + companyName + "\\" + productName);
#else
Microsoft.Win32.RegistryKey registryKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey("Software\\" + companyName + "\\" + productName);
#endif
// Parse the registry if the specified registryKey exists
if (registryKey != null)
{
// Get an array of what keys (registry value names) are stored
string[] valueNames = registryKey.GetValueNames();
// Create the array of the right size to take the saved player prefs
PlayerPrefPair[] tempPlayerPrefs = new PlayerPrefPair[valueNames.Length];
// Parse and convert the registry saved player prefs into our array
int i = 0;
foreach (string valueName in valueNames)
{
string key = valueName;
// Remove the _h193410979 style suffix used on player pref keys in Windows registry
int index = key.LastIndexOf("_");
key = key.Remove(index, key.Length - index);
// Get the value from the registry
object ambiguousValue = registryKey.GetValue(valueName);
// Unfortunately floats will come back as an int (at least on 64 bit) because the float is stored as
// 64 bit but marked as 32 bit - which confuses the GetValue() method greatly!
if (ambiguousValue.GetType() == typeof(int))
{
// If the player pref is not actually an int then it must be a float, this will evaluate to true
// (impossible for it to be 0 and -1 at the same time)
if (PlayerPrefs.GetInt(key, -1) == -1 && PlayerPrefs.GetInt(key, 0) == 0)
{
// Fetch the float value from PlayerPrefs in memory
ambiguousValue = PlayerPrefs.GetFloat(key);
}
}
else if(ambiguousValue.GetType() == typeof(byte[]))
{
// On Unity 5 a string may be stored as binary, so convert it back to a string
ambiguousValue = System.Text.Encoding.Default.GetString((byte[])ambiguousValue);
}
// Assign the key and value into the respective record in our output array
tempPlayerPrefs[i] = new PlayerPrefPair() { Key = key, Value = ambiguousValue };
i++;
}
// Return the results
return tempPlayerPrefs;
}
else
{
// No existing player prefs saved (which is valid), so just return an empty array
return new PlayerPrefPair[0];
}
}
else
{
throw new NotSupportedException("PlayerPrefsEditor doesn't support this Unity Editor platform");
}
}
private void UpdateSearch()
{
// Clear any existing cached search results
filteredPlayerPrefs.Clear();
// Don't attempt to find the search results if a search filter hasn't actually been supplied
if (string.IsNullOrEmpty(searchFilter))
{
return;
}
int entryCount = deserializedPlayerPrefs.Count;
// Iterate through all the cached results and add any matches to filteredPlayerPrefs
for (int i = 0; i < entryCount; i++)
{
string fullKey = deserializedPlayerPrefs[i].Key;
string displayKey = fullKey;
// Special case for encrypted keys in auto decrypt mode, search should use decrypted values
bool isEncryptedPair = PlayerPrefsUtility.IsEncryptedKey(deserializedPlayerPrefs[i].Key);
if (automaticDecryption && isEncryptedPair)
{
displayKey = PlayerPrefsUtility.DecryptKey(fullKey);
}
// If the key contains the search filter (ToLower used on both parts to make this case insensitive)
if (displayKey.ToLower().Contains(searchFilter.ToLower()))
{
filteredPlayerPrefs.Add(deserializedPlayerPrefs[i]);
}
}
}
private void DrawSearchBar()
{
EditorGUILayout.BeginHorizontal();
// Heading
GUILayout.Label("Search", GUILayout.MaxWidth(50));
// Actual search box
string newSearchFilter = EditorGUILayout.TextField(searchFilter);
// If the requested search filter has changed
if (newSearchFilter != searchFilter)
{
searchFilter = newSearchFilter;
// Trigger UpdateSearch to calculate new search results
UpdateSearch();
}
EditorGUILayout.EndHorizontal();
}
private void DrawMainList()
{
// The bold table headings
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Key", EditorStyles.boldLabel);
GUILayout.Label("Value", EditorStyles.boldLabel);
GUILayout.Label("Type", EditorStyles.boldLabel, GUILayout.Width(37));
GUILayout.Label("Del", EditorStyles.boldLabel, GUILayout.Width(25));
EditorGUILayout.EndHorizontal();
// Create a GUIStyle that can be manipulated for the various text fields
GUIStyle textFieldStyle = new GUIStyle (GUI.skin.textField);
// Could be dealing with either the full list or search results, so get the right list
List<PlayerPrefPair> activePlayerPrefs = deserializedPlayerPrefs;
if (!string.IsNullOrEmpty(searchFilter))
{
activePlayerPrefs = filteredPlayerPrefs;
}
// Cache the entry count
int entryCount = activePlayerPrefs.Count;
// Record the last scroll position so we can calculate if the user has scrolled this frame
lastScrollPosition = scrollPosition;
// Start the scrollable area
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
// Ensure the scroll doesn't go below zero
if(scrollPosition.y < 0)
{
scrollPosition.y = 0;
}
// The following code has been optimised so that rather than attempting to draw UI for every single PlayerPref
// it instead only draws the UI for those currently visible in the scroll view and pads above and below those
// results to maintain the right size using GUILayout.Space(). This enables us to work with thousands of
// PlayerPrefs without slowing the interface to a halt.
// Fixed height of one of the rows in the table
float rowHeight = 18;
// Determine how many rows are visible on screen. For simplicity, use Screen.height (the overhead is negligible)
int visibleCount = Mathf.CeilToInt(Screen.height / rowHeight);
// Determine the index of the first player pref that should be drawn as visible in the scrollable area
int firstShownIndex = Mathf.FloorToInt(scrollPosition.y / rowHeight);
// Determine the bottom limit of the visible player prefs (last shown index + 1)
int shownIndexLimit = firstShownIndex + visibleCount;
// If the actual number of player prefs is smaller than the caculated limit, reduce the limit to match
if (entryCount < shownIndexLimit)
{
shownIndexLimit = entryCount;
}
// If the number of displayed player prefs is smaller than the number we can display (like we're at the end
// of the list) then move the starting index back to adjust
if (shownIndexLimit - firstShownIndex < visibleCount)
{
firstShownIndex -= visibleCount - (shownIndexLimit - firstShownIndex);
}
// Can't have a negative index of a first shown player pref, so clamp to 0
if (firstShownIndex < 0)
{
firstShownIndex = 0;
}
// Pad above the on screen results so that we're not wasting draw calls on invisible UI and the drawn player
// prefs end up in the same place in the list
GUILayout.Space(firstShownIndex * rowHeight);
// For each of the on screen results
for (int i = firstShownIndex; i < shownIndexLimit; i++)
{
// Detect if it's an encrypted player pref (these have key prefixes)
bool isEncryptedPair = PlayerPrefsUtility.IsEncryptedKey(activePlayerPrefs[i].Key);
// Colour code encrypted player prefs blue
if (isEncryptedPair)
{
if(UsingProSkin)
{
textFieldStyle.normal.textColor = new Color(0.5f,0.5f,1);
textFieldStyle.focused.textColor = new Color(0.5f,0.5f,1);
}
else
{
textFieldStyle.normal.textColor = new Color(0,0,1);
textFieldStyle.focused.textColor = new Color(0,0,1);
}
}
else
{
// Normal player prefs are just black
textFieldStyle.normal.textColor = GUI.skin.textField.normal.textColor;
textFieldStyle.focused.textColor = GUI.skin.textField.focused.textColor;
}
// The full key is the key that's actually stored in player prefs
string fullKey = activePlayerPrefs[i].Key;
// Display key is used so in the case of encrypted keys, we display the decrypted version instead (in
// auto-decrypt mode).
string displayKey = fullKey;
// Used for accessing the type information stored against the player pref
object deserializedValue = activePlayerPrefs[i].Value;
// Track whether the auto decrypt failed, so we can instead fallback to encrypted values and mark it red
bool failedAutoDecrypt = false;
// If this is an encrypted play pref and we're attempting to decrypt them, try to decrypt it!
if (isEncryptedPair && automaticDecryption)
{
// This may throw exceptions (e.g. if private key changes), so wrap in a try-catch
try
{
deserializedValue = PlayerPrefsUtility.GetEncryptedValue(fullKey, (string)deserializedValue);
displayKey = PlayerPrefsUtility.DecryptKey(fullKey);
}
catch
{
// Change the colour to red to highlight the decrypt failed
textFieldStyle.normal.textColor = Color.red;
textFieldStyle.focused.textColor = Color.red;
// Track that the auto decrypt failed, so we can prevent any editing
failedAutoDecrypt = true;
}
}
EditorGUILayout.BeginHorizontal();
// The type of player pref being stored (in auto decrypt mode this works with the decrypted values too)
Type valueType;
// If it's an encrypted playerpref, we're automatically decrypting and it didn't fail the earlier
// auto decrypt test
if (isEncryptedPair && automaticDecryption && !failedAutoDecrypt)
{
// Get the encrypted string
string encryptedValue = PlayerPrefs.GetString(fullKey);
// Set valueType appropiately based on which type identifier prefix the encrypted string starts with
if (encryptedValue.StartsWith(PlayerPrefsUtility.VALUE_FLOAT_PREFIX))
{
valueType = typeof(float);
}
else if (encryptedValue.StartsWith(PlayerPrefsUtility.VALUE_INT_PREFIX))
{
valueType = typeof(int);
}
else if (encryptedValue.StartsWith(PlayerPrefsUtility.VALUE_STRING_PREFIX) || string.IsNullOrEmpty (encryptedValue))
{
// Special case here, empty encrypted values will also report as strings
valueType = typeof(string);
}
else
{
throw new InvalidOperationException("Could not decrypt item, no match found in known encrypted key prefixes");
}
}
else
{
// Otherwise fallback to the type of the cached value (for non-encrypted values this will be
// correct). For encrypted values when not in auto-decrypt mode, this will return string type
valueType = deserializedValue.GetType();
}
// Display the PlayerPref key
EditorGUILayout.TextField(displayKey, textFieldStyle);
// Value display and user editing
// If we're dealing with a float
if (valueType == typeof(float))
{
float initialValue;
if (isEncryptedPair && automaticDecryption)
{
// Automatically decrypt the value if encrypted and in auto-decrypt mode
initialValue = PlayerPrefsUtility.GetEncryptedFloat(displayKey);
}
else
{
// Otherwise fetch the latest plain value from PlayerPrefs in memory
initialValue = PlayerPrefs.GetFloat(fullKey);
}
// Display the float editor field and get any changes in value
float newValue = EditorGUILayout.FloatField(initialValue, textFieldStyle);
// If the value has changed
if (newValue != initialValue)
{
// Store the changed value in player prefs, encrypting if necessary
if (isEncryptedPair)
{
string encryptedValue = PlayerPrefsUtility.VALUE_FLOAT_PREFIX + SimpleEncryption.EncryptFloat(newValue);
PlayerPrefs.SetString(fullKey, encryptedValue);
}
else
{
PlayerPrefs.SetFloat(fullKey, newValue);
}
// Save PlayerPrefs
PlayerPrefs.Save();
}
// Display the PlayerPref type
GUILayout.Label("float", GUILayout.Width(37));
}
else if (valueType == typeof(int)) // if we're dealing with an int
{
int initialValue;
if (isEncryptedPair && automaticDecryption)
{
// Automatically decrypt the value if encrypted and in auto-decrypt mode
initialValue = PlayerPrefsUtility.GetEncryptedInt(displayKey);
}
else
{
// Otherwise fetch the latest plain value from PlayerPrefs in memory
initialValue = PlayerPrefs.GetInt(fullKey);
}
// Display the int editor field and get any changes in value
int newValue = EditorGUILayout.IntField(initialValue, textFieldStyle);
// If the value has changed
if (newValue != initialValue)
{
// Store the changed value in player prefs, encrypting if necessary
if (isEncryptedPair)
{
string encryptedValue = PlayerPrefsUtility.VALUE_INT_PREFIX + SimpleEncryption.EncryptInt(newValue);
PlayerPrefs.SetString(fullKey, encryptedValue);
}
else
{
PlayerPrefs.SetInt(fullKey, newValue);
}
// Save PlayerPrefs
PlayerPrefs.Save();
}
// Display the PlayerPref type
GUILayout.Label("int", GUILayout.Width(37));
}
else if (valueType == typeof(string)) // if we're dealing with a string
{
string initialValue;
if (isEncryptedPair && automaticDecryption && !failedAutoDecrypt)
{
// Automatically decrypt the value if encrypted and in auto-decrypt mode
initialValue = PlayerPrefsUtility.GetEncryptedString(displayKey);
}
else
{
// Otherwise fetch the latest plain value from PlayerPrefs in memory
initialValue = PlayerPrefs.GetString(fullKey);
}
// Display the text (string) editor field and get any changes in value
string newValue = EditorGUILayout.TextField(initialValue, textFieldStyle);
// If the value has changed
if (newValue != initialValue && !failedAutoDecrypt)
{
// Store the changed value in player prefs, encrypting if necessary
if (isEncryptedPair)
{
string encryptedValue = PlayerPrefsUtility.VALUE_STRING_PREFIX + SimpleEncryption.EncryptString(newValue);
PlayerPrefs.SetString(fullKey, encryptedValue);
}
else
{
PlayerPrefs.SetString(fullKey, newValue);
}
// Save PlayerPrefs
PlayerPrefs.Save();
}
if (isEncryptedPair && !automaticDecryption && !string.IsNullOrEmpty(initialValue))
{
// Because encrypted values when not in auto-decrypt mode are stored as string, determine their
// encrypted type and display that instead for these encrypted PlayerPrefs
PlayerPrefType playerPrefType = (PlayerPrefType)(int)char.GetNumericValue(initialValue[0]);
GUILayout.Label(playerPrefType.ToString().ToLower(), GUILayout.Width(37));
}
else
{
// Display the PlayerPref type
GUILayout.Label("string", GUILayout.Width(37));
}
}
// Delete button
if (GUILayout.Button("X", GUILayout.Width(25)))
{
// Delete the key from player prefs
PlayerPrefs.DeleteKey(fullKey);
// Tell Unity to Save PlayerPrefs
PlayerPrefs.Save();
// Delete the cached record so the list updates immediately
DeleteCachedRecord(fullKey);
}
EditorGUILayout.EndHorizontal();
}
// Calculate the padding at the bottom of the scroll view (because only visible player pref rows are drawn)
float bottomPadding = (entryCount - shownIndexLimit) * rowHeight;
// If the padding is positive, pad the bottom so that the layout and scroll view size is correct still
if (bottomPadding > 0)
{
GUILayout.Space(bottomPadding);
}
EditorGUILayout.EndScrollView();
// Display the number of player prefs
GUILayout.Label("Entry Count: " + entryCount);
}
private void DrawAddEntry()
{
// Create a GUIStyle that can be manipulated for the various text fields
GUIStyle textFieldStyle = new GUIStyle (GUI.skin.textField);
// Create a space
EditorGUILayout.Space();
// Heading
GUILayout.Label("Add Player Pref", EditorStyles.boldLabel);
// UI for whether the new player pref is encrypted and what type it is
EditorGUILayout.BeginHorizontal();
newEntryIsEncrypted = GUILayout.Toggle(newEntryIsEncrypted, "Encrypt");
newEntryType = (PlayerPrefType)GUILayout.SelectionGrid((int)newEntryType, new string[] { "float", "int", "string" }, 3);
EditorGUILayout.EndHorizontal();
// Key and Value headings
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Key", EditorStyles.boldLabel);
GUILayout.Label("Value", EditorStyles.boldLabel);
EditorGUILayout.EndHorizontal();
// If the new value will be encrypted tint the text boxes blue (in line with the display style for existing
// encrypted player prefs)
if (newEntryIsEncrypted)
{
if(UsingProSkin)
{
textFieldStyle.normal.textColor = new Color(0.5f,0.5f,1);
textFieldStyle.focused.textColor = new Color(0.5f,0.5f,1);
}
else
{
textFieldStyle.normal.textColor = new Color(0,0,1);
textFieldStyle.focused.textColor = new Color(0,0,1);
}
}
EditorGUILayout.BeginHorizontal();
// Track the next control so we can detect key events in it
GUI.SetNextControlName("newEntryKey");
// UI for the new key text box
newEntryKey = EditorGUILayout.TextField(newEntryKey, textFieldStyle);
// Track the next control so we can detect key events in it
GUI.SetNextControlName("newEntryValue");
// Display the correct UI field editor based on what type of player pref is being created
if (newEntryType == PlayerPrefType.Float)
{
newEntryValueFloat = EditorGUILayout.FloatField(newEntryValueFloat, textFieldStyle);
}
else if (newEntryType == PlayerPrefType.Int)
{
newEntryValueInt = EditorGUILayout.IntField(newEntryValueInt, textFieldStyle);
}
else
{
newEntryValueString = EditorGUILayout.TextField(newEntryValueString, textFieldStyle);
}
// If the user hit enter while either the key or value fields were being edited
bool keyboardAddPressed = Event.current.isKey && Event.current.keyCode == KeyCode.Return && Event.current.type == EventType.KeyUp && (GUI.GetNameOfFocusedControl() == "newEntryKey" || GUI.GetNameOfFocusedControl() == "newEntryValue");
// If the user clicks the Add button or hits return (and there is a non-empty key), create the player pref
if ((GUILayout.Button("Add", GUILayout.Width(40)) || keyboardAddPressed) && !string.IsNullOrEmpty(newEntryKey))
{
// If the player pref we're creating is encrypted
if (newEntryIsEncrypted)
{
// Encrypt the key
string encryptedKey = PlayerPrefsUtility.KEY_PREFIX + SimpleEncryption.EncryptString(newEntryKey);
// Note: All encrypted values are stored as string
string encryptedValue;
// Calculate the encrypted value
if (newEntryType == PlayerPrefType.Float)
{
encryptedValue = PlayerPrefsUtility.VALUE_FLOAT_PREFIX + SimpleEncryption.EncryptFloat(newEntryValueFloat);
}
else if (newEntryType == PlayerPrefType.Int)
{
encryptedValue = PlayerPrefsUtility.VALUE_INT_PREFIX + SimpleEncryption.EncryptInt(newEntryValueInt);
}
else
{
encryptedValue = PlayerPrefsUtility.VALUE_STRING_PREFIX + SimpleEncryption.EncryptString(newEntryValueString);
}
// Record the new player pref in PlayerPrefs
PlayerPrefs.SetString(encryptedKey, encryptedValue);
// Cache the addition
CacheRecord(encryptedKey, encryptedValue);
}
else
{
if (newEntryType == PlayerPrefType.Float)
{
// Record the new player pref in PlayerPrefs
PlayerPrefs.SetFloat(newEntryKey, newEntryValueFloat);
// Cache the addition
CacheRecord(newEntryKey, newEntryValueFloat);
}
else if (newEntryType == PlayerPrefType.Int)
{
// Record the new player pref in PlayerPrefs
PlayerPrefs.SetInt(newEntryKey, newEntryValueInt);
// Cache the addition
CacheRecord(newEntryKey, newEntryValueInt);
}
else
{
// Record the new player pref in PlayerPrefs
PlayerPrefs.SetString(newEntryKey, newEntryValueString);
// Cache the addition
CacheRecord(newEntryKey, newEntryValueString);
}
}
// Tell Unity to save the PlayerPrefs
PlayerPrefs.Save();
// Force a repaint since hitting the return key won't invalidate layout on its own
Repaint();
// Reset the values
newEntryKey = "";
newEntryValueFloat = 0;
newEntryValueInt = 0;
newEntryValueString = "";
// Deselect
GUI.FocusControl("");
}
EditorGUILayout.EndHorizontal();
}
private void DrawBottomMenu()
{
EditorGUILayout.Space();
// Allow the user to import player prefs from another project (helpful when renaming product name)
GUILayout.Label("Import", EditorStyles.boldLabel);
EditorGUILayout.BeginHorizontal();
GUIStyle textFieldStyle = new GUIStyle(GUI.skin.textField);
if (newEntryIsEncrypted)
{
if (UsingProSkin)
{
textFieldStyle.normal.textColor = new Color(0.5f, 0.5f, 1);
textFieldStyle.focused.textColor = new Color(0.5f, 0.5f, 1);
}
else
{
textFieldStyle.normal.textColor = new Color(0, 0, 1);
textFieldStyle.focused.textColor = new Color(0, 0, 1);
}
}
importCompanyName = EditorGUILayout.TextField(importCompanyName, textFieldStyle);
importProductName = EditorGUILayout.TextField(importProductName, textFieldStyle);
if(GUILayout.Button("Import"))
{
// Walk through all the imported player prefs and apply them to the current player prefs
PlayerPrefPair[] importedPairs = RetrieveSavedPrefs(importCompanyName, importProductName);
for (int i = 0; i < importedPairs.Length; i++)
{
Type type = importedPairs[i].Value.GetType();
if (type == typeof(float))
PlayerPrefs.SetFloat(importedPairs[i].Key, (float)importedPairs[i].Value);
else if (type == typeof(int))
PlayerPrefs.SetInt(importedPairs[i].Key, (int)importedPairs[i].Value);
else if (type == typeof(string))
PlayerPrefs.SetString(importedPairs[i].Key, (string)importedPairs[i].Value);
// Cache any new records until they are reimported from disk
CacheRecord(importedPairs[i].Key, importedPairs[i].Value);
}
// Force a save
PlayerPrefs.Save();
}
EditorGUILayout.EndHorizontal();
// UI for toggling automatic decryption on and off
automaticDecryption = EditorGUILayout.Toggle("Auto-Decryption", automaticDecryption);
EditorGUILayout.BeginHorizontal();
// Delete all player prefs
if (GUILayout.Button("Delete All Preferences"))
{
PlayerPrefs.DeleteAll();
PlayerPrefs.Save();
// Clear the cache too, for an instant visibility update for OSX
deserializedPlayerPrefs.Clear();
}
GUILayout.Space(15);
// Mainly needed for OSX, this will encourage PlayerPrefs to save to file (but still may take a few seconds)
if (GUILayout.Button("Force Save"))
{
PlayerPrefs.Save();
}
EditorGUILayout.EndHorizontal();
}
private void OnGUI()
{
EditorGUILayout.Space();
if(Application.platform == RuntimePlatform.OSXEditor)
{
// Construct the plist filename from the project's settings
string plistFilename = string.Format("unity.{0}.{1}.plist", PlayerSettings.companyName, PlayerSettings.productName);
// Now construct the fully qualified path
string playerPrefsPath = Path.Combine(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Library/Preferences"), plistFilename);
// Determine when the plist was last written to
DateTime lastWriteTime = File.GetLastWriteTimeUtc(playerPrefsPath);
// If we haven't deserialized the player prefs already, or the written file has changed then deserialize
// the latest version
if(!lastDeserialization.HasValue || lastDeserialization.Value != lastWriteTime)
{
// Deserialize the actual player prefs from file into a cache
deserializedPlayerPrefs = new List<PlayerPrefPair>(RetrieveSavedPrefs(PlayerSettings.companyName, PlayerSettings.productName));
// Record the version of the file we just read, so we know if it changes in the future
lastDeserialization = lastWriteTime;
}
if(lastWriteTime != MISSING_DATETIME)
{
GUILayout.Label("PList Last Written: " + lastWriteTime.ToString());
}
else
{
GUILayout.Label("PList Does Not Exist");
}
}
else if(Application.platform == RuntimePlatform.WindowsEditor)
{
// Windows works a bit differently to OSX, we just regularly query the registry. So don't query too often
if (!lastDeserialization.HasValue || DateTime.UtcNow - lastDeserialization.Value > TimeSpan.FromMilliseconds(500))
{
// Deserialize the actual player prefs from registry into a cache
deserializedPlayerPrefs = new List<PlayerPrefPair>(RetrieveSavedPrefs(PlayerSettings.companyName, PlayerSettings.productName));
// Record the latest time, so we don't fetch again too quickly
lastDeserialization = DateTime.UtcNow;
}
}
DrawSearchBar();
DrawMainList();
DrawAddEntry();
DrawBottomMenu();
// If the user has scrolled, deselect - this is because control IDs within carousel will change when scrolled
// so we'd end up with the wrong box selected.
if (scrollPosition != lastScrollPosition)
{
// Deselect
GUI.FocusControl("");
}
}
private void CacheRecord(string key, object value)
{
// First of all check if this key already exists, if so replace it's value with the new value
bool replaced = false;
int entryCount = deserializedPlayerPrefs.Count;
for (int i = 0; i < entryCount; i++)
{
// Found the key - it exists already
if (deserializedPlayerPrefs[i].Key == key)
{
// Update the cached pref with the new value
deserializedPlayerPrefs[i] = new PlayerPrefPair() { Key = key, Value = value };
// Mark the replacement so we no longer need to add it
replaced = true;
break;
}
}
// Player pref doesn't already exist (and wasn't replaced) so add it as new
if(!replaced)
{
// Cache a player pref the user just created so it can be instantly display (mainly for OSX)
deserializedPlayerPrefs.Add(new PlayerPrefPair() { Key = key, Value = value });
}
// Update the search if it's active
UpdateSearch();
}
private void DeleteCachedRecord(string fullKey)
{
keyQueuedForDeletion = fullKey;
}
// OnInspectorUpdate() is called by Unity at 10 times a second
private void OnInspectorUpdate()
{
// If a player pref has been specified for deletion
if(!string.IsNullOrEmpty(keyQueuedForDeletion))
{
// If the user just deleted a player pref, find the ID and defer it for deletion by OnInspectorUpdate()
if (deserializedPlayerPrefs != null)
{
int entryCount = deserializedPlayerPrefs.Count;
for (int i = 0; i < entryCount; i++)
{
if (deserializedPlayerPrefs[i].Key == keyQueuedForDeletion)
{
deserializedPlayerPrefs.RemoveAt(i);
break;
}
}
}
// Remove the queued key since we've just deleted it
keyQueuedForDeletion = null;
// Update the search results and repaint the window
UpdateSearch();
Repaint();
}
else if (inspectorUpdateFrame % 10 == 0) // Once a second (every 10th frame)
{
// Force the window to repaint
Repaint();
}
// Track what frame we're on, so we can call code less often
inspectorUpdateFrame++;
}
bool UsingProSkin
{
get
{
#if UNITY_3_4
if(EditorPrefs.GetInt("UserSkin") == 1)
{
return true;
}
else
{
return false;
}
#else
return EditorGUIUtility.isProSkin;
#endif
}
}
}

11
Assets/PlayerPrefsEditor/Editor/PlayerPrefsEditor.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 861677afe8cab4d3299ebf446fd71db0
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: