Esempio n. 1
0
    // Use this for initialization
    void Start()
    {
        //set values for IntArray at startup
        IntArray = new int[] { 1, 2, 3, 4, 5 };

        //set values for StringArray at startup
        StringArray = new string[] { "abc", "bcd" };

        //set values for FloatArray at startup
        FloatArray = new float[] { 0.1f, 100, Random.Range(-10.0f, 10.0f) };

        // save it
        PlayerPrefsElite.SetIntArray("IntArray", IntArray);
        PlayerPrefsElite.SetStringArray("StringArray", StringArray);
        PlayerPrefsElite.SetFloatArray("FloatArray", FloatArray);

        //now verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyArray("IntArray"))
        {
            testIntArray = PlayerPrefsElite.GetIntArray("IntArray");
            Debug.Log("IntArray return true");
        }

        if (PlayerPrefsElite.VerifyArray("StringArray"))
        {
            testStringArray = PlayerPrefsElite.GetStringArray("StringArray");
            Debug.Log("StringArray return true");
        }

        if (PlayerPrefsElite.VerifyArray("FloatArray"))
        {
            testFloatArray = PlayerPrefsElite.GetFloatArray("FloatArray");
            Debug.Log("FloatArray return true");
        }
    }
Esempio n. 2
0
 // Use this for initialization
 void Awake()
 {
     PlayerPrefsElite.setKeys(keys);
     if (!Application.isEditor)
     {
         Destroy(this);
     }
 }
Esempio n. 3
0
    // Use this for initialization
    void Start()
    {
        myItem = true;

        // save myItem
        PlayerPrefsElite.SetBoolean("myItem", myItem);

        //verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyBoolean("myItem"))
        {
            Debug.Log("myItem verified");
        }
    }
Esempio n. 4
0
    // Use this for initialization
    void Start()
    {
        myFloat = 1.0f;

        // save myFloat
        PlayerPrefsElite.SetFloat("myFloat", myFloat);

        //verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyFloat("myFloat"))
        {
            newFloat = PlayerPrefs.GetFloat("myFloat");
            Debug.Log("myFloat return true");
        }
    }
Esempio n. 5
0
    // Use this for initialization
    void Start()
    {
        // Vector2 test
        //set values for myVector2 at startup
        myVector2 = new Vector2(Random.Range(0.0f, 100.0f), 1.0f);

        // save it to player preferences
        PlayerPrefsElite.SetVector2("myVector2", myVector2);

        //verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyVector2("myVector2"))
        {
            // Assign myVector2 from player preferences to myNewVector2
            myNewVector2 = PlayerPrefsElite.GetVector2("myVector2");
            Debug.Log("myNewVector2 return true");
        }



        // Vector3 test
        //set values for myVector3 at startup
        myVector3 = new Vector3(Random.Range(0.0f, 100.0f), 2.0f, 3);

        // save it to player preferences
        PlayerPrefsElite.SetVector3("myVector3", myVector3);

        //verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyVector3("myVector3"))
        {
            // Assign myVector3 from player preferences to myNewVector3
            myNewVector3 = PlayerPrefsElite.GetVector3("myVector3");
            Debug.Log("myNewVector3 return true");
        }


        // Vector4 test
        //set values for myVector4 at startup
        myVector4 = new Vector4(Random.Range(0.0f, 100.0f), 2.0f, 3, 100);

        // save it to player preferences
        PlayerPrefsElite.SetVector4("myVector4", myVector4);

        //verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyVector4("myVector4"))
        {
            // Assign myVector4 from player preferences to myNewVector4
            myNewVector4 = PlayerPrefsElite.GetVector4("myVector4");
            Debug.Log("myNewVector4 return true");
        }
    }
Esempio n. 6
0
    // Use this for initialization
    void Start()
    {
        myString = "I choose to believe what I was programmed to believe!";

        // save myString
        PlayerPrefsElite.SetString("myString", myString);

        //verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyString("myString"))
        {
            newString = PlayerPrefs.GetString("myString");
            Debug.Log("myString return true");
        }
    }
