Unity、C#学习笔记一

最新推荐文章于 2024-08-13 10:21:03 发布

qq_35556613

最新推荐文章于 2024-08-13 10:21:03 发布

阅读量913

点赞数 1

文章标签： c# unity

本文链接：https://blog.youkuaiyun.com/qq_35556613/article/details/127468097

版权

一、Unity Input System

1.导入input system组件

2.创建InputAction文件——用来配置所有输入动作的文件

3.创建动作表（可根据不同阶段创建相应输入动作），添加Action并设置动作的类型，添加相应设备的输入动作绑定

4.资产栏点击inputaction自动生成C#脚本

5.生成的InputactionC#脚本末尾为创建的动作表接口

6.新建C#脚本——PlayerInput

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Events;


[CreateAssetMenu(menuName ="Player input")]  //2.一个attribute（属性 ）：标记一个scriptableobject派生的类型，
                   //以便在Assets/Create子菜单中自动列出，
                   //这样类型的实例就可以很容易地创建并存储在项目中为“。资产”文件。

public class PlayerInput : ScriptableObject,PlayerInputAction.IGamePlayActions
{//1.ScriptableObject不需要附加到游戏对象上的对象,继承Playerinputaction接口（即为inputsystem生成的脚本中我们自定义动作的接口类
    PlayerInputAction playerinputaction;//3.0
    
    //10.创建一个事件,并在下面OnMove函数中调用
    public event UnityAction<Vector2> onMove=delegate { };   //UnityAction实际是一个委托。也可用System.Action并引入命名空间;

    //注10：Inputaction（即我重命名的PlayerInputAction）的原理：输入动作是一个由输入信号所触发的事件
    //过程为我按下键盘按键，就输入了一个信号

    //委托：C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。
    //      委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。
    //      委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。

    //C#事件：事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，
    //或者是一些提示信息，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。
    //C# 中使用事件机制实现线程间的通信。
    //事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。
    //标准事件的用法：在使用事件的时候我们还应该先确认事件是否为空值，也可直接给一个空值委托，使其用不为空
   
    public event  UnityAction onStopMove=delegate{};//13.创建停止动作事件

    void OnEnable()//4.0
    {

        playerinputaction = new PlayerInputAction();  //4.1初始化playerinputaction类的引用
        //注释3.0，4.1：A a = new A（）是为了给a分配内存空间，new的意思是在内存空间中按照类型A分配一块空间，
        //这块空间的指针赋给a，既是给a分配内存。没有这句话的话，
        //例如A a = b这样的赋值语句只是把b的内存地址赋给a，两者使用同一内存空间，
        //但a没有实际分配内存，a的值改变，b有可能随之改变。如果A a = new A（）；
        //A a = b是将b的值赋给a，但a，b使用各自的内存空间，a改变，b不变。

        playerinputaction.GamePlay.SetCallbacks(this);//5.登记gameplay动作表的回调函数
       //创建型的动作表也要在这里更新它的回调函数
    }

    //6.创建一个public函数，让其他的类能在需要的时候启用gameplay动作表
    public void EnableGameplayInput()
    {
        playerinputaction.GamePlay.Enable();
        //7.同时我们希望操作玩家角色时，也就是启用gameplay动作表时，把鼠标的游标隐藏
        Cursor.visible = false;
        Cursor.lockState = CursorLockMode.Locked;//鼠标的锁定状态为锁定
    }

    //8.创建一个public函数，让其他的类能在需要时，禁用所有输入(如过场动画
    public void DisableAllInputs()
    {
        playerinputaction.GamePlay.Disable();//8.1动作表不起用
    }

    void OnDisable()//9.对象变为禁用时调用此函数
    {
        DisableAllInputs();
    }
    public void OnMove(InputAction.CallbackContext context)
    {
        //11.Inout Action Phase输入动作阶段
        if (context.phase == InputActionPhase.Performed)  
        {   
            //事件调用函数
            onMove.Invoke(context.ReadValue<Vector2>());//12.由于Move输入操作读取的是二位向量，
                                                        //所以事件应有Vector2的参数，
        }
        if (context.phase == InputActionPhase.Canceled)   //14.停止移动触发函数
        {
            onStopMove.Invoke();   
        }

        //输入动作阶段：DIsable动作表被禁用的时候Waiting
        //动作表被启用但没有相应的输入信号传入的时候
        //Started按下按键的那一帧
        //performed输入动作已执行的阶段包含按下按键和按住案件俩个阶段
        //Canceled输入信号停止的时候即松开按键的的那一帧
    }


}

7.在资产栏为PlayerInput脚本创建ScriptObject，方便以后使用

