Unity 在重播时将分数重置为 0

Question

Salutations. I have a working script that carries my game score over from level to level. The issue is that my replay level script does not reset to 0 but preserves the score from prior to reset. Suggestions on how to get the replay script to reset score to 0 without interfering with score carryover script would be greatly appreciated

Score Carryover Script

{
  
public static int scoreValue = 0;
Text score;

void Start()
{
    score = GetComponent<Text>();
    scoreValue = PlayerPrefs.GetInt("Player Score");
}

void Update()
{
    score.text = " " + scoreValue;
    PlayerPrefs.SetInt("Player Score", scoreValue);
}

}

Replay Level Script

{

public static int scoreValue = 0;
Text score;

public void RestartLevel()
{
    SceneManager.LoadScene(SceneManager.GetActiveScene().name);
    score = GetComponent<Text>();
    score.text = " " + 0;
    
}


public void Awake()
{
    Time.timeScale = 1;
    
}

Answer 1

Alright sorry just got home. There are a few issues that have been addressed in the comments. One issue that I am seeing is the constant use of PlayerPrefs.SetInt("Player Score", scoreValue); in an Update() function. Unless absolutely needed, I refrain from using any sort of Update() method as some of the methods called can computationally get rather heavy. With a smaller project, it is negligible, but after months of working on a project, something like this can bottleneck your project.

Aside from the nitpicky reason of not having this method in Update() , it very well could be the reason why the data is not resetting as it is setting it every frame. I did a little bit of rewriting to help you out a bit. I am going to employ the Singleton Pattern which some believe is bad, but I disagree. I find them very useful when used in proper situations and when they are not overused. To briefly and generally explain the Singleton Pattern, it is effectively a static instance of a class that is global so all other scripts can access it by accessing its instance. Think of it as a class that exists once and every other script can use it.

Firstly, create a new script called Singleton.cs and copy the code below. I stripped down the Unity implementation and commented it to be a little less confusing.

// from the Unity wiki
// http://wiki.unity3d.com/index.php/Singleton
// base class of a singelton pattern 
using UnityEngine;

/// <summary>
/// Inherit from this base class to create a singleton.
/// e.g. public class MyClassName : Singleton<MyClassName> {}
/// </summary>
public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    // Check to see if we're about to be destroyed.
    private static object m_Lock = new object();
    private static T m_Instance;

    /// <summary>
    /// Determines if this instance exists
    /// </summary>
    /// <returns></returns>
    public static bool HasInstance() { return m_Instance != null; }

    /// <summary>
    /// Access singleton instance through this propriety.
    /// </summary>
    public static T Instance
    {
        get
        {
            lock (m_Lock)
            {
                if (m_Instance == null)
                {
                    // Search for existing instance.
                    m_Instance = (T)FindObjectOfType(typeof(T));

                    // Create new instance if one doesn't already exist.
                    if (m_Instance == null)
                    {
                        // Need to create a new GameObject to attach the singleton to.
                        var singletonObject = new GameObject();
                        m_Instance = singletonObject.AddComponent<T>();
                        singletonObject.name = typeof(T).ToString() + " (Singleton)";

                        // Make instance persistent.
                        DontDestroyOnLoad(singletonObject);
                    }
                }

                return m_Instance;
            }
        }
    }
}

Now for the score carry over script . I changed it a bit to be a score manager. What this means is up to you, but the general idea of a manager is that it holds all data relating to whatever it is managing. In your case, it will manage, save, manipulate and display the score. Other scripts that need to access the score, change the score, etc. call it.

using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;

/// <summary>
/// Scoremanager that handles all score related functionality
/// </summary>
public class ScoreManager : Singleton<ScoreManager>
{
    [SerializeField] private Text score;
    private int scoreValue = 0;

    private void OnEnable()
    {
        SceneManager.sceneLoaded += NewSceneLoaded;
    }

    private void OnDisable()
    {
        SceneManager.sceneLoaded -= NewSceneLoaded;
    }

    /// <summary>
    /// Listen for when a new scene is loaded - set our score to the current player value
    /// </summary>
    /// <param name="scene"></param>
    /// <param name="mode"></param>
    public void NewSceneLoaded(Scene scene, LoadSceneMode mode)
    {
        // again just reusing the same function for less code rewriting
        AddScore(PlayerPrefs.GetInt("Player Score"));
    }

    /// <summary>
    /// Adds any given amount to our score, saves it and displays it to the user
    /// </summary>
    /// <param name="amount"></param>
    public void AddScore(int amount)
    {
        scoreValue += amount;
        UpdateScoreUI();
        PlayerPrefs.SetInt("Player Score", scoreValue);
    }

    public void ResetScore()
    {
        // nice trick to reset the score to 0 by negating the entire score
        // re-uses all of the other code as well to update UI and save the score to Player Prefs
        AddScore(-scoreValue);
    }

    /// <summary>
    /// Updates the UI of our score
    /// </summary>
    private void UpdateScoreUI()
    {
        score.text = "Score: " + scoreValue;
    }
}

As you can see, it is inheriting from the Singleton class meaning it can be called from anywhere in the project as long as the object exists in the scene. Make sure to place a ScoreManager in every scene. The other change is that I made the Text object a private field and Serialized it in the inspector. This just means other classes can not access it, but Unity will show it in the inspector so you can drag in your Text object into the script to get the reference set. One other note I will make is I am subscribing to the SceneManager delegate event of sceneLoaded which is called when the scene finishes loading. I am using it to initially set the UI and initialize your score properly.

Next is an example script that calls the ScoreManager to increase the score. It has an int that increases the score by some value I set in the inspector. You can attach this to any of the objects that change the score or, you can copy the one line that matters.

using UnityEngine;

/// <summary>
/// Example object that increases our score
/// </summary>
public class IncreaseScore : MonoBehaviour
{
    // the amount of score that this object gives when its IncScore is called
    [SerializeField] private int PointsWorth = 0;

    /// <summary>
    /// Increaes our score after some event - this example I am using a button to increase it
    /// whenever you click an enemy or object, etc. use the same function
    /// </summary>
    public void IncScore()
    {
        ScoreManager.Instance.AddScore(PointsWorth);
    }
}

Just to reiterate, the one line that changes the current score is this one: ScoreManager.Instance.AddScore(PointsWorth); . Change PointsWorth to whatever value you would like to change it by.

Finally, I revised your ReplayLevel a bit to assure that the score is reset to 0 when the ResetLevel function is called.

using UnityEngine;
using UnityEngine.SceneManagement;

public class ReplayLevel : MonoBehaviour
{
    public void Awake()
    {
        Time.timeScale = 1;
    }

    public void RestartLevel()
    {
        // reset our score as we are resetting the level
        PlayerPrefs.SetInt("Player Score", 0);
        SceneManager.LoadScene(SceneManager.GetActiveScene().name);
    }

    public void NewLevel()
    {
        SceneManager.LoadScene(SceneManager.GetActiveScene().name);
    }
}

Let me know if you have questions as this was quite a lot. I tested this myself as it was more involved and I have it locally working in a scene with a bunch of buttons just calling the functions.