public static AssemblyPatch ParseFromJSON(JSON.Object obj)
{
var patch = new AssemblyPatch();
patch.TargetAssembly = Reflection.AssemblyPatcher.GetPatcher(obj["TargetAssembly"].Str);
patch.FileName = obj["TargetAssembly"].Str;
if (obj.ContainsKey("Instructions")) {
foreach (var inst in obj["Instructions"].Array) {
var instruction = (AssemblyInstruction)AssemblyInstruction.ParseFromJSON(inst.Obj);
if (instruction.InstructionType == AssemblyInstruction.EInstructionType.CreateType) {
MainClass.LogLine("-> Creating type: " + instruction.Name);
patch.TargetAssembly.CreateType(instruction.Name);
}
patch.Instructions.Add(instruction);
}
}
foreach (var typ in obj["Types"].Obj) {
var typePatch = TypePatch.ParseFromJSON(typ.Value.Obj, typ.Key, patch.TargetAssembly);
patch.Patches.Add(typePatch);
}
return patch;
}
public static void Save(JSON json, string fileName, int encriptionKey = 0)
{
if (!json.ContainsKey(VersionKey))
{
throw new Exception("File without version code");
}
if (json.GetInt(VersionKey) > CurrentVersion)
{
throw new Exception("File version is newer than this one");
}
if (json.GetInt(VersionKey) < CurrentVersion)
{
UpdateSave(ref json);
}
Debug.Log(json.CreatePrettyString());
string rawData = json.CreatePrettyString();
if (encriptionKey != 0)
{
rawData = SecureHelper.EncryptDecrypt(rawData, encriptionKey);
}
SaveLoadManager.SaveText(fileName, rawData);
}
new internal static BasePatch ParseFromJSON(JSON.Object obj, params object[] args)
{
var targetType = args[0] as Reflection.TypePatcher;
var patch = new MethodPatch();
if (obj.ContainsKey("TargetMethodSigniture"))
patch.TargetMethod = targetType.GetMethod(obj["TargetMethod"].Str, obj["TargetMethodSigniture"].Str);
else
patch.TargetMethod = targetType.GetMethod(obj["TargetMethod"].Str);
MainClass.LogLine(" + " + patch.TargetMethod.methodDefinition.GetSigniture());
foreach (JSON.Value instru in obj["Instructions"].Array) {
var instrupatch = MethodInstruction.ParseFromJSON(instru.Obj, patch);
switch (instrupatch.OperandType) {
case EOperandType.Instruction:
instrupatch.Operand = patch.TargetMethod.IlProc.Body.Instructions[instrupatch.ParamOrVarOffset];
break;
case EOperandType.Variable:
instrupatch.Operand = patch.TargetMethod.IlProc.Body.Variables[instrupatch.ParamOrVarOffset];
break;
case EOperandType.Parameter:
instrupatch.Operand = patch.TargetMethod.IlProc.Body.Method.Parameters[instrupatch.ParamOrVarOffset];
break;
}
patch.Instructions.Add(instrupatch);
}
return patch;
}
public static void LoadData(this ISaveAsJson source, JSON mainData)
{
if (!mainData.ContainsKey(source.Key))
{
return;
}
JSON loadData = mainData.GetJSON(source.Key);
if (!mainData.ContainsKey(source.Key))
{
return;
}
if (IsOldVersion(source, loadData))
{
source.UpdateSaveData(loadData);
}
source.Load(loadData);
}
public void Load(JSON data)
{
if (!data.ContainsKey("ClipName"))
{
return;
}
string clipName = data.GetString("ClipName");
SwapAnimationClip(CharacterPoseManager.Get(clipName));
}
private void ParseFBUserData(string jsonDataFromFbAsString)
{
// Parse string data received from FB to JSON
// Second (optional) parameter is ID for debug purposes. If anything fails in JSON parsing, this debug id is added to exception message.
// This will greatly help tracking problems in projects where lots of JSON objects are handled and stack trace is not necessary available (like in production builds).
// This same debug id will be attached also to resulting JSON object so that if any exceptions happens afterwards (for example when reading values from JSON),
// thos eexceptions will have this ID printed out also.
JSON fbUserJSON = JSON.ParseString(jsonDataFromFbAsString, "FBUserJSON");
// Set JSON protected (read only) so no accidental changes are made to it
// In this example this is of course somewhat pointless since JSON is only used locally in this method and not passed forward to anywhere
// But very handy if this JSON is paased forward and you want to make sure no other code accidentally changes anything
fbUserJSON.SetProtected();
// Add this JSON object to runtime debug in Unity Editor
// After this call, you can see content of this JSON object in Unity Editor, by choosing "Window -> Total JSON -> JSON Runtime Debug" from Unity menu
fbUserJSON.DebugInEditor("FB User JSON");
// Get user basic info
string userId = fbUserJSON.GetString("id");
string name = fbUserJSON.GetString("name");
// Get user picture info
JSON userPictureData = fbUserJSON.GetJSON("picture").GetJSON("data");
bool isPictureSilhouette = userPictureData.GetBool("is_silhouette");
string pictureUrl = userPictureData.GetString("url");
// Get country
string country;
try {
// This code just assumes data contains location information, which it in real life doesn't necessary do
country = fbUserJSON.GetJSON("location").GetJSON("location").GetString("country");
}
catch (JSONKeyNotFoundException) { // The lazy way to handle possibly missing information
country = "Unknown";
}
// Get currency USD exchange
decimal?usdExchange = null;
if (fbUserJSON.ContainsKey("currency"))
{
JSON userCurrency = fbUserJSON.GetJSON("currency");
usdExchange = userCurrency.GetJNumber("usd_exchange").AsDecimal();
}
// Print out what we got
Debug.Log("userId = " + userId);
Debug.Log("name = " + name);
Debug.Log("isPictureSilhouette = " + isPictureSilhouette);
Debug.Log("pictureUrl = " + pictureUrl);
Debug.Log("country = " + country);
Debug.Log("usdExchange = " + usdExchange);
}
public static bool IsOldVersion(this ISaveAsJson source, JSON data)
{
if (!data.ContainsKey(VersionKey))
{
throw new KeyNotFoundException($"El archivo NO contiene la VersionKey '{VersionKey}' para el tipo de archivo: {source.GetType()}");
}
int fileVersion = data.GetInt(VersionKey);
return(fileVersion < source.Version);
}
public void LoadSaveData(JSON json)
{
if (json.ContainsKey("value"))
{
Value.LoadSaveData(json.Get("value") as JSON);
}
else
{
Debug.LogWarning($"No se pudo cargar 'value' en {this}");
}
}
public static FieldInstruction ParseFromJSON(JSON.Object obj)
{
var instruction = new FieldInstruction();
instruction.InstructionType = (EInstructionType)Enum.Parse(typeof(EInstructionType),
obj["InstructionType"].Str,
true);
if (obj.ContainsKey("ValueSource")) {
instruction.ValueSource = (EValueSource)Enum.Parse(typeof(EValueSource), obj["ValueSource"].Str, true);
switch (instruction.ValueSource) {
case EValueSource.StaticField:
case EValueSource.TypeConstruction:
throw new NotImplementedException(instruction.ValueSource.ToString() + " as ValueSource is not yet implemented.");
case EValueSource.Custom:
instruction.Value = obj.ContainsKey("Value") ? obj["Value"].value : null;
break;
case EValueSource.PreDefined:
if (obj["Value"].Str == "%PatcherVersion%") {
instruction.Value = MainClass.Version;
}
break;
}
}
instruction.Public = obj.ContainsKey("Public") ? obj["Public"].Boolean : instruction.Public;
instruction.Static = obj.ContainsKey("Static") ? obj["Static"].Boolean : instruction.Static;
instruction.ReadOnly = obj.ContainsKey("ReadOnly") ? obj["ReadOnly"].Boolean : instruction.ReadOnly;
instruction.Constant = obj.ContainsKey("Constant") ? obj["Constant"].Boolean : instruction.Constant;
return instruction;
}
new internal static BasePatch ParseFromJSON(JSON.Object obj, params object[] args)
{
var targettype = args[0] as string;
var targetAssembly = args[1] as Reflection.AssemblyPatcher;
var patch = new TypePatch();
patch.TargetType = targetAssembly.GetType(targettype);
if (obj.ContainsKey("Instructions")) {
foreach (JSON.Value instru in obj["Instructions"].Array) {
var instruction = TypeInstruction.ParseFromJSON(instru.Obj);
if (instruction.InstructionType == TypeInstruction.EInstructionType.CreateMethod)
throw new NotImplementedException("Creating method is not yet a supported feature.");
if (instruction.InstructionType == TypeInstruction.EInstructionType.CreateField) {
patch.TargetType.CreateField(instruction.Name);
}
patch.Instructions.Add(instruction);
}
}
MainClass.LogLine(targettype);
if (obj.ContainsKey("Methods")) {
foreach (JSON.Value met in obj["Methods"].Array) {
var methodPatch = MethodPatch.ParseFromJSON(met.Obj, patch.TargetType);
patch.Patches.Add(methodPatch);
}
}
if (obj.ContainsKey("Fields")) {
foreach (JSON.Value fld in obj["Fields"].Array) {
var fieldPatch = FieldPatch.ParseFromJSON(fld.Obj, patch.TargetType);
patch.Patches.Add(fieldPatch);
}
}
return patch;
}
// this has to be called per scenario at start of the scenario, as it creates the basic Empty object for a scenario with its key structures
// better to be called after the PlayerID is set from GameManager, as this attempts to find an existing User file with same date to modify , or else it create a new one
public bool SetScenarioMasterLogObject(string key)
{
if (LogData == null)
{
Init();
}
if (key != null && key != "")
{
currentSecnarioMasterKey = key;
currentTAS = 0;
if (currentSecnarioMasterKey != "")
{
// initiate basics Log object Arrays
JArray TASData = new JArray();
JArray PlayerLookingAtData = new JArray();
JArray PlayerMovedToData = new JArray();
JArray PlayerSelectedStudentData = new JArray();
JArray StudentLookingAtData = new JArray();
JArray StudentAnimationsData = new JArray();
JArray StudentSetupData = new JArray();
JSON ScenarioMasterObject = new JSON();
JSON TeacherActionsObject = new JSON();
JSON PlayerActionsObject = new JSON();
JSON StudentActionsObject = new JSON();
JSON GettingToKnowYourClassObject = new JSON();
JSON InitialSituationObject = new JSON();
// Populate TeacherActions
TeacherActionsObject.AddOrReplace("TASData", TASData);
// Populate PlayerActions
PlayerActionsObject.AddOrReplace("LookingAt", PlayerLookingAtData);
PlayerActionsObject.AddOrReplace("MovedTo", PlayerMovedToData);
PlayerActionsObject.AddOrReplace("SelectedStudent", PlayerSelectedStudentData);
// Populate StudentActions
StudentActionsObject.AddOrReplace("LookingAt", StudentLookingAtData);
StudentActionsObject.AddOrReplace("Animations", StudentAnimationsData);
// Populate GettingToKnowYourClassObject
GettingToKnowYourClassObject.AddOrReplace("start1", "");
GettingToKnowYourClassObject.AddOrReplace("end1", "");
// Populate InitialSituationObject
InitialSituationObject.AddOrReplace("start2", "");
InitialSituationObject.AddOrReplace("end2", "");
// Add all the above and StudentSetup to the Current Scenario Object
ScenarioMasterObject.AddOrReplace("GettingToKnowYourClass", GettingToKnowYourClassObject);
ScenarioMasterObject.AddOrReplace("InitialSituation", InitialSituationObject);
ScenarioMasterObject.AddOrReplace("TeacherActions", TeacherActionsObject);
ScenarioMasterObject.AddOrReplace("StudentSetup", StudentSetupData);
ScenarioMasterObject.AddOrReplace("PlayerActions", PlayerActionsObject);
ScenarioMasterObject.AddOrReplace("StudentActions", StudentActionsObject);
if (LogData.ContainsKey(currentSecnarioMasterKey))
{
LogData.AddOrReplace(currentSecnarioMasterKey, ScenarioMasterObject);
}
else
{
LogData.Add(currentSecnarioMasterKey, ScenarioMasterObject);
}
}
return(true);
}
currentSecnarioMasterKey = "";
Debug.LogAssertion("Key for New attepmt to set Scenario Master Log Object is empty or null");
return(false);
}
private void recursiveAddUI(JSON.Object json, GameObject parent)
{
var go = new GameObject(json.GetString("name", "AddUI CreatedPanel"));
if (parent == null) {
var parentName = json.GetString("parent", "Overlay");
parent = findServerCreatedPanel(parentName); //Find parent in serverCreatedUI
if (parent == null) {
parent = findClientPanel(parentName);//Find parent in the client UI
if (parent == null)
return; //Parent doesn't exists
//Add the GameObject to serverCreatedUI since it's a new UI and destroy old one if it exists
if(go != null)
DestroyPanel(go.name, true);
serverCreatedUI.Add(go);
}
}
generateElement(go, json);
go.transform.SetParent(parent.transform, false);
if (json.ContainsKey("childs"))
foreach (var child in json.GetArray("childs")) {
recursiveAddUI(child.Obj, go);
}
}
private void GraphicComponentCreated(UnityEngine.UI.Graphic c, JSON.Object obj)
{
if (obj.ContainsKey("fadeIn")) {
c.canvasRenderer.SetAlpha(0f);
c.CrossFadeAlpha(1f, obj.GetFloat("fadeIn", 0), true);
}
}
private void generateElement(GameObject go, JSON.Object json)
{
var rt = go.GetComponent<RectTransform>();
if (rt) {
rt.anchorMin = new Vector2(0, 0);
rt.anchorMax = new Vector2(1, 1);
rt.offsetMin = new Vector2(0, 0);
rt.offsetMax = new Vector2(1, 1);
}
foreach (var component in json.GetArray( "components" )) {
CreateComponents(go, component.Obj);
}
if (json.ContainsKey("fadeOut")) {
go.AddComponent<FadeOut>().duration = json.GetFloat("fadeOut", 0);
}
}
private void CreateComponents(GameObject go, JSON.Object obj)
{
//
// This is the 'stupid' but 'safe & predictable way of doing this.
//
switch (obj.GetString("type", "UnityEngine.UI.Text")) {
case "UnityEngine.UI.Text":
{
var c = go.AddComponent<UnityEngine.UI.Text>();
c.text = obj.GetString("text", "Text");
c.fontSize = obj.GetInt("fontSize", 14);
c.font = FileSystem.Load<Font>("Assets/Content/UI/Fonts/" + obj.GetString("font", "RobotoCondensed-Bold.ttf"));
c.alignment = (TextAnchor)System.Enum.Parse(typeof(TextAnchor), obj.GetString("align", "UpperLeft"));
c.color = ColorEx.Parse(obj.GetString("color", "1.0 1.0 1.0 1.0"));
GraphicComponentCreated(c, obj);
break;
}
case "UnityEngine.UI.Image":
{
var c = go.AddComponent<UnityEngine.UI.Image>();
c.sprite = FileSystem.Load<Sprite>(obj.GetString("sprite", "Assets/Content/UI/UI.Background.Tile.psd"));
c.material = FileSystem.Load<Material>(obj.GetString("material", "Assets/Icons/IconMaterial.mat"));
c.color = ColorEx.Parse(obj.GetString("color", "1.0 1.0 1.0 1.0"));
c.type = (UnityEngine.UI.Image.Type)System.Enum.Parse(typeof(UnityEngine.UI.Image.Type), obj.GetString("imagetype", "Simple"));
if (obj.ContainsKey("png")) {
PngGraphicLoadRequested(c, uint.Parse(obj.GetString("png")));
}
GraphicComponentCreated(c, obj);
break;
}
case "UnityEngine.UI.RawImage":
{
var c = go.AddComponent<UnityEngine.UI.RawImage>();
c.texture = FileSystem.Load<Texture>(obj.GetString("sprite", "Assets/Icons/rust.png"));
c.color = ColorEx.Parse(obj.GetString("color", "1.0 1.0 1.0 1.0"));
if (obj.ContainsKey("material")) {
c.material = FileSystem.Load<Material>(obj.GetString("material"));
}
if (obj.ContainsKey("url")) {
StartCoroutine(LoadTextureFromWWW(c, obj.GetString("url")));
}
if (obj.ContainsKey("png")) {
PngGraphicLoadRequested(c, uint.Parse(obj.GetString("png")));
}
GraphicComponentCreated(c, obj);
break;
}
case "UnityEngine.UI.Button":
{
var c = go.AddComponent<UnityEngine.UI.Button>();
if (obj.ContainsKey("command")) {
var cmd = obj.GetString("command");
c.onClick.AddListener(() => {
ConsoleSystem.ClientRunOnServer(cmd);
});
}
if (obj.ContainsKey("close")) {
var pnlName = obj.GetString("close");
c.onClick.AddListener(() => {
DestroyPanel(pnlName);
});
}
// bg image
var img = go.AddComponent<UnityEngine.UI.Image>();
img.sprite = FileSystem.Load<Sprite>(obj.GetString("sprite", "Assets/Content/UI/UI.Background.Tile.psd"));
img.material = FileSystem.Load<Material>(obj.GetString("material", "Assets/Icons/IconMaterial.mat"));
img.color = ColorEx.Parse(obj.GetString("color", "1.0 1.0 1.0 1.0"));
img.type = (UnityEngine.UI.Image.Type)System.Enum.Parse(typeof(UnityEngine.UI.Image.Type), obj.GetString("imagetype", "Simple"));
c.image = img;
GraphicComponentCreated(img, obj);
break;
}
case "UnityEngine.UI.Outline":
{
var c = go.AddComponent<UnityEngine.UI.Outline>();
c.effectColor = ColorEx.Parse(obj.GetString("color", "1.0 1.0 1.0 1.0"));
c.effectDistance = Vector2Ex.Parse(obj.GetString("distance", "1.0 -1.0"));
c.useGraphicAlpha = obj.ContainsKey("useGraphicAlpha");
break;
}
case "NeedsCursor":
{
go.AddComponent<NeedsCursor>();
break;
}
case "RectTransform":
{
var rt = go.GetComponent<RectTransform>();
if (rt) {
rt.anchorMin = Vector2Ex.Parse(obj.GetString("anchormin", "0.0 0.0"));
rt.anchorMax = Vector2Ex.Parse(obj.GetString("anchormax", "1.0 1.0"));
rt.offsetMin = Vector2Ex.Parse(obj.GetString("offsetmin", "0.0 0.0"));
rt.offsetMax = Vector2Ex.Parse(obj.GetString("offsetmax", "1.0 1.0"));
}
break;
}
}
}
/// <summary>
/// Parse JSON string to key value pairs
/// </summary>
/// <param name="rawjson">JSON String</param>
/// <returns>Key value pairs data</returns>
public static JSON Parse(string rawjson)
{
JSON outdict = new JSON();
StringBuilder keybufferbuilder = new StringBuilder();
StringBuilder valuebufferbuilder = new StringBuilder();
StringReader bufferreader = new StringReader(rawjson);
int s = 0;
bool reading = false;
bool inside_string = false;
bool reading_value = false;
//break at end (returns -1)
while (s >= 0)
{
s = bufferreader.Read();
//opening of json
if (!reading)
{
if ((char)s == '{' && !inside_string && !reading)
{
reading = true;
}
continue;
}
else
{
//if we find a quote and we are not yet inside a string, advance and get inside
if (!inside_string)
{
//read past the quote
if ((char)s == '\"')
{
inside_string = true;
}
continue;
}
if (inside_string)
{
//if we reached the end of the string
if ((char)s == '\"')
{
inside_string = false;
s = bufferreader.Read(); //advance pointer
if ((char)s == ':')
{
reading_value = true;
continue;
}
if (reading_value && (char)s == ',')
{
//we know we just ended the line, so put itin our dictionary
if (!outdict.ContainsKey(keybufferbuilder.ToString()))
{
outdict.Add(keybufferbuilder.ToString(), valuebufferbuilder.ToString());
}
//and clear the buffers
keybufferbuilder.Clear();
valuebufferbuilder.Clear();
reading_value = false;
}
if (reading_value && (char)s == '}')
{
//we know we just ended the line, so put itin our dictionary
if (!outdict.ContainsKey(keybufferbuilder.ToString()))
{
outdict.Add(keybufferbuilder.ToString(), valuebufferbuilder.ToString());
}
//and clear the buffers
keybufferbuilder.Clear();
valuebufferbuilder.Clear();
reading_value = false;
reading = false;
break;
}
}
else
{
if (reading_value)
{
valuebufferbuilder.Append((char)s);
continue;
}
else
{
keybufferbuilder.Append((char)s);
continue;
}
}
}
else
{
switch ((char)s)
{
case ':':
reading_value = true;
break;
default:
if (reading_value)
{
valuebufferbuilder.Append((char)s);
}
else
{
keybufferbuilder.Append((char)s);
}
break;
}
}
}
}
return(outdict);
}
public static MethodInstruction ParseFromJSON(JSON.Object instru, MethodPatch targetMethod)
{
var patch = new MethodInstruction();
patch.InstructionType = (EInstructionType)Enum.Parse(typeof(EInstructionType),
instru["InstructionType"].Str);
switch (patch.InstructionType) {
case EInstructionType.SetVisibility:
patch.Public = instru.ContainsKey("Public") ? instru["Public"].Boolean : patch.Public;
break;
case EInstructionType.RemoveRange:
patch.RemoveEnd = Int32.Parse(instru["RemoveEnd"].Str);
goto case EInstructionType.RemoveAt;
case EInstructionType.RemoveAt:
patch.RemoveStart = Int32.Parse(instru["RemoveStart"].Str);
goto case EInstructionType.Clear;
case EInstructionType.Clear:
return patch;
case EInstructionType.InsertAfter:
case EInstructionType.InsertBefore:
patch.InsertOffset = Int32.Parse(instru["InsertOffset"].Str);
break;
}
patch.Instruction = Instruction.Create(OpCodes.Ret);
patch.OpCode = (OpCode)typeof(OpCodes).GetField(instru["OpCode"].Str).GetValue(typeof(OpCodes));
patch.OperandType = (EOperandType)Enum.Parse(typeof(EOperandType), instru["OperandType"].Str);
switch (patch.OperandType) {
case EOperandType.Type:
patch.Operand = Reflection.AssemblyPatcher.GetPatcher(instru["TargetAssembly"].Str).GetType(instru["TargetType"].Str).typeDefinition;
break;
case EOperandType.Method:
if (instru.ContainsKey("TargetMethodSigniture"))
patch.Operand = targetMethod.TargetMethod.rootAssemblyPatcher.mainModule.Import(Reflection.AssemblyPatcher.GetPatcher(instru["TargetAssembly"].Str).GetType(instru["TargetType"].Str).GetMethod(instru["TargetMethod"].Str,
instru["TargetMethodSigniture"].Str).methodDefinition);
else
patch.Operand = targetMethod.TargetMethod.rootAssemblyPatcher.mainModule.Import(Reflection.AssemblyPatcher.GetPatcher(instru["TargetAssembly"].Str).GetType(instru["TargetType"].Str).GetMethod(instru["TargetMethod"].Str).methodDefinition);
break;
case EOperandType.Field:
patch.Operand = Reflection.AssemblyPatcher.GetPatcher(instru["TargetAssembly"].Str).GetType(instru["TargetType"].Str).GetField(instru["TargetField"].Str);
break;
case EOperandType.Parameter:
case EOperandType.Variable:
case EOperandType.Instruction:
patch.ParamOrVarOffset = Int32.Parse(instru["ParamVarOffset"].Str);
break;
case EOperandType.SByte:
patch.Operand = SByte.Parse(instru["Operand"].Str);
break;
case EOperandType.Byte:
patch.Operand = Byte.Parse(instru["Operand"].Str);
break;
case EOperandType.Int:
patch.Operand = Int32.Parse(instru["Operand"].Str);
break;
case EOperandType.Float:
patch.Operand = Single.Parse(instru["Operand"].Str);
break;
case EOperandType.Long:
patch.Operand = Int64.Parse(instru["Operand"].Str);
break;
case EOperandType.Double:
patch.Operand = Double.Parse(instru["Operand"].Str);
break;
case EOperandType.String:
patch.Operand = instru["Operand"].Str;
break;
}
return patch;
}
private void Test1()
{
// Create empty JSON object "{}"
JSON jsonObject = new JSON();
// Add this JSON object to debug
// After this call, you can see content of this JSON object in Unity Editor, by choosing "Window -> Total JSON -> JSON Runtime Debug" from Unity menu
// For debug/development purposes it is very handy to see contents of JSON objects while application is running in editor
jsonObject.DebugInEditor("CreateAndModify Test JSON");
Debug.Log("Note! You can see the content of selected JSON objects while application is running by choosing \"Window -> Total JSON -> JSON Runtime Debug\" from Unity menu");
// Add basic things
jsonObject.Add("text", "Hello World!");
jsonObject.Add("number", 42);
jsonObject.Add("truth", true);
jsonObject.Add("nullText", null);
jsonObject.Add("numberArray", new int[] { 1, 2, 4, 8 });
// Print out
Debug.Log(jsonObject.CreateString()); // {"text":"Hello World!","number":42,"truth":true,"nullText":null,"numberArray":[1,2,4,8]}
// Do some changes
jsonObject.Remove("number");
jsonObject.Replace("truth", false);
// Loop through all the keys and print out debug info of all values
Debug.Log("Info of all the values:");
foreach (string key in jsonObject.Keys)
{
Debug.Log(key + ": " + jsonObject[key]);
}
// Loop through all the keys and print out all values in JSON formatted strings
Debug.Log("Content of all the values:");
foreach (string key in jsonObject.Keys)
{
Debug.Log(key + " -> " + jsonObject[key].CreateString());
}
// Get and print out some values
Debug.Log("Print outs of some values:");
Debug.Log(jsonObject.GetString("text")); // "Hello World!"
Debug.Log(jsonObject.ContainsKey("number")); // false
Debug.Log(jsonObject.GetBool("truth")); // false
Debug.Log(jsonObject.GetString("nullText")); // Null
// Do some changes to array
JArray jsonArray = jsonObject.GetJArray("numberArray"); // Contains ints 1,2,4,8
jsonArray.Add(16); // 1,2,4,8,16
jsonArray.RemoveAt(1); // 1,4,8,16
jsonArray.InsertAt(3, 0); // 1,4,8,0,16
jsonArray.ReplaceAt(2, -1); // 1,4,-1,0,16
// Print out some array values
Debug.Log("Array length: " + jsonArray.Length); // 5
Debug.Log("Fifth element as int: " + jsonArray.GetInt(4)); // 16
// Since all values in array are numbers (JNumber) and they all fit to c# int values, array can be also copied to system int array
int[] systemIntArray = jsonArray.AsIntArray();
// Print out values
Debug.Log("Second element as int: " + systemIntArray[1]); // 4
}