8.创建Player类脚本

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Player : MonoBehaviour   //玩家类
{
    [SerializeField] PlayerInput input;  //声明一个PlayerInput类
    Rigidbody2D rb;
    public float moveSpeed = 10.0f;
    private void OnEnable()
    {
        input.onMove += Move;
        input.onStopMove += StopMove;
    }
    private void OnDisable()
    {
        input.onMove -= Move;
        input.onStopMove -= StopMove;

    }
    void Move(Vector2 moveInput)  //移动事件处理函数 MovementEventHandleFunction
    {
        Vector2 moveAmount = moveSpeed * moveInput;
        rb.velocity = moveAmount;
    }
    void StopMove()
    {
        rb.velocity = Vector2.zero;
    }
     void Awake()
    {
        rb = GetComponent<Rigidbody2D>();
    }
    void Start()
    {
        rb.gravityScale = 0f; //修改刚体的重力
        input.EnableGameplayInput(); //激活gameplay动作表输入
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

9.为player对象挂载脚本和刚体组件

二、C#知识

1.委托

C# 委托（Delegate）

C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。

声明委托（Delegate）

委托声明决定了可由该委托引用的方法。委托可指向一个与其具有相同标签的方法。

例如，假设有一个委托：

public delegate int MyDelegate (string s);

上面的委托可被用于引用任何一个带有一个单一的 string 参数的方法，并返回一个 int 类型变量。

声明委托的语法如下：

delegate <return type> <delegate-name> <parameter list>

实例化委托（Delegate）

一旦声明了委托类型，委托对象必须使用 new 关键字来创建，且与一个特定的方法有关。当创建委托时，传递到 new 语句的参数就像方法调用一样书写，但是不带有参数。例如：

public delegate void printString(string s);
...
printString ps1 = new printString(WriteToScreen);
printString ps2 = new printString(WriteToFile);

下面的实例演示了委托的声明、实例化和使用，该委托可用于引用带有一个整型参数的方法，并返回一个整型值。

实例

using System;

delegate int NumberChanger(int n);
namespace DelegateAppl
{
class TestDelegate
{
  static int num = 10;
  public static int AddNum(int p)
  {
num += p;
return num;
  }

  public static int MultNum(int q)
  {
num *= q;
return num;
  }
  public static int getNum()
  {
return num;
  }

  static void Main(string[] args)
  {
// 创建委托实例
NumberChanger nc1 = new NumberChanger(AddNum);
NumberChanger nc2 = new NumberChanger(MultNum);
// 使用委托对象调用方法
nc1(25);
Console.WriteLine("Value of Num: {0}", getNum());
nc2(5);
Console.WriteLine("Value of Num: {0}", getNum());
Console.ReadKey();
  }
}
}

当上面的代码被编译和执行时，它会产生下列结果：

Value of Num: 35
Value of Num: 175

个人总结：声明委托，根据委托的参数，需要选择具有相同形参的方法，来实例化（new）委托，也就相当于创建了对该方法的引用。

链接：https://www.runoob.com/csharp/csharp-delegate.html

2.事件

C# 事件（Event）

事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些提示信息，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。

C# 中使用事件机制实现线程间的通信。

通过事件使用委托

事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。包含事件的类用于发布事件。这被称为 发布器（publisher） 类。其他接受该事件的类被称为 订阅器（subscriber） 类。事件使用 发布-订阅（publisher-subscriber） 模型。

发布器（publisher） 是一个包含事件和委托定义的对象。事件和委托之间的联系也定义在这个对象中。发布器（publisher）类的对象调用这个事件，并通知其他的对象。

订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。

声明事件（Event）

在类的内部声明事件，首先必须声明该事件的委托类型。例如：

public delegate void BoilerLogHandler(string status);

然后，声明事件本身，使用 event 关键字：

// 基于上面的委托定义事件
public event BoilerLogHandler BoilerEventLog;

上面的代码定义了一个名为 BoilerLogHandler 的委托和一个名为 BoilerEventLog 的事件，该事件在生成的时候会调用委托。

个人总结：发布器（publisher） 是一个包含事件和委托定义的对象，也即是一个已实例化的类，未实例化还不能称之为发布器。订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。委托调用的订阅器（subscriber）类中的方法就是事件处理程序。

注：类是一个数据类型的蓝图（即架构的一个抽象的还未实现的蓝图）

对象是类的实例，构成类的方法和变量称为类的成员数据

事件只是对委托的进行包装的容器，用来防止外界滥用委托中的方法

订阅的过程即是选择某个类（订阅器）的方法传递给事件，进而给委托进行实例化防止外界任意调用委托？？

事件订阅的2种方式：

01.eventname +=进行事件处理的方法；

02.eventname +=new 委托（事件处理的方法）；//即+=委托的实例化

链接： https://www.bilibili.com/video/av26891611/?p=23&vd_source=cd77f29c920fe031e2b46c16d795f999 链接：https://www.runoob.com/csharp/csharp-event.html