C# Unity3d新输入系统（2.8），can'；t在编辑器中引用输入操作

我刚刚将新的输入系统从2.7升级到2.8

新输入系统的工作原理是通过进入create->Input actions创建输入操作资产

这将创建一个可以将操作映射到关键点的资源。然后从这个资源创建一个C#脚本，并在代码中使用它。我就是这么做的。我调用了资产

MyInput.inputations

，而C#脚本是

MyInput.cs

以这种方式使用生成的C#脚本时，需要在脚本中引用资产。然而，在更新之后，从编辑器看来这是不可能做到的。当我在类中定义一个public

MyInput

变量时，如下所示：

public class ShapeMover: MonoBehaviour
{
    public MyInput controls;

    private       float        _lastFallTime;
    private       float        _fallSpeed;
    private       ShapeSpawner _spawn;
    private       GameObject   _shapeToMove;
    private       Transform    _shapeToMoveTransform;
    private       bool         _isGameOver;
    private const float        _leftRotationAngle  = (float) -1.57079633;
    private const float        _rightRotationAngle = (float) 1.57079633;
}

它不会暴露在检查员的视野中：

当我试图访问

控件

变量时，我得到了一个明显的

NullReferenceException

错误

我做错什么了吗

如何从检查员处引用资产？我尝试将

[SerializeField]

添加到公共声明中，但没有任何帮助

我一直在关注视频，直到我升级到一个新的输入系统版本，它才开始工作

作为参考，这是完整的ShapeMover类：

using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

namespace _Scripts
{
    public class ShapeMover : MonoBehaviour
    {
        [SerializeField]
        public MyInput controls;

        private       float        _lastFallTime;
        private       float        _fallSpeed;
        private       ShapeSpawner _spawn;
        private       GameObject   _shapeToMove;
        private       Transform    _shapeToMoveTransform;
        private       bool         _isGameOver;
        private const float        _leftRotationAngle  = (float) -1.57079633;
        private const float        _rightRotationAngle = (float) 1.57079633;


        private void Awake()
        {
            _spawn        = FindObjectOfType<ShapeSpawner>();
            _lastFallTime = 0f;
            _fallSpeed    = GameGrid.Instance.GetFallSpeed();
            _isGameOver   = false;

            Debug.Log("Registering controls callbacks...");
            controls.Player.Movement.performed += ctx => Movement(ctx.ReadValue<Vector2>(), true);
            controls.Player.Drop.performed     += ctx => Drop();
            controls.Menu.Reset.performed      += ctx => Restart();
            controls.Menu.Pause.performed      += ctx => PauseToggle();
            SetShapeToMove();
        }

        private void Restart()
        {
            GameGrid.Instance.ResetGame();
            _isGameOver = false;
            SetShapeToMove();
        }


        private void PauseToggle()
        {
            Debug.Log("Got Pause input");
            var currentPauseState = GameGrid.Instance.IsPaused;
            //If not paused, will pause
            if (!currentPauseState)
            {
//                controls.Player.Movement.Disable();
//                controls.Player.Drop.Disable();
//                controls.Player.Menu.Disable();
//                controls.Player.Disable();
                GameGrid.Instance.IsPaused = true;
            }
            else
            {
//                controls.Player.Movement.Enable();
//                controls.Player.Drop.Enable();
//                controls.Player.Menu.Enable();
//                controls.Player.Enable();
                GameGrid.Instance.IsPaused = false;
            }
        }

        private void Drop()
        {
//            Debug.Log("Should Drop Shape!");
            bool didMove = true;
            while (didMove)
            {
                didMove = Movement(new Vector2(0, -1), false);
            }
        }

