Comment accéder aux variables singleton avec un clic et ne pas provoquer d'exception NullReferenceException

Modifiez votre code sur cette ligne

private static Player e;

public static Player E
{
    get
    {
       if(e==null) 
        {
              e= new Player() ;
        } 
       return e;
   } 
    set
    {
      e=value;
    } 
} 

Avec ce code

static public Player E;

Cela ressemble plus à une question Unity / Monobehavior qu'à une question C #. Awake est déclenché avant le début du jeu, une seule fois. Il peut être traité comme un initialiseur.

Comme vous avez un E public, vous devez lui fournir une instance: en ajoutant un objet dans l'interface Unity IDE (glisser-déposer) ou par code.

Vous pouvez également utiliser des balises à la place. Vous trouverez ici plus d'informations sur la façon de procéder: https://docs.unity3d.com/ScriptReference/MonoBehaviour.Awake.html

J'irais avec une propriété d'initialisation paresseuse mais si vous voulez vraiment que ce soit un Singleton, cela devrait ressembler à

Player.EA = i;

Ensuite, notez que je ne ferais pas cela dans Mettre à jour (chaque cadre)

public static class Player
{
    private static int _ea = 5;
    private static int _eg = 0;

    public static int EA
    {
        get => _ea;
        set
        {
            _ea = value;
            if (_eg >= 5 && _ea >= 0) _eg = 0;          
            if (_ea <= 4 && _eg > 9) _ea = 5;
        }
    }

    public static int EG
    {
        get => _eg;
        set
        {
            _eg = value;
            if (_eg >= 5 && _ea >= 0) _eg = 0;
            if (_ea <= 4 && _eg > 9) _ea = 5;
        }
    }
}

Définissez plutôt EA et EG également des propriétés et faites le cocher uniquement lorsque vous modifiez réellement la valeur:

Player.E.EA = i;

Maintenant, chaque fois que vous définissez l'une de ces valeurs via par exemple

private int _ea = 5;
private int _eg = 0;

public int EA
{
    get => _ea;
    set
    {
        _ea = value;
        if (_eg >= 5 && _ea >= 0) _eg = 0;
        if (_ea <= 4 && _eg > 9) _ea = 5;
    }
}

public int EG
{
    get => _eg;
    set
    {
        _eg = value;
        if (_eg >= 5 && _ea >= 0) _eg = 0;      
        if (_ea <= 4 && _eg > 9) _ea = 5;
    }
}

le setter correspondant est exécuté et vos champs de sauvegarde mis à jour en fonction des événements.

Et maintenant, oui maintenant, il est douteux que vous ayez même besoin de cela comme MonoBehaviour ... en fait vous n'avez même pas besoin d'une instance et donc pas du tout de Singleton!

void Update()
{
    if (EG >= 5 && EA >= 0)
    {
        EG = 0;
    }
    if (EA <= 4 && EG > 9)
    {
        EA = 5;
    }
}

Cela n'a pas besoin d'être attaché à quoi que ce soit dans la scène mais c'est une classe statique qui "vit" simplement pour toute la session dès que l'application est lancée.

Maintenant, lisez et attribuez simplement par exemple

private static Player _instance;
public static Player E
{
    get
    {
        // if already exists return it directly
        if(_instance) return _instance;

        // otherwise find it in the scene
        _instance = FindObjectOfType<Player>();

        // if found return it
        if(_instance) return _instance;

        // otherwise create it now
        // note that anything you have to configure via the Inspector
        // will not be there so you would need to find another way to 
        // initialize all values
        _instance = new GameObject ("Player").AddComponent<Player>();

        return _instance;
    }
}

private void Awake()
{
    if(_instance && _instance != this)
    {
        // another instance already exists!
        Destroy (gameObject);
        return;
    }

    _instance = this;
}

Remarque générale:

Noms tels que E , E Un et un EG doivent être évités! Utilisez des noms plus descriptifs! Il faut savoir ce qu'est ment et ce que représente une valeur en regardant simplement le nom. Ces raccourcis vous causeront des ennuis tôt ou tard. Si vous regardez votre code 6 mois plus tard, vous ne saurez plus ce que EA ment dans votre tête;)