objeto com referencia vazia

Boa tarde, gostaria de ajuda para descobrir e resolver um problema com objeto que ta retornando vazio. Estou adaptando um projeto antigo para mobile, e nessa versão ta dando esse problema que nao tinha antes:

Link do print

Codigo da missao da chave

Código:

[size=14]using System.Collections;
using System.Collections.Generic;
using UnityEngine;

// Adiciona automaticamente o closed dooor script
[RequireComponent(typeof(ClosedDoor))]
public class KeyMisson : InteractObject {

    // Armazena uma refernecia ao close door
    private ClosedDoor door;

    // Armazrna o id desta missão de chaves
    [Tooltip("O id deste missão de pegar uma chave, 1 diferente para cada em todo jogo")]
    public int id = 0;

    public Itens itensUI;

    private bool AlreadyGetMission
    {
        get
        {
            int result = PlayerPrefs.GetInt("keyMission-" + id, 0);

            if (result == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        set
        {
            int data = 0;

            if (value == true)
            {
                data = 1;
            }

            PlayerPrefs.SetInt("keyMission-" + id, data);
        }
    }

    // Use this for initialization
    void Start ()
    {
        itensUI = gameObject.GetComponent<Itens>();
        // Pega a referencia ao close door
        door = GetComponent<ClosedDoor>();

        if (AlreadyGetMission == false)
        {
            // Desativa o script da porta
            door.enabled = false;
        }
        else
        {
            // Remove o script da missão
            Destroy(this);
        }
    }
    
    // Update is called once per frame
    void Update () {
        
    }

    public override void Action(Player player)
    {
        if (AlreadyGetMission == false)
        {
            // Inicia missão
            SearchKeyObject.StartMission(id);

            // Define missão
            menssagesController.SetMissionMessage("Find the key");

            // Exibe a quantidade de chaves
            itensUI.GetComponent<Itens>().ChangeActive(Collectible.Key, true);

            // Ativa a porta
            door.enabled = true;

            // Desativa missão
            AlreadyGetMission = true;

            // Desativa este script
            this.enabled = false;
        }
    }
}
[/size]

codigo dos itens

Código:

[size=14]using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public enum Collectible
{
    Lamp,
    Key,
    Tool
}

public class Itens : MonoBehaviour
{
    public GameObject objectLamps, objectKeys, objectTools;

    // Propriedade para controlar exibião das chaves
    public static bool EnabledKeys
    {
        get
        {
            int result = PlayerPrefs.GetInt("itens-enabled-keys", 0);

            if (result == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        set
        {
            int data = 0;

            if (value == true)
            {
                data = 1;
            }

            PlayerPrefs.SetInt("itens-enabled-keys", data);
        }
    }

    public static bool EnabledTools
    {
        get
        {
            int result = PlayerPrefs.GetInt("itens-enabled-tools", 0);

            if (result == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        set
        {
            int data = 0;

            if (value == true)
            {
                data = 1;
            }

            PlayerPrefs.SetInt("itens-enabled-tools", data);
        }
    }

    void Start()
    {       
        UpdateText(Collectible.Lamp);
        UpdateText(Collectible.Key);
        UpdateText(Collectible.Tool);

        // Ativa ou desativa as chaves
        ChangeActive(Collectible.Key, Itens.EnabledKeys);

        ChangeActive(Collectible.Tool, Itens.EnabledTools);
    }

    public void ChangeActive(Collectible collectible, bool active)
    {   
        switch (collectible)
        {
            case Collectible.Key:
                Itens.EnabledKeys = active;
                objectKeys.SetActive(active);
                break;
            case Collectible.Tool:
                Itens.EnabledTools = active;
                objectTools.SetActive(active);
                break;
        }
    }

    public void UpdateText(Collectible collectible)
    {
        // Reserva espaço na memoria
        Text toUpdate;
        
        switch (collectible)
        {
            case Collectible.Lamp:
                // Pega o UI Text do "filho" do gameobject
                toUpdate = objectLamps.GetComponentInChildren<Text>();

                // Atualiza o texto
                toUpdate.text = Player.Lamps.ToString();

                // Sai do switch
                break;
            case Collectible.Key:
                toUpdate = objectKeys.GetComponentInChildren<Text>();

                toUpdate.text = Player.Keys.ToString();

                break;
            case Collectible.Tool:
                toUpdate = objectTools.GetComponentInChildren<Text>();

                toUpdate.text = Player.Tools.ToString();

                break;
        }
    }
}
[/size]

codigo do player

Código:

[size=14]using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

// Adiciona automaticamente Rigidbody2D
[RequireComponent(typeof(Rigidbody2D))]

// Adiciona automaticamente Animator
[RequireComponent(typeof(Animator))]
public class Player : MonoBehaviour {

    // Declara uma variavel - espaço na mémoria RAM para armazenar um tipo - do tipo Rigidbody2D.
    private Rigidbody2D rigbody;

    // Variavel do controllador de animação
    private Animator animator;

    private new Collider2D collider;

    // Contém o valor de todas as lampadas pegas no jogo inteiro (em todas as cenas)
    public static int Lamps
    {
        get
        {
            var lamps = PlayerPrefs.GetInt("playerLamps", -1);

            // Verifica se não há nenhum valor amazenado em "playerLamps"
            if (lamps == -1)
            {
                // Definir valor inicial
                lamps = 0;

                Player.Lamps = lamps;
            }

            return lamps;
        }
        private set
        {
            PlayerPrefs.SetInt("playerLamps", value);
        }
    }

    // Contém o valor de todas das chaves pegas no jogo inteiro (em todas as cenas)
    public static int Keys
    {
        get
        {
            var keys = PlayerPrefs.GetInt("playerKeys", -1);

            // Verifica se não há nenhum valor amazenado em "playerKeys"
            if (keys == -1)
            {
                // Definir valor inicial
                keys = 0;

                Player.Keys = keys;
            }

            return keys;
        }
        private set
        {
            PlayerPrefs.SetInt("playerKeys", value);
        }
    }

    public static int Tools
    {
        get
        {
            var tools = PlayerPrefs.GetInt("playerTools", -1);

            if (tools == -1)
            {
                // Definir valor inicial
                tools = 0;

                Player.Tools = tools;
            }

            return tools;
        }
        private set
        {
            PlayerPrefs.SetInt("playerTools", value);
        }
    }

    // Variavel do tipo SpriteReender chamada de sprite.
    private SpriteRenderer sprite;

    // Declara uma variavel para controlar a velocidade de movimentação
    public float speed = 2;

    // Variavel para armazenar possiveis objetos diponiveis para interagir
    public InteractObject interactObject;

    public Itens itemsUI;

    // variaavel que controla se o player está escondido ou não
    public bool escondido;

    public bool movingLeft = false;
    public bool movingRight = false;
    public Vector3 moveDirectionLeft = Vector3.left;
    public Vector3 moveDirectionRight = Vector3.right;
    
    // Método chamado na inicialização.
    void Start() {
        // Armazena uma referência ao componente Rigidbody2D deste GameObject
        rigbody = GetComponent<Rigidbody2D>();

        animator = GetComponent<Animator>();

        // Pega o componente SpriteReender que esta no player.
        sprite = GetComponent<SpriteRenderer>();

        movingLeft = false;
        movingRight = false;

        collider = GetComponent<Collider2D>();

        // Verifica se este GameObject contém um Collider.
        if (collider == null)
        {
            // Adiciona uma exceção ao Debug
            Debug.LogException(
                new System.Exception("Adicione um Collider ao GameObjeto " +
                "com o script \"Player\"."));
        }

        // Chama o método para carregar a posição do jogador.
        LoadPosition();
    }
    
    // Método Update é chamado 1 vez por frame
    void Update() {
        if (Pause.getPausado() == false) {
            if (escondido == false) {
                // Chama o método "Movement" a cada atualização
                //Movement();
                ButtonMovement();
            }

            //DoAction();
        }
    }

    void ButtonMovement()
    {
        if (movingLeft == true) {                      // LEFT BUTTON //
            animator.SetBool ("walk", true);// walk left
            transform.position += Vector3.left * 3.0f * Time.deltaTime;
            sprite.flipX = false;
        }  
        else if (movingLeft == false) {
            //speed = 0;
            animator.SetBool ("walk", false); // goes back to idle
        }


        if (movingRight == true) {                         // RIGHT BUTTON //
            animator.SetBool ("walk", true); // walks right
            transform.position += Vector3.right * 3.0f * Time.deltaTime;
            sprite.flipX = true;
        } 
        else if (movingLeft == false) {
            //speed = 0;
            animator.SetBool ("walk", false); // goes back to idle
        }
    }

    public void limitLD() { // UI Button Event trigger - pointUp
        movingLeft = false;
    }

    public void limitRD() { // UI Button Event trigger - pointUp
        movingRight = false;
    }


    public void MoveLeft() { // UI Button Event trigger - pointDown
        movingLeft = true;
        movingRight = false;
    }

    public void MoveRight() { // UI Button Event trigger - pointDown
        movingLeft = false;
        movingRight = true;
    }

    private void Movement()
    {
        float x = 0f, y = 0f;

        // Pegar das teclas (setas, joystick, A, D) para movimentar na horizontal
        x = Input.GetAxis("Horizontal");

        // Pegar das teclas (setas, joystick, W, S) para movimentar na vertical
        // Remove o "//" para permitir a movimentação em Vertical
        //y = Input.GetAxis("Vertical");

        // Passa para o walk a verificação se as teclas de movimentação foram pressionadas.
        animator.SetBool("walk", (x != 0));
        
        // Passa o valor de controle de direita esquerda, baseado nos valores da variavel "x"
        if (x > 0)
            animator.SetBool("right", true);
        else if (x < 0)
            animator.SetBool("right", false);

        // Declarei uma variavel para armazenar um novo vetor para armazenar informaçoes do movimento
        Vector2 movement = new Vector2(x, y);

        // Adicionar uma velocidade ao corpo
        rigbody.velocity = movement * speed;
    }

    public void ActionButton()
    {
        DoAction();
    }


    void DoAction()
    {
        // Verifica se há algum objeto de interação e se o botão de ação foi pressionado
        if (interactObject != null /* && Input.GetKeyDown(KeyCode.E) */)
        {
            // Manda o objeto de interação fazer sua ação
            interactObject.Action(this);
        }
    }

    // Método que carrega a posição do jogador da próxima cena.
    private void LoadPosition()
    {
        // Verifica se foi definido um posição para o jogador anteriormente.
        // Para tal, verificamos se o valor de "x" é diferente do padrão deifido como "-999999".
        // Isto é uma solução ruim, pois so funciona se na lógica do jogo nunca, houver uma posição 
        // valida de valor "-999999".
        if (PlayerPrefs.GetFloat("x", -999999) != -999999) {

            // Move o jogador para a posição definida.
            rigbody.transform.Translate(PlayerPrefs.GetFloat("x"), PlayerPrefs.GetFloat("y"), -1);

            // Verifica e define a direção do jogador.
            // if (PlayerPrefs.GetInt("right") == 1)
            //     animator.SetBool("right", true);
            // else
            //     animator.SetBool("right", false);

            // Depois de carregar apagar a posição definida para a próxima cena.
            PlayerPrefs.DeleteKey("x");
            PlayerPrefs.DeleteKey("y");
            //PlayerPrefs.DeleteKey("right");
        }
    }

    // Metodo que define a posição do jogador na próxima cena.
    public void SetLoadPosition(float x, float y)
    {
        // Define a posição do player usando as variaveis que foram passadas ao método.
        PlayerPrefs.SetFloat("x", x);
        PlayerPrefs.SetFloat("y", y);

        // Define a direção do player com base na direção atual.
        // O tipo int foi usado pois, não há um método padrão para valores booleanos (verdadeiro ou falso)
        // if (animator.GetBool("right")) 
        //     PlayerPrefs.SetInt("right", 1);
        // else
        //     PlayerPrefs.SetInt("right", 0);
    }

    public void AddLamp()
    {
        // Adiciona uma lampada
        Player.Lamps++; // -> Player.Lamps = Player.Lamps + 1;

        // Atualiza interface de items
        itemsUI.UpdateText(Collectible.Lamp);
    }

    // Método que tenta remover uma lampada do player se ele tiver.
    // Retorna:
    //      true -> caso o player tenha uma lampada e este foi retirada
    //      false -> caso o player não tenha uma lampada e não seja possível retirar
    public bool RemoveLamp()
    {
        if (Player.Lamps > 0)
        {
            // Remove uma lampa
            Player.Lamps--;

            // Atualiza interface de items
            itemsUI.UpdateText(Collectible.Lamp);

            return true;
        }
        else
        {
            // Não há lampadas, não faça nada
            return false;
        }
    }

    public void AddKey()
    {
        // Adiciona uma chave
        Player.Keys++; // -> Player.Keys = Player.Keys + 1;

        // Atualiza interface de items
        itemsUI.UpdateText(Collectible.Key);
    }

    // Método que tenta remover uma chave do player se ele tiver.
    // Retorna:
    //      true -> caso o player tenha uma chave e este foi retirada
    //      false -> caso o player não tenha uma chave e não seja possível retirar
    public bool RemoveKey()
    {
        if (Player.Keys > 0)
        {
            // Remove uma chave
            Player.Keys--;

            // Atualiza interface de items
            itemsUI.UpdateText(Collectible.Key);

            return true;
        }
        else
        {
            // Não há chaves, não faça nada
            return false;
        }
    }

    public void AddTool()
    {
        Player.Tools++;

        // Atualiza interface de items
        itemsUI.UpdateText(Collectible.Tool);
    }

    public bool RemoveTool()
    {
        if (Player.Tools > 0)
        {
            Player.Tools--;

            // Atualiza interface de items
            itemsUI.UpdateText(Collectible.Tool);

            return true;
        }
        else
        {
            return false;
        }
    }

    public void Hide()
    {
        if (escondido == true)
        {
            // Desesconde-se
            sprite.enabled = true;
            collider.isTrigger = false;
            rigbody.gravityScale = 1f;
            escondido = false;
        }
        else
        {
            // Esconde-se
            sprite.enabled = false;
            collider.isTrigger = true;
            rigbody.gravityScale = 0f;
            escondido = true;
        }
    }

    // Método para parar a movimentação do player
    public void StopMovement()
    {
        // Para a movimentação do player, para remover bug de andar e apartar "E"
        rigbody.velocity = Vector2.zero;
    }

    public void Death()
    {
        var audio = AudioManager.GetManager();

        if (audio != null)
        {
            audio.Stop();

            audio.audioSource.clip = audio.gameOver;

            audio.audioSource.loop = false;

            audio.Play();
        }
        
        // Carrega scena
        SceneManager.LoadScene ((int)Scenes.GameOver);
    }
}[/size]

Bom como próprio erro já diz referencia nula, na linha 81
que provavelmente é essa

Código:

itensUI.GetComponent<Itens>().ChangeActive(Collectible.Key, true);

então basicamente você esqueceu de setar alguma coisa