Example #1
0
 public static void DeleteInt(string key)
 {
     key = string.Format(KeyFormat, "int", key);
     PlayerPrefs.DeleteKey(key);
 }
Example #2
0
 public static void DeleteString(string key)
 {
     key = string.Format(KeyFormat, "string", key);
     PlayerPrefs.DeleteKey(key);
 }
Example #3
0
 public static void Remove(string key)
 {
     PlayerPrefs.DeleteKey(key);
 }
Example #4
0
    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);
    }
Example #5
0
 public void DeleteKey(string name)
 {
     PlayerPrefs.DeleteKey(name);
     PlayerPrefs.Save();
 }
Example #6
0
 public void ClearHighscores()
 {
     PlayerPrefs.DeleteKey("Highscore");
     HighScore.text = "No High Scores Yet";
 }
Example #7
0
 void OnApplicationQuit()
 {
     PlayerPrefs.DeleteKey("myID");
 }
Example #8
0
 // 清除存檔
 public void ClearSave()
 {
     Clear();
     PlayerPrefs.DeleteKey(GameDefine.szSavePickup);
 }
 public void Clear()
 {
     this.userData = null;//new UserSaveDataFormat ();
     PlayerPrefs.DeleteKey(KEY_USER);
     this.dataExist = false;
 }
Example #10
0
    void OnGUI()
    {
        if (generator == null)
        {
            return;
        }
        GUI.enabled = usingLatestConfig;// && !character.animation.IsPlaying("walkin");
        GUILayout.BeginArea(new Rect(10, 10, typeWidth + 2 * buttonWidth + 8, 500));

        // Buttons for changing character elements.
        AddCategory("head", "Head", null);
        AddCategory("torso", "Torso", null);
        AddCategory("pants", "Pants", null);
        AddCategory("boots", "Boots", null);

        // Buttons for saving and deleting configurations.
        // In a real world application you probably want store these
        // preferences on a server, but for this demo configurations
        // are saved locally using PlayerPrefs.
        if (GUILayout.Button("Save Configuration"))
        {
            PlayerPrefs.SetString(prefName, generator.GetConfig());
        }

        if (GUILayout.Button("Delete Configuration"))
        {
            PlayerPrefs.DeleteKey(prefName);
        }

        // Show download progress or indicate assets are being loaded.
        GUI.enabled = true;
        if (!usingLatestConfig)
        {
            float  progress = generator.CurrentConfigProgress;
            string status   = "Loading";
            if (progress != 1)
            {
                status = "Downloading " + (int)(progress * 100) + "%";
            }
            GUILayout.Box(status);
        }

        defaultRotate = GUILayout.Toggle(defaultRotate, "Default Rotation");

        GUILayout.Box("Max. Players (4)");

        maxPlayers = GUILayout.TextField(maxPlayers, GUILayout.Width(30));

        if (GUILayout.Button(buttonString, GUILayout.Width(100)))
        {
            if (!searchingRoom)
            {
                buttonString  = "Cancel";
                searchingRoom = true;

                PlayerStats.config = generator.GetConfig();

                if (SmartFoxConnection.hasConnection)
                {
                    SearchForRooms();
                }
                else
                {
                    StartCoroutine(SceneChanger.ChangeScene("Baskin-Arena"));
                }
            }
            else
            {
                buttonString  = "Play";
                searchingRoom = false;

                if (SmartFoxConnection.hasConnection)
                {
                    CancelRoomSearch();
                }
            }
        }

        GUILayout.EndArea();
    }
Example #11
0
 public void RestartGame() {
     PlayerPrefs.DeleteKey("latestStage");
     GameState.LoadLatestStage();
 }