        private bool Movement(Vector2 direction, bool isFromInput)
        {
            if (isFromInput)
            {
                Debug.Log($"Got input {direction.ToString()}");
            }

            //Disable movement controls when game is over.
            if (_isGameOver)
            {
                return false;
            }

            var oldPosition = _shapeToMoveTransform.position;
            var oldRotation = _shapeToMoveTransform.rotation;
//            Transform[] children       = _shapeToMoveTransform.Cast<Transform>().ToArray();
            var didMove        = true;
            var didEndMovement = false;

            GameGrid.Instance.RemoveShapeFromGrid(_shapeToMoveTransform);

            if (direction.x < 0)
            {
                didMove = MoveLeft();
            }
            else if (direction.x > 0)
            {
                didMove = MoveRight();
            }
            else if (direction.y > 0)
            {
                didMove = RotateLeft();
            }
            else if (direction.y < 0)
            {
                didMove = MoveDown();

                if (!didMove)
                {
                    didEndMovement = true;
                }
            }

            //If Shape didn't move, restore previous position.
            if (!didMove)
            {
                _shapeToMoveTransform.position = oldPosition;
                _shapeToMoveTransform.rotation = oldRotation;
            }

            GameGrid.Instance.AddShapeToGrid(_shapeToMoveTransform);

//            Debug.Log($"Shape {_shapeToMove.name} Position after movement Did Move: {didMove.ToString()}");

//            Transform[] children = _shapeToMoveTransform.Cast<Transform>().ToArray();

//            var lowestChild = children.OrderBy(x => x.position.y).First();

//            Debug.Log($"{lowestChild.position.ToString()}");

            if (didEndMovement)
            {
                GameGrid.Instance.ClearRows(_shapeToMoveTransform);
                _isGameOver = GameGrid.Instance.IsGameOver(_shapeToMoveTransform);
                if (!_isGameOver)
                {
                    SetShapeToMove();
                }
            }

            return didMove;
        }

        private void SetShapeToMove()
        {
            _shapeToMove          = _spawn.SpawnShape();
            _shapeToMoveTransform = _shapeToMove.transform;
        }

        private void Update()
        {
            if (_isGameOver)
            {
                return;
            }

            if (GameGrid.Instance.IsPaused)
            {
                return;
            }


            var time = Time.time;
            if (!(time - (_lastFallTime + _fallSpeed) > 0))
            {
                return;
            }

            Movement(new Vector2(0, -1), false);
            _lastFallTime = time;
            _fallSpeed    = GameGrid.Instance.GetFallSpeed();
        }


        private bool MoveLeft()
        {
            _shapeToMoveTransform.position += Vector3.right;
            return GameGrid.Instance.CanMove(_shapeToMoveTransform);
        }

        private bool MoveRight()
        {
            _shapeToMoveTransform.position += Vector3.left;
            return GameGrid.Instance.CanMove(_shapeToMoveTransform);
        }

        private bool MoveDown()
        {
            _shapeToMoveTransform.position += Vector3.down;
            return GameGrid.Instance.CanMove(_shapeToMoveTransform);
        }


        private bool RotateLeft()
        {
            _shapeToMoveTransform.Rotate(0, 0, -90);
//            foreach (Transform child in _shapeToMoveTransform)
//            {
//                RotateTransform(child, _leftRotationAngle);
//            }

            return GameGrid.Instance.CanMove(_shapeToMoveTransform);
        }

        private void RotateTransform(Transform transformToRotate, float rotationAngleRadian)
        {
            var currentLocalPosition = transformToRotate.localPosition;
            var currentX             = currentLocalPosition.x;
            var currentY             = currentLocalPosition.y;

            var rotatedX = currentX * Mathf.Cos(rotationAngleRadian) - currentY * Mathf.Sin(rotationAngleRadian);
            var rotatedY = currentX * Mathf.Sin(rotationAngleRadian) + currentY * Mathf.Cos(rotationAngleRadian);

            transformToRotate.localPosition = new Vector2(rotatedX, rotatedY);
//            Debug.Log($"Position after rotation is: {transformToRotate.localPosition.ToString()}");
        }

        private bool RotateRight()
        {
            _shapeToMoveTransform.Rotate(0, 0, -90);
            return GameGrid.Instance.CanMove(_shapeToMoveTransform);
        }

        private void OnEnable()
        {
            Debug.Log("Controls Enabled...");
            controls.Enable();
        }

//        private void OnDisable()
//        {
//            Debug.Log("Controls Disabled...");
//            controls.Disable();
//        }
    }
}