Esempio n. 7
0
    // Use this for initialization
    void Start()
    {
        myInt = 100;

        // save myInt
        PlayerPrefsElite.SetInt("myInt", myInt);

        //verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyInt("myInt"))
        {
            newInt = PlayerPrefs.GetInt("myInt");
            Debug.Log("myInt return true");
        }
    }
Esempio n. 8
0
    // Use this for initialization
    void Start()
    {
        // Initialize variables
        Lives  = 3;
        Scores = Random.Range(0, 10000);

        // Store encrypted variables (Lives + Scores)
        PlayerPrefsElite.Encrypt("Combined", Lives.ToString() + Scores.ToString());

        // Compare between already saved "Combined" and current Lives + Scores

        if (PlayerPrefsElite.CompareEncrypt("Combined", Lives.ToString() + Scores.ToString()))
        {
            Debug.Log("It's true");
        }
    }
Esempio n. 9
0
    // Use this for initialization
    void Start()
    {
        // add an new item to the end of the myArrayList
        myArrayList.Add("sometext");

        // save it
        PlayerPrefsElite.SetStringArray("myArrayList", myArrayList);

        //now verify and read from PlayerPrefs
        if (PlayerPrefsElite.VerifyArray("myArrayList"))
        {
            // Assign the myArrayList from player preferences to myOtherArrayList
            ArrayList myOtherArrayList = new ArrayList(PlayerPrefsElite.GetStringArray("myArrayList"));

            // log
            Debug.Log("myArrayList return true, myOtherArrayList now contained " + myOtherArrayList.Count + " number of elements and retrieve \"" + myOtherArrayList[0] + "\" from myOtherArrayList[0]");
        }
    }
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            // Display MonoScript
            //MonoScript script = MonoScript.FromMonoBehaviour(target as MonoBehaviour);
            //EditorGUI.BeginDisabledGroup(true);
            //EditorGUILayout.ObjectField("Script", script, typeof(MonoScript), false);
            //EditorGUI.EndDisabledGroup();

            // Help boxes
            EditorGUILayout.HelpBox("Changing the Data Type will modify some ToryFramework scripts immediately, and Unity editor will reload the scripts.",
                                    MessageType.Info);

            // Data type
            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(dataType);
            if (EditorGUI.EndChangeCheck())
            {
                string typeStr = "";
                switch (dataType.enumValueIndex)
                {
                case (int)DataType.Int:
                    typeStr = "int";
                    break;

                case (int)DataType.Float:
                    typeStr = "float";
                    break;

                case (int)DataType.Vector2:
                    typeStr = "Vector2";
                    break;

                case (int)DataType.Vector3:
                    typeStr = "Vector3";
                    break;

                case (int)DataType.Vector4:
                    typeStr = "Vector4";
                    break;

                case (int)DataType.Quaternion:
                    typeStr = "Quaternion";
                    break;

                case (int)DataType.KeyCode:
                    typeStr = "KeyCode";
                    break;

                default:
                    break;
                }

                // Modify the ToryInput.cs
                // Generating a script reference: http://answers.unity3d.com/questions/1170350/editorscript-generate-enum-from-string.html
                StringBuilder code = new StringBuilder();
                code.Append("using ToryFramework.Input;\n\nnamespace ToryFramework\n{\n\tpublic class ToryInput : Tory" +
                            char.ToUpper(typeStr[0]) + typeStr.Substring(1) +
                            "Input\n\t{\n\t\t#region SINGLETON\n\n\t\tstatic volatile ToryInput instance;\n\t\tstatic readonly object syncRoot = new object();\n\n\t\tToryInput() { }\n\n\t\tpublic static ToryInput Instance\n\t\t{\n\t\t\tget\n\t\t\t{\n\t\t\t\tif (instance == null)\n\t\t\t\t{\n\t\t\t\t\tlock (syncRoot)\n\t\t\t\t\t{\n\t\t\t\t\t\tif (instance == null)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tinstance = new ToryInput();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn instance;\n\t\t\t}\n\t\t}\n\n\t\t#endregion\n\t}\t\n}");

                // Set the path of the script.
                MonoScript script = MonoScript.FromMonoBehaviour(behaviour);
                string     path   = AssetDatabase.GetAssetPath(script);
                path = path.Substring(0, path.Length - Path.GetFileName(path).Length - 1);
                string[] paths = path.Split('/');
                path = "";
                for (int i = 0; i < paths.Length - 3; i++)
                {
                    path += paths[i] + "/";
                }
                path += "(Do Not Update This Folder)/Scripts/ToryInput/Singletons/" + toryInputFileName + ".cs";

                // Write the script.
                if (File.Exists(path))
                {
                    if (!string.Equals(code.ToString(), File.ReadAllText(path)))
                    {
                        File.WriteAllText(path, code.ToString());
                        AssetDatabase.ImportAsset(path);
                        Debug.Log("[ToryInput] The \"" + toryInputFileName + ".cs\" modified and loaded.");
                    }
                }
                else
                {
                    File.WriteAllText(path, code.ToString());
                    AssetDatabase.ImportAsset(path);
                    Debug.Log("[ToryInput] A new \"" + toryInputFileName + ".cs\" created and loaded.");
                }

                // Modifying the ToryMultiInput.cs
                // Generating a script reference: http://answers.unity3d.com/questions/1170350/editorscript-generate-enum-from-string.html
                code.Remove(0, code.Length);
                code.Append("namespace ToryFramework.Input\n{\n\tpublic class ToryMultiInput : Tory" +
                            char.ToUpper(typeStr[0]) + typeStr.Substring(1) +
                            "MultiInput\n\t{\n\t\t#region CONSTRUCTOR\n\n\t\tpublic ToryMultiInput() : base()\n\t\t{\n\t\t}\n\n\t\tpublic ToryMultiInput(int id) : base(id)\n\t\t{\n\t\t}\n\n\t\t#endregion\n\t}\t\n}");

                // Set the path of the script.
                path  = path.Substring(0, path.Length - Path.GetFileName(path).Length);
                path += toryMultiInputFileName + ".cs";

                // Write the script.
                if (File.Exists(path))
                {
                    if (!string.Equals(code.ToString(), File.ReadAllText(path)))
                    {
                        File.WriteAllText(path, code.ToString());
                        AssetDatabase.ImportAsset(path);
                        Debug.Log("[ToryInput] The \"" + toryMultiInputFileName + ".cs\" modified and loaded.");
                    }
                }
                else
                {
                    File.WriteAllText(path, code.ToString());
                    AssetDatabase.ImportAsset(path);
                    Debug.Log("[ToryInput] A new \"" + toryMultiInputFileName + ".cs\" created and loaded.");
                }
            }

            if (dataType.enumValueIndex != (int)DataType.KeyCode)
            {
                // Filter type
                int f = filterType.FindPropertyRelative("currentValue").enumValueIndex;
                EditorGUI.BeginChangeCheck();
                EditorGUILayout.PropertyField(filterType);
                if (EditorGUI.EndChangeCheck())
                {
                    // Do nth.
                }

                // OEF frequency
                if (f == (int)FilterType.ONE_EURO_FILTER)
                {
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(oefFrequency, new GUIContent("OEF Frequency"));
                    if (EditorGUI.EndChangeCheck())
                    {
                        // Restrict the value.
                        oefFrequency.FindPropertyRelative("currentValue").floatValue = Mathf.Max(oefFrequency.FindPropertyRelative("currentValue").floatValue, 0f);
                        oefFrequency.FindPropertyRelative("defaultValue").floatValue = Mathf.Max(oefFrequency.FindPropertyRelative("defaultValue").floatValue, 0f);
                        if (SecureKeysChecker.CheckSecureKeys() &&
                            PlayerPrefsElite.key != null &&
                            PlayerPrefs.HasKey(KeyFormatter.GetSavedKey(oefFrequency.FindPropertyRelative("key").stringValue)))
                        {
                            float sv = PlayerPrefsElite.GetFloat(KeyFormatter.GetSavedKey(oefFrequency.FindPropertyRelative("key").stringValue));
                            sv = Mathf.Max(0f, sv);
                            PlayerPrefsElite.SetFloat(KeyFormatter.GetSavedKey(oefFrequency.FindPropertyRelative("key").stringValue),
                                                      sv);
                        }
                    }
                }
                // Ensemble average
                else if (f == (int)FilterType.ENSEMBLE_AVERAGE)
                {
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(ensembleSize);
                    if (EditorGUI.EndChangeCheck())
                    {
                        // Restrict the value.
                        ensembleSize.FindPropertyRelative("currentValue").intValue = Mathf.Max(ensembleSize.FindPropertyRelative("currentValue").intValue, 1);
                        ensembleSize.FindPropertyRelative("defaultValue").intValue = Mathf.Max(ensembleSize.FindPropertyRelative("defaultValue").intValue, 1);
                        if (SecureKeysChecker.CheckSecureKeys() &&
                            PlayerPrefsElite.key != null &&
                            PlayerPrefs.HasKey(KeyFormatter.GetSavedKey(ensembleSize.FindPropertyRelative("key").stringValue)))
                        {
                            int sv = PlayerPrefsElite.GetInt(KeyFormatter.GetSavedKey(ensembleSize.FindPropertyRelative("key").stringValue));
                            sv = Mathf.Max(1, sv);
                            PlayerPrefsElite.SetInt(KeyFormatter.GetSavedKey(ensembleSize.FindPropertyRelative("key").stringValue),
                                                    sv);
                        }
                    }
                }

                // Gain
                EditorGUI.BeginChangeCheck();
                EditorGUILayout.PropertyField(gain);
                if (EditorGUI.EndChangeCheck())
                {
                    // Do nth.
                }
            }

            // Interaction type
            int c = interactionType.FindPropertyRelative("currentValue").enumValueIndex;

            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(interactionType);
            if (EditorGUI.EndChangeCheck())
            {
                // Do nth.
            }

            // Minimum interaction.
            if (c == (int)InteractionType.CONTINUOUS)
            {
                EditorGUI.BeginChangeCheck();
                EditorGUILayout.PropertyField(minimumInteraction);
                if (EditorGUI.EndChangeCheck())
                {
                    // Restrict the value.
                    minimumInteraction.FindPropertyRelative("currentValue").floatValue = Mathf.Max(minimumInteraction.FindPropertyRelative("currentValue").floatValue, 0f);
                    minimumInteraction.FindPropertyRelative("defaultValue").floatValue = Mathf.Max(minimumInteraction.FindPropertyRelative("defaultValue").floatValue, 0f);
                    if (SecureKeysChecker.CheckSecureKeys() &&
                        PlayerPrefsElite.key != null &&
                        PlayerPrefs.HasKey(KeyFormatter.GetSavedKey(minimumInteraction.FindPropertyRelative("key").stringValue)))
                    {
                        float sv = PlayerPrefsElite.GetFloat(KeyFormatter.GetSavedKey(minimumInteraction.FindPropertyRelative("key").stringValue));
                        sv = Mathf.Max(0f, sv);
                        PlayerPrefsElite.SetFloat(KeyFormatter.GetSavedKey(minimumInteraction.FindPropertyRelative("key").stringValue),
                                                  sv);
                    }
                }
            }

            // Max multi-input count
            EditorGUI.BeginChangeCheck();
            EditorGUILayout.PropertyField(maxMultiInputCount);
            if (EditorGUI.EndChangeCheck())
            {
                // Restrict the value.
                maxMultiInputCount.FindPropertyRelative("currentValue").intValue = Mathf.Max(maxMultiInputCount.FindPropertyRelative("currentValue").intValue, 0);
                maxMultiInputCount.FindPropertyRelative("defaultValue").intValue = Mathf.Max(maxMultiInputCount.FindPropertyRelative("defaultValue").intValue, 0);
                if (SecureKeysChecker.CheckSecureKeys() &&
                    PlayerPrefsElite.key != null &&
                    PlayerPrefs.HasKey(KeyFormatter.GetSavedKey(maxMultiInputCount.FindPropertyRelative("key").stringValue)))
                {
                    int sv = PlayerPrefsElite.GetInt(KeyFormatter.GetSavedKey(maxMultiInputCount.FindPropertyRelative("key").stringValue));
                    sv = Mathf.Max(0, sv);
                    PlayerPrefsElite.SetInt(KeyFormatter.GetSavedKey(maxMultiInputCount.FindPropertyRelative("key").stringValue),
                                            sv);
                }
            }

            serializedObject.ApplyModifiedProperties();
        }