使用System.Collections.Generic；
使用System.Linq；
使用UnityEditor；
使用UnityEngine；
使用UnityEngine.SceneManagement；
使用UnityEngine.UI；
名称空间脚本
{
公共类ShapeMover：单行为
{
[序列化字段]
公共输入控制；
私人浮动时间；
私人浮动(fallSpeed);；
私人形状喷枪(产卵),；
私有游戏对象_shapeToMove；
私有变换_shapeToMoveTransform；
私人布卢伊斯加莫弗；
私有常量float _leftRotationAngle=（float）-1.57079633；
私有常量float _rightRotationAngle=（float）1.57079633；
私人空间
{
_spawn=FindObjectOfType（）；
_lastFallTime=0f；
_fallSpeed=GameGrid.Instance.GetFallSpeed（）；
_isGameOver=false；
Log（“注册控件回调…”）；
controls.Player.Movement.performed+=ctx=>Movement（ctx.ReadValue（），true）；
controls.Player.Drop.performed+=ctx=>Drop（）；
controls.Menu.Reset.performed+=ctx=>Restart（）；
controls.Menu.Pause.performed+=ctx=>pauseTogle（）；
SetShapeToMove（）；
}
私有void Restart（）
{
GameGrid.Instance.ResetGame（）；
_isGameOver=false；
SetShapeToMove（）；
}
私有无效暂停切换（）
{
Log（“获得暂停输入”）；
var currentPauseState=GameGrid.Instance.IsPaused；
//如果没有暂停，将暂停
如果（！currentPauseState）
{
//controls.Player.Movement.Disable（）；
//controls.Player.Drop.Disable（）；
//controls.Player.Menu.Disable（）；
//controls.Player.Disable（）；
GameGrid.Instance.IsPaused=true；
}
其他的
{
//controls.Player.Movement.Enable（）；
//controls.Player.Drop.Enable（）；
//controls.Player.Menu.Enable（）；
//controls.Player.Enable（）；
GameGrid.Instance.IsPaused=false；
}
}
私人空投（）
{
//Log（“应该下降形状！”）；
bool-didMove=true；
while（didMove）
{
didMove=移动（新向量2（0，-1），false）；
}
}
专用布尔移动（矢量2方向，布尔来自输入）
{
如果（isFromInput）
{
Log（$“获取输入{direction.ToString（）}”）；
}
//游戏结束时禁用移动控制。
如果（_isGameOver）
{
返回false；
}
var oldPosition=_shapeToMoveTransform.position；
var oldRotation=_shapeToMoveTransform.rotation；
//Transform[]children=_shapeToMoveTransform.Cast（）.ToArray（）；
var didMove=true；
var didEndMovement=假；
GameGrid.Instance.RemoveShapeFromGrid（_shapeToMoveTransform）；
如果（方向x<0）
{
didMove=MoveLeft（）；
}
如果（方向x>0），则为else
{
didMove=MoveRight（）；
}
如果（方向y>0），则为else
{
didMove=RotateLeft（）；
}
否则如果（方向y<0）
{
didMove=MoveDown（）；
如果（！didMove）
{
双端运动=真；
}
}
//如果形状未移动，请恢复以前的位置。
如果（！didMove）
{
_shapeToMoveTransform.position=旧位置；
_shapeToMoveTransform.rotation=旧旋转；
}
GameGrid.Instance.AddShapeToGrid（_shapeToMoveTransform）；
//Log（$“Shape{u shapeToMove.name}移动后的位置确实移动：{didMove.ToString（）}”）；
//Transform[]children=_shapeToMoveTransform.Cast（）.ToArray（）；
//var lowestChild=children.OrderBy（x=>x.position.y）.First（）；
//Log（$“{lowestChild.position.ToString（）}”）；
如果（双端运动）
{
GameGrid.Instance.ClearRows（_shapeToMoveTransform）；
_isGameOver=GameGrid.Instance.isGameOver（_shapeToMoveTransform）；
如果（！\u isGameOver）
private MyInput _inputs;

public void Awake()
{
    _inputs = new MyInput();
}

public class ShapeMover : MonoBehaviour, MyInput.IPlayerActions
{
    private MyInput _inputs;

    public void Awake()
    {
        _inputs = new MyInput();
        _inputs.Player.SetCallbacks(this);
    }

    public void OnEnable()
    {
        _inputs.Player.Enable();
    }

    public void OnDisable()
    {
        _inputs.Player.Disable();
    }

    public void OnMovement(InputAction.CallbackContext context)
    {
        Vector2 delta = context.ReadValue<Vector2>();
        transform.position += new Vector3(delta.x, 0, delta.y);
    }

    public void OnDrop(InputAction.CallbackContext context)
    {
        //TODO
    }

    // ...
}