devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity3D RPG实现 3 —— 对话、任务系统_unity任务系统

作者：笔触狂放9 | 2024-02-16 04:26:37

赞

踩

unity任务系统

目录

成果展示

对话系统

对话的存储数据结构

对话的UI面板设置

创建对话&任务的 NPC

实现对话控制器显示主对话窗口的内容

创建对话的选项内容

任务系统

创建任务 UI 面板

 任务的存储数据结构

任务管理器与接受任务

任务控制相关脚本

实现点按任务显示信息

接受任务时检查任务物品是否契合

根据完成情况控制任务对话分支

拿到任务奖励

保存任务数据

代码汇总

背包部分

Dialogue部分

任务部分

成果展示

对话系统

对话的存储数据结构

一个对话框需要什么呢？我们先来想想：

首先需要一个字符串，表示内容，

为了方便对话间的跳转，我们还需要给每个对话唯一标识，因此需要ID

对话是由人说的，我们还需要人物头像

具体如下：

首先需要一个对话信息：

数据如下：含有当前对话的id、头像、文本以及选项

  1. [System.Serializable]
  2. public class DialoguePiece {
  3.     public string ID;
  4.     public Sprite image;
  5.     public string text;
  6.  
  7.     public List<DialogueOption> options = new List<DialogueOption>();
  8.  
  9.  
  10. }

另一方面，每个对话可能会有选项，每个选项本身也有内容，并且一些选项可能意味着是否要接取任务，以及选择选项后，我们需要跳转到不同的对话，于是需要一个targetID

于是选项的数据结构如下：

  1. [System.Serializable]
  2. public class DialogueOption 
  3. {   
  4.     public string text;
  5.     public string targetID;
  6.     public bool takeQuest;
  7. }

我们将所有的对话信息存储在SO中，因此：

  1. [CreateAssetMenu(fileName ="New Dialogue",menuName ="Dialogue/Dialogue Data")]
  2. public class DialougeData_SO : ScriptableObject
  3. {
  4.  
  5.     public List<DialoguePiece> dialoguePieces = new List<DialoguePiece>();
  6. }

此时完整的一个对话SO如下：

完整的数据结构如下

逻辑：在Dialogue Data中有若干个piece，每个piece中有若干个ID、Text、Image和Quest，还包含有List<Option>

如果有Option，我们就通过获取其Target ID。

对话的UI面板设置

创建一个面板：

设定Panel 

添加vertical layout Group：

添加对话框还有按钮并设定其位置：

再添加一个头像：

在这种情况下， 如果有button有text的话，布局就会比较乱，因此此处将头像图片放在Main Text下，并且锚点放在左边，这样锚点就是在对话框的左边了。

接下来还需要给Dialogue Panel添加verticalLayoutGroup，这样子物体才可以使用content size filter。

此时头像的图片是以文字为基准点，所以就在对话框的外面了：

这样可以使得按钮在比较靠右的位置。

为了使其能在竖直方向上拉伸：

然后在DialoguePanel和Main Text中都添加content Size Fitter

这样就可以根据文本数量的多少改变框的大小。

问题在于字少的时候，头像会超出位置。

设定一个最小高度即可：

记得给文字设定居中：

给Button设定如下选项：

接下来为选择面板添加Button：

将按钮拉长，并选择居于右部，就会发现此时Button位于右边。

选择text，改变其对话框长度：

多复制几个按钮，并将面板透明度设置为0：

创建对话&任务的 NPC

导入素材后，要将场景素材升级到URP

别忘记添加基本的必要组件

  • 自己单独创建 Animator Controller 只添加一个 Idle 动画即可
  • 修改 Tag 及 Layer
  • 将这个人物保存成 Original Prefab 在你的文件夹中

实现对话控制器显示主对话窗口的内容

接下来实现在对话框中显示显示对话内容的效果。

首先要先将之前创建的UI的那些组件用脚本控制：

（UpdateDialogueData是用于根据传入的对话信息进行更新的函数，后续会补充完整）

  1. public class DialogueUI : Singleton<DialogueUI>
  2. {
  3.     [Header("Basic Elements")]
  4.     public Image icon;
  5.     public Text mainText;
  6.     public Button nextButton;
  7.  
  8.     public GameObject dialoguePanel;
  9.  
  10.     [Header("Data")]
  11.     public DialougeData_SO currentData;
  12.     int currentIndex = 0;
  13.     
  14.     public void UpdateDialogueData(DialougeData_SO data)
  15.     {
  16.         currentData = data;
  17.         currentIndex = 0;
  18.     }
  19.  
  20. }

 把那些栏拖拽到里面

给NPC 添加 DialogueController 脚本，用于控制对话

当触发和npc的对话，打开对话面板时，我们就要传给对话UI面板给对话数据：

以一个简单的例子：

进行赋值

具体根据对话数据存储的头像，对话语句进行更新

如果对话数据不止一条对话内容，则我们可以继续往下更新对话

这样即可实现点击进入下一行对话，没有对话时面板消失。

创建对话的选项内容

将Button作为预制体：

创建对话的选项OptionUI的脚本，并用该脚本控制选项的组件:

为了实现在对话里生成选项，首先得为选项单独创建一个面板，并在脚本中获取选项所在的Panel及脚本：

因为对话会切换，所以选项也需要生成与销毁

接下来实现选项的销毁与创建：

在选项的UI脚本中，还需要根据传入的参数设定UI

这样即可实现生成选项：

接下来实现点击选项的事件：

我们希望根据选项所存储的下一个对话的ID实现跳转：

所以需要在optionUI里添加下一个对话ID的变量

然后在选项中更新：

为了降低耦合度，使用委托来实现接下来添加点击时需要执行的事件：

给Button添加Onclick事件

                     

获取了ID之后，然后就通过ID去对话的List中去获取该对话信息：

实现打字的效果：下载DOTween插件。

这样即可实现打字效果

但是此处还有一个问题，在于当next按钮消失时布局会发生改变。

还有currentIndex的顺序++，这个和选项无关

任务系统

创建任务 UI 面板

创建canvas：

创建一个panel附上图片，然后为实现任务左侧的滚动栏：

然后将滚动的栏删掉变成这样，（删除滑动条后记得调整viewport大小）

设定vertical group：

 

添加item slot：

以及item tooltip

 任务的存储数据结构

  • 创建任务基本变量
  • 创建 QuestRequire 用来追踪我们要完成的任务目标
  • 在 DialoguePiece 中加入 Quest 并设置一个新对话可以接受任务

思考一下，一个任务需要什么？需要有任务的名字、描述、要求、完成的状态。

任务的需求，我们以物品或者杀的怪物来举例，我们需要名字，需要的数量，有的数量，于是不难得出数据结构如下：

（任务可能有多个需求，所以需要用List来存储）

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. [CreateAssetMenu(fileName = "New Quest", menuName = "Quest/Quest Data")]
  6. public class QuestData_SO : ScriptableObject
  7. {
  8. 	[System.Serializable]
  9. 	public class QuestRequire
  10. 	{
  11. 		public string name;
  12. 		public int requireAmount;
  13. 		public int currentAmount;
  14. 	}
  15.  
  16.  
  17. 	public string questName;
  18. 	[TextArea]
  19. 	public string description;
  20.  
  21. 	//需要三种任务完成的状态，npc才会有不同的反应
  22. 	public bool isStarted;
  23. 	public bool isComplete;
  24. 	public bool isFinised;
  25.  
  26. 	public List<QuestRequire> questRequires = new List<QuestRequire>();
  27.  
  28. }

此处在这里将任务所需的怪物变量改的名字相同：

在对话一栏中加入任务作为成员变量，因为，我们有时候需要根据对话来接受任务

然后设置对话：

别忘了，任务还需要有奖励：

 添加奖励：

（bug记录：DondestroyOnLoad的物体不能是子物体，因此：不能放在别人的子集）

任务管理器与接受任务

接下来书写管理任务的管理器：用于管理全部的任务信息，使用List来存储全部的任务以及一些控制任务的函数。

  1. public class QuestManager : Singleton<QuestManager>
  2. {
  3.     public List<QuestTask> tasks = new List<QuestTask>();
  4. }

具体的任务的书写如下：包含任务数据，以及任务的三种状态。

  1.  
  2.     public class QuestTask
  3.     {
  4.         public QuestData_SO questData;
  5.         public bool IsStarted {
  6.             get { return questData.isStarted; }
  7.             set { questData.isStarted = value; }
  8.         }
  9.  
  10.         public bool IsComplete
  11.         {
  12.             get { return questData.isComplete; }
  13.             set { questData.isComplete = value; }
  14.         }
  15.  
  16.         public bool IsFinished
  17.         {
  18.             get { return questData.isFinished; }
  19.             set { questData.isFinished  = value; }
  20.         }
  21.  
  22.     }
  23.  
  24.

有了存储任务的数据结构后，作为一个管理器，还需要基础的增、查、获取的功能：

  1.     public bool HaveQuest(QuestData_SO data)//判断是否有这个任务
  2.     {
  3.         //在头文件中引入Ling，可以用于查找链表中的内容
  4.         if (data != null)
  5.             return tasks.Any(q => q.questData.questName == data.questName);
  6.         else return false;
  7.     }
  8.  
  9.     //根据任务数据的名字查找链表中的某一个任务
  10.     public QuestTask GetTask(QuestData_SO data)
  11.     {
  12.         return tasks.Find(q => q.questData.questName == data.questName);
  13.     }

上面有了查和获取，

增加任务的功能只需要直接往List中调用Add函数即可。

而什么时候需要添加任务呢？就是当玩家和NPC进行对话的时候来处理。

具体如下：

思路很简单，当玩家在对话中做出选择，判断本次的选项中是否含有任务，然后判断玩家是否选择了接任务的选项，如果含有，则判断该任务是否在列表中了，如果不在列表中，则将该任务实例化，并且加入到QuestManager的单例的List中。

这样即可实现对话后加任务的思路。

除此之外，我们接取任务后还希望设置任务的状态为开始状态：

但是直接修改并没有用，这只是修改的临时变量的值。

因此需要在QuestManager中根据任务的数据来查找管理器的链表中对应的任务

随后在此处设定开始：

任务控制相关脚本

接下来继续创建任务按钮以及任务需求的面板，并用脚本进行控制。

  • 创建 QuestNameButton 添加在 任务名字按钮 上
  • 创建 QuestRequirement 添加在 Requirement 上
  • 设置好以上两个类的变量并且拿到赋值

这个Button是最终面板中的这里：

 任务按钮需要哪些东西呢？由于我们希望点击任务的名字可以跳转到该任务并展示信息，所以需要按钮，以及任务的内容text。

所以button的控制脚本如下（任务按钮会存储该任务的信息，所以需要QuestData——SO变量）

为每个按钮做一个预制体，并且用脚本去控制

完善上面的脚本，并且书写设定按钮的函数。

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class QuestNameButton : MonoBehaviour
  7. {
  8.     public Text questNameText;
  9.     public QuestData_SO currentData;
  10.     //public Text questContentText;
  11.  
  12.     public void SetupNameButton(QuestData_SO quesData)
  13.     {
  14.         currentData = quesData;
  15.  
  16.         if (quesData.isComplete)
  17.             questNameText.text = quesData.questName + "(完成)";
  18.         else
  19.             questNameText.text = quesData.questName;
  20.     }
  21.  
  22.     private void Awake()
  23.     {
  24.         GetComponent<Button>().onClick.AddListener(UpdateQuestContent);
  25.     }
  26.     void UpdateQuestContent()
  27.     {
  28.         //questContentText.text = currentData.description;
  29.         QuestUI.Instance.SetupRequireList(currentData);
  30.  
  31.         foreach(Transform item in QuestUI.Instance.rewardTransform)
  32.         {
  33.             Destroy(item.gameObject);
  34.         }
  35.  
  36.  
  37.         foreach(var item in currentData.rewards)//奖励可能不止一个所以需要循环列表
  38.         {
  39.             QuestUI.Instance.SetupRewardItem(item.itemData, item.amount);
  40.         }
  41.     }
  42. }

此处设定任务内容有两种方式，一种是，我们使用单例的QuestUI（也就是实际上的Quest Manager）来统一显示这些数据

由于很多数据的显示我们是通过一个统一的管理器QuestUI来实现的，所以需要将相关的一些UI组件交由脚本来控制

继续完善任务控制脚本所需的组件：

接下来书写任务需求的脚本，它与UI面板中，它储存的是每个任务的需求和名字。

可以看到每个任务都带有这个脚本

接下来将单独的每个需求做成预制体，并将任务需求所在的Panel交由QuestUI来统一控制：

任务的奖励

奖励就是实际的物品Item

并且还需要获取奖励所在的面板

展示物品信息的代码如下

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5.  
  6. public class ShowTooltip : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
  7. {
  8.     private ItemUI currentItemUI;
  9.  
  10.     void Awake()
  11.     {
  12.         currentItemUI = GetComponent<ItemUI>();
  13.     }
  14.     public void OnPointerEnter(PointerEventData eventData)
  15.     {
  16.         Debug.Log("mouse in slot");
  17.         QuestUI.Instance.tooltip.gameObject.SetActive(true);
  18.         QuestUI.Instance.tooltip.SetupTooltip(currentItemUI.currentItemData);
  19.     }
  20.  
  21.     public void OnPointerExit(PointerEventData eventData)
  22.     {
  23.         QuestUI.Instance.tooltip.gameObject.SetActive(false);
  24.     }
  25. }

QuestUI完整代码

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class QuestUI : Singleton<QuestUI>
  7. {
  8.     [Header("Elements")]
  9.     public GameObject quesPanel;
  10.     public ItemToolTip tooltip;
  11.     bool isOpen;
  12.  
  13.     [Header("Quest Name")]
  14.     public RectTransform questListTransform;
  15.     public QuestNameButton questNameButton;
  16.  
  17.     [Header("Text Content")]
  18.     public Text quesContentText;
  19.  
  20.     [Header("Requirement")]
  21.     public RectTransform requireTransform;
  22.     public QuestRequirement requirement;
  23.  
  24.     [Header("Reward Panel")]
  25.     public RectTransform rewardTransform;
  26.     public ItemUI rewardUI;
  27.  
  28.     private void Update()
  29.     {
  30.         if (Input.GetKeyDown(KeyCode.Q))
  31.         {
  32.             isOpen = !isOpen;
  33.             quesPanel.SetActive(isOpen);
  34.             quesContentText.text = string.Empty;
  35.             SetupQuestList();
  36.         }
  37.  
  38.  
  39.         if (!isOpen)
  40.             tooltip.gameObject.SetActive(false);
  41.     }
  42.  
  43.     public void SetupQuestList()
  44.     {
  45.         //清除原来已有的任务
  46.         foreach(Transform item in questListTransform)
  47.         {
  48.             Destroy(item.gameObject);
  49.         }
  50.         foreach(Transform item in rewardTransform)
  51.         {
  52.             Destroy(item.gameObject);
  53.         }
  54.         foreach (Transform item in requireTransform)
  55.         {
  56.             Destroy(item.gameObject);
  57.         }
  58.  
  59.         //遍历列表中的list，接取任务
  60.         foreach(var task in QuestManager.Instance.tasks)
  61.         {
  62.             var newTask = Instantiate(questNameButton, questListTransform);
  63.             newTask.SetupNameButton(task.questData);
  64.             //newTask.questContentText = quesContentText;
  65.         }
  66.  
  67.  
  68.     }
  69.  
  70.     public void SetupRequireList(QuestData_SO questData)
  71.     {
  72.         quesContentText.text = questData.description;
  73.         //将涉及到QuestNameButton中的三处questContentText关闭，不使用在里面传东西然后赋值的形式了，改为在此处直接修改
  74.  
  75.         foreach (Transform item in requireTransform)
  76.         {
  77.             Destroy(item.gameObject);
  78.         }
  79.         foreach(var require in questData.questRequires)
  80.         {
  81.             var q = Instantiate(requirement, requireTransform);
  82.             q.SetupRequirement(require.name, require.requireAmount, require.currentAmount);
  83.         }
  84.     }
  85.  
  86.     public void SetupRewardItem(ItemData_SO itemData,int amount)
  87.     {
  88.         var item = Instantiate(rewardUI, rewardTransform);
  89.         item.SetupItemUI(itemData, amount);
  90.     }
  91.  
  92. }

实现点按任务显示信息

  • 按照逻辑去写每一个需要的函数方法
  • 设置任务按钮显示对应任务名字
  • 实现点击名字按钮能显示任务详情以及任务需求
  • 调整 UI 布局

添加按钮的监听事件：显示任务的描述（实现当按下按钮时会更新信息的操作）

实现显示任务的需求

首先在需求的预制体里写一个供外部调用的接口

然后在管理器中调用该接口

在按钮点击事件中调用该函数：

这样即可显示：

但是任务信息和需求重叠在了一起。

在这里可以使得它强制布局：

这样显示就正常了

  • SetupRewardList的 方法实现
  • 创建 ShowTooltip 实现鼠标滑入显示信息
  • 创建多个任务并修复重复显示任务奖励的问题

对于任务信息的显示，除了之前的那种方法：

回顾一下之前的方法：

在QuestNameButton这个预制体的脚本里面给每个任务对应的text里声明该变量：

然后在设定任务时，将任务的需求的那个text赋值给它。

然后根据按钮更新数据的时候，再从任务的SO中获取任务内容再赋值：

这样的过程比较冗余。

现在删去其中在另外一个脚本QuestNameButton中声明变量并且传值然后修改的过程，直接在QuestUI中统一修改：

接下来实现展现需求的代码：

在questUI中，调用之前写的slotItem的方法：

这样即可实现

注意布局

接下来实现鼠标放到上面时显示信息的功能：

脚本并非挂在那个tooltip上，否则因为初始它是不可见的所以没法调用，应该放在reward item slot上。

那么和之前一样，需要实现接口即可：

然后放到上面时就显示设置active为true然后显示信息。

然后设置setupTooltip：

但是有个问题在于:

这个东西返回的是背包里的数据：

而不是实际存在的值。

所以此处需要添加新的变量：

将原来那个函数修改成这样：

这样即可实现，但是发现会出现遮挡现象：

将其放在最下方，就不会被遮挡了：

然后还有个问题在于背包关闭再次打开时，这个还是存在：这是因为即使关闭面板栏，tooltip依然是Active状态。

这样即可解决。

接下来实现多个任务时，出现了这样的问题：

任务来回切换会导致item Slot变多：

更新时清除奖励：

 

检测和更新任务进度

  • 创建函数在 敌人死亡 和 拾取物品时 更新任务进度
  • 使用 Linq 语句中的 Where 找到匹配的任务需求并检查是否满足
  • 修改特殊情况使用任务物品消耗后更新进度

任务进度：检查背包中的物品数量和任务所需的物品数量是否相同，

敌人死亡时进行调用

代码中如果出现两个任务，则两个任务中的都要对应减少。

书写检查任务的函数

提问：为什么有些函数放在QuestUI中有些函数放在QuestManager中，有些函数放在QuestData_SO中呢？

QuestUI是用来处理和UI界面的显示相关的函数。是MVC模式中的模型 Model

QuestData_SO中需要的函数很少，只需要涉及到修改状态数据的函数。是MVC中的视图View

而QuestManager用来处理读取数据以及和UI界面交互的功能。是MVC中的控制器Controller

拾取物品时也进行调用：

这样即可实现完成任务。

但是我们发现使用物品后，任务不会更新。

在此处进行修改：

接受任务时检查任务物品是否契合

  • 考虑可能存在的情况在接受任务的时候检查背包是否有任务物品
  • 在 QuestData_SO 中创建 RequireTargetName 拿到需求的名字列表
  • 循环列表中每一项在 Inventory 中检查是否存在并更新数据

有个问题在于如果接任务前背包就有两个蘑菇了，此时并不会任务面板并不会更新；
所以需要在InventoryManager中设定一个刚开始的函数中就去检查背包中的物品

检查任务物品：

由于一个questRequire中有多个物品：

因此需要一个包含其名字的list，循环时要判断每一个是否有

创建一个包含名字的链表：

这样就可以实现接受任务时就检查是否完成。

在questGiver里获取当前任务的任务状态：


 

根据完成情况控制任务对话分支

根据任务完成的状态，需要给予npc不同的对话，所以给npc创建一个脚本：

然后有QuestGiver去修改Dialogue Controller里面的数据

QuestGiver包含多种对话

  1. [RequireComponent(typeof(DialogueController))]
  2. public class QuestGiver : MonoBehaviour
  3. {
  4.     DialogueController controller;
  5.     QuestData_SO currentQuest;
  6.  
  7.     public DialougeData_SO startDialogue;
  8.     public DialougeData_SO progressDialogue;
  9.     public DialougeData_SO completeDialogue;
  10.     public DialougeData_SO finishDialogue;
  11.  
  12.     private void Awake()
  13.     {
  14.         controller = GetComponent<DialogueController>(); 
  15.     }
  16. }
  17.

对于发布任务的人，我们需要让它拿到任务的完成状态，才能根据不同状态执行不同对话：

然后赋值给当前任务：

在questGiver的update函数中则根据不同的状态进行切换。

然后自行设定四个对话的内容并传入：

有个bug会产生，问题在于不要出现这种情况

这样就实现了任务不同状态时的不同对话。

添加一个功能：

当玩家远离时则自动关闭对话：

、

拿到任务奖励及扣除报酬

拿到任务奖励需扣除报酬，那么可以这样，将奖励设置为-2：

接受完任务后，背包和栏里面的物品会更新，因此需要写一个根据任务里的物品判断背包是否有该物品的函数 

在任务数据里书写给予奖励的函数：

  1. public void GiveRewards()
  2.     {
  3.         foreach(var reward in rewards)
  4.         {
  5.             if (reward.amount < 0)
  6.             {
  7.                 int requireCount = Mathf.Abs(reward.amount);
  8.  
  9.                 //优先在背包里找是否有该物品，
  10.                 if (InventoryManager.Instance.QuestItemInBag(reward.itemData) != null)
  11.                 {
  12.                     //这种情况是背包里的东西不够，那就先在背包里扣除一部分，
  13.                     if (InventoryManager.Instance.QuestItemInBag(reward.itemData).amount <= requireCount)
  14.                     {
  15.                         requireCount -= InventoryManager.Instance.QuestItemInBag(reward.itemData).amount;//所需的数量减少
  16.                         InventoryManager.Instance.QuestItemInBag(reward.itemData).amount = 0;//背包里的商品扣除为0
  17.  
  18.                         //背包里东西不够，剩下的部分从行动栏里扣除
  19.                         if (InventoryManager.Instance.QuestItemInAction(reward.itemData) != null)
  20.                         {
  21.                             InventoryManager.Instance.QuestItemInAction(reward.itemData).amount -= requireCount;
  22.                         }
  23.  
  24.                     }
  25.                     //这种情况就是背包里的东西直接够，那直接扣除就好
  26.                     else
  27.                     {
  28.                         InventoryManager.Instance.QuestItemInBag(reward.itemData).amount -= requireCount;
  29.                     }
  30.  
  31.                 }
  32.                 //这种情况是背包里一点东西都没有，那就直接扣除行动栏里的物品
  33.                 else
  34.                 {
  35.                     InventoryManager.Instance.QuestItemInAction(reward.itemData).amount -= requireCount;
  36.                 }
  37.             }
  38.             else
  39.             {
  40.                 InventoryManager.Instance.inventoryData.AddItem(reward.itemData, reward.amount);
  41.             }
  42.  
  43.             InventoryManager.Instance.inventoryUI.RefreshUI();
  44.             InventoryManager.Instance.actionUI.RefreshUI();
  45.         }
  46.     }

在OptionUI中执行给与奖励：

这里做的时候出现了一个bug，问题在于之前的对话中没添加quest：

这样即可实现交付任务和扣除东西。

但是有个问题在于：

蘑菇会显示负数。

改动如下：

接下来还有一个小小问题，在于任务完成了，继续拾取蘑菇，任务进度还是会更新，解决方法：

然后在执行更新需求的代码里：

如果完成了则执行完成的设定 

在对话时，我们希望保持鼠标是固定的样式：

为了避免已完成的任务再次受到数据更新的影响： 

保存任务数据

QuestManager里面保存的数据以List类型保存，而里面的数据不是SO类型的，所以不能用之前那样的方法保存 

以前的保存都是通过Object来保存的：

因此此处实现一个非SO类型的保存方法：

虽然也可以通过将其改成SO的方式来实现，但此处换种方式：

注意到tasks虽然不是SO，但是task里面的QuestData是SO类型的，我们可以保存它

书写保存和Load的方法：

  1. public void SaveQuestManager()
  2.     {
  3.         PlayerPrefs.SetInt("QuestCount", tasks.Count);
  4.         for(int i = 0; i < tasks.Count; i++)
  5.         {
  6.             SaveManager.Instance.Save(tasks[i].questData, "task" + i);
  7.         }
  8.     }
  9.  
  10.  
  11.     //加载数据的方式是通过重新新创建一个SO，然后让SO读取数据，然后再加入到tasks链表当中
  12.     public void LoadQuestManager()
  13.     {
  14.         var quesCount = PlayerPrefs.GetInt("QuestCount");
  15.         for(int i = 0; i < quesCount; i++)
  16.         {
  17.             var newQuest = ScriptableObject.CreateInstance<QuestData_SO>();//
  18.             SaveManager.Instance.Load(newQuest, "task" + i);
  19.             tasks.Add(new QuestTask { questData = newQuest });
  20.         }
  21.     }

读取数据的方法可以放在初始时：

在QuestManager中添加

 这样即可实现切换场景保存任务：

代码汇总

背包部分

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public enum ItemType { Useable,Weapon,Armor}
  6. [CreateAssetMenu(fileName ="New Item",menuName ="Inventory/Item Data")]
  7. public class ItemData_SO : ScriptableObject
  8. {
  9.     public ItemType itemType;
  10.     public string itemName;
  11.     public Sprite itemIcon;
  12.     public int itemAmount;//这个物品有多少数量
  13.  
  14.     [TextArea]
  15.     public string description = "";
  16.  
  17.     public bool stackable;//是否可堆叠
  18.  
  19.  
  20.     [Header("Weapon")]
  21.     public GameObject WeaponPrefab;
  22.  
  23.     public AttackData_SO weaponData;
  24.     public AnimatorOverrideController weaponAnimator;
  25.  
  26.     [Header("Useable Item")]
  27.     public UseableItemData_SO useableData;
  28. }

  1.   using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class ItemPickUp : MonoBehaviour
  6. {
  7.     public ItemData_SO itemData;
  8.  
  9.     private void OnTriggerEnter(Collider other)
  10.     {
  11.         if (other.CompareTag("Player"))
  12.         {
  13.             Debug.Log("OnTrigger");
  14.             //GameManager.Instance.playerStats.EquipWeapon(itemData);
  15.             InventoryManager.Instance.inventoryData.AddItem(itemData, itemData.itemAmount);
  16.             InventoryManager.Instance.inventoryUI.RefreshUI();
  17.  
  18.             QuestManager.Instance.UpdateQuestProgress(itemData.itemName, itemData.itemAmount);
  19.             //装备武器
  20.             Destroy(gameObject);
  21.         }
  22.     }
  23. }

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class InventoryManager : Singleton<InventoryManager>
  7. {
  8.  
  9.     public class DragData
  10.     {
  11.         public SlotHolder orginalHolder;
  12.         public RectTransform originalParent;
  13.     }
  14.     [Header("Inventory Data")]
  15.     //使用类似之前那样的模板，游戏新开始时复制一份的操作
  16.     //TODO:最后添加模板用于保存数据
  17.     public InventoryData_SO inventoryTemplate;
  18.     public InventoryData_SO inventoryData;
  19.  
  20.     public InventoryData_SO actionTemplate;
  21.     public InventoryData_SO actionData;
  22.  
  23.     public InventoryData_SO equipmentTemplate;
  24.     public InventoryData_SO equipmentData;
  25.  
  26.     [Header("Containers")]
  27.     public ContainerUI inventoryUI;
  28.     public ContainerUI actionUI;
  29.     public ContainerUI equipmentUI;
  30.  
  31.     [Header("Drag Canvas")]
  32.     public Canvas dragCanvas;
  33.  
  34.     public DragData currentDrag;
  35.     protected override void Awake()
  36.     {
  37.         base.Awake();
  38.         if (inventoryTemplate != null)
  39.             inventoryData = Instantiate(inventoryTemplate);
  40.         if (actionTemplate != null)
  41.             actionData = Instantiate(actionTemplate);
  42.         if (equipmentTemplate != null)
  43.             equipmentData = Instantiate(equipmentTemplate);
  44.     }
  45.     private void Start()
  46.     {
  47.         LoadData();
  48.         inventoryUI.RefreshUI();
  49.         actionUI.RefreshUI();
  50.         equipmentUI.RefreshUI();
  51.     }
  52.  
  53.     [Header("UI Panel")]
  54.     public GameObject bagPanel;
  55.     public GameObject statsPanel;
  56.     bool isOpen;
  57.  
  58.     [Header("Stats Text")]
  59.     public Text healthText;
  60.     public Text attackText;
  61.  
  62.     [Header("Tooltip")]
  63.     public ItemToolTip tooltip;
  64.     
  65.     void Update()
  66.     {
  67.         if (Input.GetKeyDown(KeyCode.B))
  68.         {
  69.             isOpen = !isOpen;
  70.             bagPanel.SetActive(isOpen);
  71.             statsPanel.SetActive(isOpen);
  72.         }
  73.  
  74.         UpdateStatsText(GameManager.Instance.playerStats.MaxHealth, GameManager.Instance.playerStats.attackData.minDamage,
  75.             GameManager.Instance.playerStats.attackData.maxDamage);
  76.     }
  77.  
  78.     public void UpdateStatsText(int health,int min,int max)
  79.     {
  80.         healthText.text = health.ToString();
  81.         attackText.text = min + " - " + max;
  82.     }
  83.  
  84.     #region 检查拖拽物品是否在每一个slot范围内
  85.     public bool CheckInInventoryUI(Vector3 position)//此处这个位置是要传输进来的位置
  86.     {
  87.         for(int i = 0; i < inventoryUI.slotHolders.Length; i++)
  88.         {
  89.             RectTransform t = inventoryUI.slotHolders[i].transform as RectTransform;
  90.             if (RectTransformUtility.RectangleContainsScreenPoint(t, position))//判断当前位置是否物品栏里
  91.             {
  92.                 return true;
  93.             }
  94.             
  95.         }
  96.         return false;
  97.     }
  98.  
  99.     public bool CheckInActionUI(Vector3 position)//此处这个位置是要传输进来的位置
  100.     {
  101.         for (int i = 0; i < actionUI.slotHolders.Length; i++)
  102.         {
  103.             RectTransform t = actionUI.slotHolders[i].transform as RectTransform;
  104.             if (RectTransformUtility.RectangleContainsScreenPoint(t, position))//判断当前位置是否物品栏里
  105.             {
  106.                 return true;
  107.             }
  108.  
  109.         }
  110.         return false;
  111.     }
  112.  
  113.     public bool CheckInEquipmentUI(Vector3 position)//此处这个位置是要传输进来的位置
  114.     {
  115.         for (int i = 0; i < equipmentUI.slotHolders.Length; i++)
  116.         {
  117.             RectTransform t = equipmentUI.slotHolders[i].transform as RectTransform;
  118.             if (RectTransformUtility.RectangleContainsScreenPoint(t, position))//判断当前位置是否物品栏里
  119.             {
  120.                 return true;
  121.             }
  122.  
  123.         }
  124.         return false;
  125.     }
  126.     #endregion
  127.  
  128.  
  129.     public void SaveData()  
  130.     {
  131.         SaveManager.Instance.Save(inventoryData, inventoryData.name);
  132.         SaveManager.Instance.Save(actionData, actionData.name);
  133.         SaveManager.Instance.Save(equipmentData, equipmentData.name);
  134.  
  135.     }
  136.  
  137.     public void LoadData()
  138.     {
  139.         SaveManager.Instance.Load(inventoryData, inventoryData.name);
  140.         SaveManager.Instance.Load(actionData, actionData.name);
  141.         SaveManager.Instance.Load(equipmentData, equipmentData.name);
  142.     }
  143.  
  144.     #region 检测任务物品
  145.     public void CheckQuestItemInBag(string questItemName)
  146.     {
  147.         foreach(var item in inventoryData.items)
  148.         {
  149.             if (item.itemData != null)
  150.             {
  151.                 if (item.itemData.itemName == questItemName)
  152.                     QuestManager.Instance.UpdateQuestProgress(item.itemData.itemName, item.amount);
  153.             }
  154.         }
  155.  
  156.         foreach (var item in actionData .items)
  157.         {
  158.             if (item.itemData != null)
  159.             {
  160.                 if (item.itemData.itemName == questItemName)
  161.                     QuestManager.Instance.UpdateQuestProgress(item.itemData.itemName, item.amount);
  162.             }
  163.         }
  164.  
  165.     }
  166.     #endregion
  167.  
  168.  
  169.     //检测背包和快捷栏里的物体是否有和任务相同的
  170.     public InventoryItem QuestItemInBag(ItemData_SO questItem)
  171.     {
  172.         return inventoryData.items.Find(i => i.itemData == questItem);
  173.     }
  174.  
  175.     public InventoryItem QuestItemInAction(ItemData_SO questItem)
  176.     {
  177.         return actionData.items.Find(i => i.itemData == questItem);
  178.      }
  179.  
  180. }

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5.  
  6. public enum SlotType { BAG,WEAPON,ARMOR,ACTION}
  7. public class SlotHolder : MonoBehaviour,IPointerClickHandler,IPointerEnterHandler,IPointerExitHandler
  8. {
  9.     // Start is called before the first frame update
  10.     public SlotType slotType;//这个需要用来告诉属于哪一个UI面板，因为后面会有背包、行动
  11.     public ItemUI itemUI;    //这是SlotHolder的子物体，Image和Text的父物体。
  12.  
  13.  
  14.  
  15.     //SlotHolder可以理解为格子里的物品的UI信息。
  16.     //获取是为了给子物体中的image和text进行修改
  17.  
  18.  
  19.     public void UpdateItem()
  20.     {
  21.         switch (slotType)
  22.         { 
  23.             case SlotType.BAG:
  24.                 itemUI.Bag = InventoryManager.Instance.inventoryData;
  25.                 break;
  26.             case SlotType.WEAPON:
  27.                 itemUI.Bag = InventoryManager.Instance.equipmentData;
  28.                 //装备武器 切换武器
  29.                 if (itemUI.Bag.items[itemUI.Index].itemData != null)
  30.                 {
  31.                     GameManager.Instance.playerStats.ChangeWeapon(itemUI.Bag.items[itemUI.Index].itemData);
  32.                 }
  33.                 else
  34.                 {
  35.                     GameManager.Instance.playerStats.UnEquipWeapon();
  36.                 }
  37.                 break;
  38.             case SlotType.ARMOR:
  39.                 itemUI.Bag = InventoryManager.Instance.equipmentData;
  40.                 break;
  41.             case SlotType.ACTION:
  42.                 itemUI.Bag = InventoryManager.Instance.actionData;
  43.  
  44.                 break;
  45.         }
  46.  
  47.         var item = itemUI.Bag.items[itemUI.Index];//找到数据库中对应序号的对应物品
  48.         itemUI.SetupItemUI(item.itemData, item.amount);
  49.     }
  50.  
  51.     public void OnPointerClick(PointerEventData eventData)
  52.     {
  53.         if (eventData.clickCount % 2 == 0)//代表是双击的话
  54.         {
  55.             UseItem();
  56.         }
  57.     }
  58.     public void UseItem()
  59.     {
  60.         if (itemUI.GetItem().itemType == ItemType.Useable&&itemUI.Bag.items[itemUI.Index].amount>0)
  61.         {
  62.             GameManager.Instance.playerStats.ApplyHealth(itemUI.GetItem().useableData.healthPoint);
  63.             itemUI.Bag.items[itemUI.Index].amount -= 1;
  64.  
  65.             QuestManager.Instance.UpdateQuestProgress(itemUI.GetItem().itemName, -1);
  66.         }
  67.         UpdateItem();
  68.     }
  69.  
  70.     public void OnPointerEnter(PointerEventData eventData)
  71.     {
  72.         if (itemUI.GetItem())
  73.         {
  74.             InventoryManager.Instance.tooltip.SetupTooltip(itemUI.GetItem());
  75.             InventoryManager.Instance.tooltip.gameObject.SetActive(true);
  76.         }
  77.     }
  78.  
  79.     public void OnPointerExit(PointerEventData eventData)
  80.     {
  81.         InventoryManager.Instance.tooltip.gameObject.SetActive(false);
  82.     }
  83.  
  84.     void OnDisable()
  85.     {
  86.         InventoryManager.Instance.tooltip.gameObject.SetActive(false);
  87.     }
  88. }

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5.  
  6. [RequireComponent(typeof(ItemUI))]
  7. public class DragItem : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
  8. {
  9.     ItemUI currentItemUI;
  10.     //
  11.     SlotHolder currentHolder;
  12.     SlotHolder targetHolder;
  13.  
  14.     void Awake()
  15.     {
  16.         currentItemUI = GetComponent<ItemUI>();
  17.         currentHolder = GetComponentInParent<SlotHolder>();//原先的格子的信息
  18.     }
  19.     public void OnBeginDrag(PointerEventData eventData)
  20.     {
  21.         InventoryManager.Instance.currentDrag = new InventoryManager.DragData();
  22.         InventoryManager.Instance.currentDrag.orginalHolder = GetComponentInParent<SlotHolder>();
  23.         InventoryManager.Instance.currentDrag.originalParent = (RectTransform)transform.parent;
  24.         //记录原始数据
  25.         transform.SetParent(InventoryManager.Instance.dragCanvas.transform,true);
  26.     }
  27.  
  28.     public void OnDrag(PointerEventData eventData)
  29.     {
  30.         //跟随鼠标位置移动
  31.         transform.position = eventData.position;
  32.     }
  33.  
  34.     public void OnEndDrag(PointerEventData eventData)
  35.     {
  36.         //放下物品 交换数据
  37.         if (EventSystem.current.IsPointerOverGameObject())//是否指向UI组件
  38.         {
  39.             if(InventoryManager.Instance.CheckInActionUI(eventData.position)
  40.                 || InventoryManager.Instance.CheckInInventoryUI(eventData.position)
  41.                 || InventoryManager.Instance.CheckInEquipmentUI(eventData.position))
  42.                 //判断是否在三个栏里面的格子里
  43.             {
  44.                 if (eventData.pointerEnter.gameObject.GetComponent<SlotHolder>())
  45.                     targetHolder = eventData.pointerEnter.gameObject.GetComponent<SlotHolder>();
  46.                 else
  47.                     targetHolder = eventData.pointerEnter.gameObject.GetComponentInParent<SlotHolder>();
  48.                 //如果没找到，此时是因为被图片所挡住了，那么就获取其父类的component
  49.  
  50.                 Debug.Log(eventData.pointerEnter.gameObject);
  51.                 //判断鼠标选中的物体是否有slot holder，
  52.  
  53.                 //判断是否目标holder是我的原holder
  54.                 if(targetHolder!=InventoryManager.Instance.currentDrag.orginalHolder)
  55.                 //由于例如食物不能放在武器栏里，所以需要对其做区分
  56.                     switch (targetHolder.slotType)
  57.                     {
  58.                         case SlotType.BAG:
  59.                             SwapItem();
  60.                             break;
  61.                          
  62.                         //下面这些if的判断就确保了只有相同的物品才能实现交换
  63.                         case SlotType.WEAPON:
  64.                             if (currentItemUI.Bag.items[currentItemUI.Index].itemData.itemType == ItemType.Weapon)
  65.                                 SwapItem();
  66.                             break;
  67.  
  68.                         case SlotType.ARMOR:
  69.                             if (currentItemUI.Bag.items[currentItemUI.Index].itemData.itemType == ItemType.Armor)
  70.                                 SwapItem();
  71.                             break;
  72.  
  73.                         case SlotType.ACTION:
  74.                             if(currentItemUI.Bag.items[currentItemUI.Index].itemData.itemType==ItemType.Useable)
  75.                                 SwapItem();
  76.                             break;
  77.                    
  78.                     }
  79.                 
  80.                 currentHolder.UpdateItem();//交换完毕后需要更新数据
  81.                 targetHolder.UpdateItem();
  82.  
  83.  
  84.             }
  85.         }
  86.  
  87.         transform.SetParent(InventoryManager.Instance.currentDrag.originalParent);
  88.  
  89.         RectTransform t = transform as RectTransform;
  90.         t.offsetMax = -Vector3.one * 5;
  91.         t.offsetMin = Vector2.one * 5;
  92.  
  93.  
  94.     }
  95.  
  96.     public void SwapItem()
  97.     {
  98.         //targetHolder是鼠标指向的位置的格子。
  99.         //获取目标格子上面显示的UI，UI图片对应它身上属于哪个背包的哪一个序号的物品
  100.         var targetItem = targetHolder.itemUI.Bag.items[targetHolder.itemUI.Index];//实际上就是获取鼠标指向的物品item
  101.  
  102.         var tempItem = currentHolder.itemUI.Bag.items[currentHolder.itemUI.Index];//点击前的鼠标的格子的信息
  103.  
  104.         //如果是相同的物品就进行合并
  105.         bool isSameItem = tempItem.itemData == targetItem.itemData;
  106.         if (isSameItem && targetItem.itemData.stackable)//并且还要可堆叠才行
  107.         {
  108.             targetItem.amount += tempItem.amount;
  109.             tempItem.itemData = null;
  110.             tempItem.amount = 0;
  111.         }
  112.         else
  113.         {
  114.             currentHolder.itemUI.Bag.items[currentHolder.itemUI.Index] = targetItem;
  115.             //targetItem=tempItem;这样的写法不行因为targetItem只是我们获取的一个变量，应该直接用其本身去更换，即下一行的写法
  116.             targetHolder.itemUI.Bag.items[targetHolder.itemUI.Index] = tempItem;
  117.         }
  118.     }
  119. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5.  
  6. public class DragPanel : MonoBehaviour,IDragHandler,IPointerDownHandler
  7. {
  8.     RectTransform rectTransform;
  9.  
  10.     Canvas canvas;
  11.     void Awake()
  12.     {
  13.         rectTransform = GetComponent<RectTransform>();
  14.         canvas = InventoryManager.Instance.GetComponent<Canvas>();
  15.     }
  16.     public void OnDrag(PointerEventData eventData)
  17.     {
  18.         rectTransform.anchoredPosition += eventData.delta/canvas.scaleFactor;//让其锚点的位置的改变量和鼠标的改变量相同即可
  19.     }
  20.  
  21.     public void OnPointerDown(PointerEventData eventData)
  22.     {
  23.         rectTransform.SetSiblingIndex(2);
  24.     }
  25.  
  26. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class ContainerUI : MonoBehaviour
  6. {
  7.     public SlotHolder[] slotHolders;
  8.     
  9.     public void RefreshUI()
  10.     {
  11.         for(int i = 0; i < slotHolders.Length; i++)
  12.         {
  13.             slotHolders[i].itemUI.Index = i;
  14.             slotHolders[i].UpdateItem();
  15.         }
  16.     }
  17. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class ItemToolTip : MonoBehaviour
  7. {
  8.     public Text itemNameText;
  9.     public Text itemInfoText;
  10.     RectTransform rectTransform;
  11.  
  12.     private void Awake()
  13.     {
  14.         rectTransform = GetComponent<RectTransform>();
  15.     }
  16.     public void SetupTooltip(ItemData_SO item)
  17.     {
  18.         itemNameText.text = item.itemName;
  19.         itemInfoText.text = item.description;
  20.     }
  21.  
  22.     void OnEnable()
  23.     {
  24.         //开始时会闪烁是因为没有定位好坐标，开始时先更新一下即可避免这种效果
  25.         UpdatePosition();
  26.  
  27.     }
  28.     private void Update()
  29.     {
  30.         UpdatePosition();
  31.     }
  32.     public void UpdatePosition()
  33.     {
  34.         Vector3 mousePos = Input.mousePosition;
  35.         rectTransform.position = mousePos;
  36.  
  37.         Vector3[] corners = new Vector3[4];
  38.         rectTransform.GetWorldCorners(corners);
  39.  
  40.         float width = corners[3].x - corners[0].x;
  41.         float height = corners[1].y - corners[0].y;
  42.  
  43.         if (mousePos.y < height)
  44.             rectTransform.position = mousePos + Vector3.up * height * 0.6f;
  45.         else if (Screen.width - mousePos.x > width)
  46.             rectTransform.position = mousePos + Vector3.right * width * 0.6f;
  47.         else
  48.             rectTransform.position = mousePos + Vector3.left * width * 0.6f;
  49.  
  50.     }
  51.  
  52. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class ItemUI : MonoBehaviour
  7. {
  8.     public Image icon = null;
  9.     public Text amount = null;
  10.  
  11.     public InventoryData_SO Bag { get; set; }
  12.     public InventoryData_SO Action { get; set; }
  13.     public InventoryData_SO Equipment { get; set; }
  14.  
  15.     public ItemData_SO currentItemData;
  16.  
  17.     public int Index { get; set; } = -1;//初始值设为-1是因为一开始序号是从0开始的，避免一开始去setup每个格子的时候出现数据的错位排序
  18.  
  19.     public void SetupItemUI(ItemData_SO item,int itemAmount)
  20.     {
  21.         if (itemAmount == 0)
  22.         {
  23.             Bag.items[Index].itemData = null;
  24.             icon.gameObject.SetActive(false);
  25.             return;
  26.         }
  27.  
  28.         //想要实现如果数量小于0则不显示，不能在上面的if条件改成<=0，因为此时并没有实际的背包
  29.  
  30.         if (itemAmount < 0) item = null;//只需要跳过下面的null部分就行了，并且需要设置active为false
  31.         if (item != null)
  32.         {
  33.             icon.sprite = item.itemIcon;
  34.             amount.text = itemAmount.ToString();
  35.             icon.gameObject.SetActive(true);//默认是可见的，此处设为不可见
  36.  
  37.             currentItemData = item;
  38.  
  39.         }
  40.         else
  41.             icon.gameObject.SetActive(false);
  42.     }
  43.  
  44.     public ItemData_SO GetItem()
  45.     {
  46.         return Bag.items[Index].itemData;
  47.     }
  48.  
  49. }

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class LootSpawner : MonoBehaviour
  6. {
  7.     [System.Serializable]
  8.     public class LootItem
  9.     {
  10.         public GameObject item;
  11.         [Range(0, 1)]
  12.         public float weight;
  13.     }
  14.  
  15.     public LootItem[] lootItems; 
  16.  
  17.     public void Spawnloot()
  18.     {
  19.         float currentValue = Random.value;
  20.  
  21.         for(int i = 0; i < lootItems.Length; i++)
  22.         {
  23.             if (currentValue <= lootItems[i].weight)
  24.             {
  25.                 GameObject obj = Instantiate(lootItems[i].item);
  26.                 obj.transform.position = transform.position + Vector3.up * 2;
  27.                 break;//确保一次只掉落一个物品
  28.             }
  29.         }
  30.     }
  31. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class ActionButton : MonoBehaviour
  6. {
  7.     public KeyCode actionKey;
  8.     private SlotHolder currentSlotHolder;
  9.  
  10.     void Awake()
  11.     {
  12.         currentSlotHolder = GetComponent<SlotHolder>();
  13.  
  14.     }
  15.  
  16.     private void Update()
  17.     {
  18.         if (Input.GetKeyDown(actionKey) && currentSlotHolder.itemUI.GetItem())
  19.             currentSlotHolder.UseItem();
  20.     }
  21. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. [CreateAssetMenu(fileName ="Useable Item",menuName ="Inventory/Useable Item Data")]
  6. public class UseableItemData_SO : ScriptableObject
  7. {
  8.     //所有你想改变的数据
  9.     public int healthPoint;
  10. }

Dialogue部分

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. public class DialogueController : MonoBehaviour
  6. {
  7.     public DialougeData_SO currentData;
  8.     bool canTalk = false;
  9.  
  10.     private void OnTriggerEnter(Collider other)
  11.     {
  12.         if (other.CompareTag("Player") && currentData != null)
  13.         {
  14.             canTalk = true;
  15.             Debug.Log("can talk is true");
  16.  
  17.         }
  18.     }
  19.  
  20.     private void OnTriggerExit(Collider other)
  21.     {
  22.         if (other.CompareTag("Player"))
  23.         {
  24.             DialogueUI.Instance.dialoguePanel.SetActive(false);
  25.         }
  26.     }
  27.  
  28.     private void Update()
  29.     {
  30.         if (canTalk && Input.GetKeyDown(KeyCode.F))//TODO:此处是否可以改编成使用事件的形式？
  31.         {
  32.             OpenDialogue();
  33.         }
  34.     }
  35.  
  36.     void OpenDialogue()
  37.     {
  38.         //打开UI面板
  39.         //传输对话内容信息
  40.         DialogueUI.Instance.UpdateDialogueData(currentData);
  41.         DialogueUI.Instance.UpdateMainDialogue(currentData.dialoguePieces[0]);
  42.     }
  43.  
  44.  
  45. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. [System.Serializable]
  6. public class DialogueOption 
  7. {   
  8.     public string text;
  9.     public string targetID;
  10.     public bool takeQuest;
  11. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. [System.Serializable]
  6. public class DialoguePiece {
  7.     public string ID;
  8.     public Sprite image;
  9.  
  10.     [TextArea]
  11.     public string text;
  12.  
  13.     public QuestData_SO quest;
  14.  
  15.     public List<DialogueOption> options = new List<DialogueOption>();
  16.  
  17.  
  18. }

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. [CreateAssetMenu(fileName ="New Dialogue",menuName ="Dialogue/Dialogue Data")]
  6. public class DialougeData_SO : ScriptableObject
  7. {
  8.  
  9.     public List<DialoguePiece> dialoguePieces = new List<DialoguePiece>();
  10.     public Dictionary<string, DialoguePiece> dialogueIndex = new Dictionary<string, DialoguePiece>();
  11.  
  12.  
  13.  
  14.     public QuestData_SO GetQuest()
  15.     {
  16.         QuestData_SO currentQuest = null;
  17.         //循环对话中的任务，找到该任务并返回
  18.         foreach (var piece in dialoguePieces)
  19.         {
  20.             if (piece.quest != null)
  21.                 currentQuest = piece.quest;
  22.         }
  23.         return currentQuest;
  24.     }
  25.  
  26.  
  27.     //如果是在Unity编辑器中，则字典随时改变时则进行修改，如果是打包则字典信息不会更改
  28. #if UNITY_EDITOR
  29.     void OnValidate()//一旦这个脚本中的数据被更改时会自动调用
  30.     {
  31.         dialogueIndex.Clear();
  32.         //一旦信息有所更新，就会将信息存储在字典中
  33.         foreach(var piece in dialoguePieces)
  34.         {
  35.             if (!dialogueIndex.ContainsKey(piece.ID))
  36.                 dialogueIndex.Add(piece.ID, piece);
  37.         }
  38.     }
  39. #else
  40.     void Awake()//保证在打包执行的游戏里第一时间获得对话的所有字典匹配 
  41.     {
  42.         dialogueIndex.Clear();
  43.         foreach (var piece in dialoguePieces)
  44.         {
  45.             if (!dialogueIndex.ContainsKey(piece.ID))
  46.                 dialogueIndex.Add(piece.ID, piece);
  47.         }
  48.     }
  49. #endif
  50.  
  51.  
  52.  
  53.  
  54. }

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5. using DG.Tweening;
  6.  
  7. public class DialogueUI : Singleton<DialogueUI>
  8. {
  9.     [Header("Basic Elements")]
  10.     public Image icon;
  11.     public Text mainText;
  12.     public Button nextButton;
  13.  
  14.     public GameObject dialoguePanel;
  15.  
  16.     [Header("Data")]
  17.     public DialougeData_SO currentData;
  18.  
  19.     int currentIndex = 0;
  20.  
  21.     [Header("Options")]
  22.     public RectTransform optionPanel;
  23.     public OptionUI optionPrefab;
  24.  
  25.  
  26.     protected override void Awake()
  27.     {
  28.         base.Awake();
  29.         nextButton.onClick.AddListener(ContinueDialogue);//点击时如果后续还有对话则继续进行
  30.     }
  31.  
  32.     void ContinueDialogue()
  33.     {
  34.         if (currentIndex < currentData.dialoguePieces.Count)
  35.         {
  36.             UpdateMainDialogue(currentData.dialoguePieces[currentIndex]);
  37.         }
  38.         else dialoguePanel.SetActive(false);
  39.     }
  40.  
  41.     public void UpdateDialogueData(DialougeData_SO data)
  42.     {
  43.         currentData = data;
  44.         currentIndex = 0;//保证每次都是从头开始对话
  45.     }
  46.  
  47.  
  48.     public void UpdateMainDialogue(DialoguePiece piece)
  49.     {
  50.         dialoguePanel.SetActive(true);
  51.         currentIndex++;
  52.  
  53.         if (piece.image != null)
  54.         {
  55.             icon.enabled = true;
  56.             icon.sprite = piece.image;
  57.         }
  58.         else icon.enabled = false;
  59.  
  60.         mainText.text = "";
  61.         //mainText.text = piece.text;
  62.         mainText.DOText(piece.text, 1f);
  63.  
  64.         //如果后续还有对话就按next，没有就不按next
  65.         if (piece.options.Count == 0 && currentData.dialoguePieces.Count > 0)
  66.         {
  67.             nextButton.interactable = true;
  68.             nextButton.gameObject.SetActive(true);
  69.             //currentIndex++;//不应该放在这里++，应该每运行一次都让index++，因此应该放在上面
  70.         }
  71.         else
  72.         {
  73.             //nextButton.gameObject.SetActive(false);
  74.             nextButton.transform.GetChild(0).gameObject.SetActive(false);//让字看不见
  75.             nextButton.interactable = false;//并且删除交互功能 
  76.         }
  77.         CreateOptions(piece);//根据对话来创建选项
  78.     }
  79.  
  80.     void CreateOptions(DialoguePiece piece)
  81.     {
  82.         if (optionPanel.childCount > 0)//销毁旧的选项
  83.         {
  84.             for(int i = 0; i < optionPanel.childCount; i++)
  85.             {
  86.                 Destroy(optionPanel.GetChild(i).gameObject);
  87.             }
  88.         }
  89.  
  90.         //生成新的选项，并且调用选项，传入对话的选项信息，来更新option所显示的信息
  91.         for (int i = 0; i < piece.options.Count; i++)
  92.         {
  93.             var option = Instantiate(optionPrefab, optionPanel);
  94.             option.UpdateOption(piece,piece.options[i]);
  95.         }
  96.  
  97.     }
  98. }

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class OptionUI : MonoBehaviour
  7. {
  8.     public Text optionText;
  9.     private Button thisButton;
  10.     private DialoguePiece currentPiece;
  11.  
  12.  
  13.     private bool takeQuest;
  14.     private string nextPieceID;
  15.     void Awake() 
  16.     {
  17.         thisButton = GetComponent<Button>();
  18.         thisButton.onClick.AddListener(OnOptionClicked);
  19.     }
  20.  
  21.     public void UpdateOption(DialoguePiece piece,DialogueOption option)
  22.     {
  23.         currentPiece = piece;
  24.         optionText.text = option.text;
  25.         nextPieceID = option.targetID;
  26.         takeQuest = option.takeQuest;
  27.     }
  28.  
  29.  
  30.     public void OnOptionClicked()
  31.     {
  32.         if (currentPiece.quest != null)//如果当前选项含有任务
  33.         {
  34.             //则获取该任务
  35.             var newTask = new QuestManager.QuestTask
  36.             {
  37.                 questData = Instantiate(currentPiece.quest)//将quest信息实例化然后赋值给QuestTask类里面的questData
  38.             };
  39.             if (takeQuest)
  40.             {
  41.                 Debug.Log("takeQuest is true");
  42.  
  43.                 //判断是否在列表中
  44.                 if (QuestManager.Instance.HaveQuest(newTask.questData))
  45.                 {
  46.                     Debug.Log("Quest in list");
  47.  
  48.                     //判断是否完成，若完成则给予奖励
  49.                     if (QuestManager.Instance.GetTask(newTask.questData).IsComplete)
  50.                     {
  51.                         Debug.Log("任务完成,给予奖励");
  52.                         newTask.questData.GiveRewards();
  53.                         QuestManager.Instance.GetTask(newTask.questData).IsFinished = true;
  54.                     }
  55.                 }
  56.                 else
  57.                 {
  58.                     QuestManager.Instance.tasks.Add(newTask);
  59.                     //newTask.IsStarted = true;这样的做法并没有用，这样只是修改的临时变量
  60.                     QuestManager.Instance.GetTask(newTask.questData).IsStarted = true;
  61.                     //添加到任务列表
  62.  
  63.                     foreach (var requireItem in newTask.questData.RequireTargetName())
  64.                     {
  65.                         InventoryManager.Instance.CheckQuestItemInBag(requireItem);
  66.                     }
  67.                 }
  68.             }
  69.         }
  70.  
  71.         if (nextPieceID == "")
  72.         {
  73.             DialogueUI.Instance.dialoguePanel.SetActive(false);
  74.             return;
  75.         }
  76.         else
  77.         {
  78.             //用ID去获取下一个对话
  79.             DialogueUI.Instance.UpdateMainDialogue(DialogueUI.Instance.currentData.dialogueIndex[nextPieceID]);
  80.         }
  81.     }
  82.  
  83. }

任务部分

  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5. using System.Linq;
  6.  
  7. [CreateAssetMenu(fileName ="New Quest",menuName ="Quest/Quest Data")]
  8. public class QuestData_SO : ScriptableObject
  9. {
  10.     [System.Serializable]
  11.     public class QuestRequire
  12.     {
  13.         public string name;
  14.         public int requireAmount;
  15.         public int currentAmount;
  16.     }
  17.  
  18.  
  19.     public string questName;
  20.     [TextArea]
  21.     public string description;
  22.  
  23.     //需要三种任务完成的状态，npc才会有不同的反应
  24.     public bool isStarted;
  25.     public bool isComplete;
  26.     public bool isFinished;
  27.  
  28.     public List<QuestRequire> questRequires = new List<QuestRequire>();
  29.     public List<InventoryItem> rewards = new List<InventoryItem>();
  30.  
  31.     public void CheckQuestProgress()
  32.     {
  33.         var finishRequires = questRequires.Where(r => r.requireAmount <= r.currentAmount);
  34.         isComplete = finishRequires.Count() == questRequires.Count;
  35.  
  36.         if (isComplete)
  37.         {
  38.             Debug.Log("任务完成");
  39.         }
  40.     }
  41.  
  42.  
  43.     //当前任务需要收集/消灭的目标名字列表
  44.     public List<string> RequireTargetName()
  45.     {
  46.         List<string> targetNameList = new List<string>();
  47.         foreach(var require in questRequires)
  48.         {
  49.             targetNameList.Add(require.name);
  50.         }
  51.         return targetNameList;
  52.     }
  53.  
  54.  
  55.     public void GiveRewards()
  56.     {
  57.         foreach(var reward in rewards)
  58.         {
  59.             if (reward.amount < 0)
  60.             {
  61.                 int requireCount = Mathf.Abs(reward.amount);
  62.  
  63.                 //优先在背包里找是否有该物品，
  64.                 if (InventoryManager.Instance.QuestItemInBag(reward.itemData) != null)
  65.                 {
  66.                     //这种情况是背包里的东西不够，那就先在背包里扣除一部分，
  67.                     if (InventoryManager.Instance.QuestItemInBag(reward.itemData).amount <= requireCount)
  68.                     {
  69.                         requireCount -= InventoryManager.Instance.QuestItemInBag(reward.itemData).amount;//所需的数量减少
  70.                         InventoryManager.Instance.QuestItemInBag(reward.itemData).amount = 0;//背包里的商品扣除为0
  71.  
  72.                         //背包里东西不够，剩下的部分从行动栏里扣除
  73.                         if (InventoryManager.Instance.QuestItemInAction(reward.itemData) != null)
  74.                             InventoryManager.Instance.QuestItemInAction(reward.itemData).amount -= requireCount;
  75.  
  76.                     }
  77.                     //这种情况就是背包里的东西直接够，那直接扣除就好
  78.                     else
  79.                     {
  80.                         InventoryManager.Instance.QuestItemInBag(reward.itemData).amount -= requireCount;
  81.                     }
  82.  
  83.                 }
  84.                 //这种情况是背包里一点东西都没有，那就直接扣除行动栏里的物品
  85.                 else
  86.                 {
  87.                     InventoryManager.Instance.QuestItemInAction(reward.itemData).amount -= requireCount;
  88.                 }
  89.             }
  90.             else
  91.             {
  92.                 InventoryManager.Instance.inventoryData.AddItem(reward.itemData, reward.amount);
  93.             }
  94.  
  95.             InventoryManager.Instance.inventoryUI.RefreshUI();
  96.             InventoryManager.Instance.actionUI.RefreshUI();
  97.         }
  98.     }
  99.  
  100.  
  101.  
  102. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4.  
  5. [RequireComponent(typeof(DialogueController))]
  6. public class QuestGiver : MonoBehaviour
  7. {
  8.     DialogueController controller;
  9.     QuestData_SO currentQuest;
  10.  
  11.     public DialougeData_SO startDialogue;
  12.     public DialougeData_SO progressDialogue;
  13.     public DialougeData_SO completeDialogue;
  14.     public DialougeData_SO finishDialogue;
  15.  
  16.     private void Awake()
  17.     {
  18.         controller = GetComponent<DialogueController>(); 
  19.     }
  20.  
  21.     #region 获得任务状态
  22.     public bool IsStarted
  23.     {
  24.         get
  25.         {
  26.             if (QuestManager.Instance.HaveQuest(currentQuest))
  27.             {
  28.                 return QuestManager.Instance.GetTask(currentQuest).IsStarted;
  29.             }
  30.             else return false;
  31.         }
  32.     }
  33.  
  34.     public bool IsComplete
  35.     {
  36.         get
  37.         {
  38.             if (QuestManager.Instance.HaveQuest(currentQuest))
  39.             {
  40.                 return QuestManager.Instance.GetTask(currentQuest).IsComplete;
  41.             }
  42.             else return false;
  43.         }
  44.     }
  45.  
  46.     public bool IsFinished
  47.     {
  48.         get
  49.         {
  50.             if (QuestManager.Instance.HaveQuest(currentQuest))
  51.             {
  52.                 return QuestManager.Instance.GetTask(currentQuest).IsFinished;
  53.             }
  54.             else return false;
  55.         }
  56.     }
  57.     #endregion
  58.  
  59.     private void Start()
  60.     {
  61.         controller.currentData = startDialogue;
  62.         currentQuest = controller.currentData.GetQuest();
  63.     }
  64.  
  65.     //根据状态切换对话
  66.     void Update()
  67.     {
  68.         if (IsStarted)
  69.         {
  70.             if (IsComplete)
  71.             {
  72.                 controller.currentData = completeDialogue;
  73.             }
  74.             else
  75.             {
  76.                 controller.currentData = progressDialogue;
  77.             }
  78.         }
  79.  
  80.         if (IsFinished)
  81.         {
  82.             controller.currentData = finishDialogue;
  83.         }
  84.     }
  85. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using System.Linq;
  5.  
  6. public class QuestManager : Singleton<QuestManager>
  7. {
  8.     [System.Serializable]
  9.     public class QuestTask
  10.     {
  11.         public QuestData_SO questData;
  12.         public bool IsStarted {
  13.             get { return questData.isStarted; }
  14.             set { questData.isStarted = value; }
  15.         }
  16.  
  17.         public bool IsComplete
  18.         {
  19.             get { return questData.isComplete; }
  20.             set { questData.isComplete = value; }
  21.         }
  22.  
  23.         public bool IsFinished
  24.         {
  25.             get { return questData.isFinished; }
  26.             set { questData.isFinished  = value; }
  27.         }
  28.  
  29.     }
  30.  
  31.     public List<QuestTask> tasks = new List<QuestTask>();
  32.  
  33.     //敌人死亡，拾取物品时调用
  34.     public void UpdateQuestProgress(string requireName,int amount)
  35.     {
  36.         foreach(var task in tasks)
  37.         {
  38.  
  39.             if (task.IsFinished)
  40.                 continue;//为了避免已完成的任务受到影响
  41.  
  42.             var matchTask = task.questData.questRequires.Find(r => r.name == requireName);
  43.             if (matchTask != null)
  44.                 matchTask.currentAmount += amount;
  45.  
  46.             task.questData.CheckQuestProgress();
  47.         }
  48.     }
  49.  
  50.     public bool HaveQuest(QuestData_SO data)//判断是否有这个任务
  51.     {
  52.         //在头文件中引入Ling，可以用于查找链表中的内容
  53.         if (data != null)
  54.             return tasks.Any(q => q.questData.questName == data.questName);
  55.         else return false;
  56.     }
  57.  
  58.     //根据任务数据的名字查找链表中的某一个任务
  59.     public QuestTask GetTask(QuestData_SO data)
  60.     {
  61.         return tasks.Find(q => q.questData.questName == data.questName);
  62.     }
  63.  
  64.     private void Start()
  65.     {
  66.         LoadQuestManager();
  67.     }
  68.  
  69.  
  70.     public void SaveQuestManager()
  71.     {
  72.         PlayerPrefs.SetInt("QuestCount", tasks.Count);
  73.         for(int i = 0; i < tasks.Count; i++)
  74.         {
  75.             SaveManager.Instance.Save(tasks[i].questData, "task" + i);
  76.         }
  77.     }
  78.  
  79.  
  80.     //加载数据的方式是通过重新新创建一个SO，然后让SO读取数据，然后再加入到tasks链表当中
  81.     public void LoadQuestManager()
  82.     {
  83.         var quesCount = PlayerPrefs.GetInt("QuestCount");
  84.         for(int i = 0; i < quesCount; i++)
  85.         {
  86.             var newQuest = ScriptableObject.CreateInstance<QuestData_SO>();//
  87.             SaveManager.Instance.Load(newQuest, "task" + i);
  88.             tasks.Add(new QuestTask { questData = newQuest });
  89.         }
  90.     }
  91.  
  92. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class QuestNameButton : MonoBehaviour
  7. {
  8.     public Text questNameText;
  9.     public QuestData_SO currentData;
  10.     //public Text questContentText;
  11.  
  12.     public void SetupNameButton(QuestData_SO quesData)
  13.     {
  14.         currentData = quesData;
  15.  
  16.         if (quesData.isComplete)
  17.             questNameText.text = quesData.questName + "(完成)";
  18.         else
  19.             questNameText.text = quesData.questName;
  20.     }
  21.  
  22.     private void Awake()
  23.     {
  24.         GetComponent<Button>().onClick.AddListener(UpdateQuestContent);
  25.     }
  26.     void UpdateQuestContent()
  27.     {
  28.         //questContentText.text = currentData.description;
  29.         QuestUI.Instance.SetupRequireList(currentData);
  30.  
  31.         foreach(Transform item in QuestUI.Instance.rewardTransform)
  32.         {
  33.             Destroy(item.gameObject);
  34.         }
  35.  
  36.  
  37.         foreach(var item in currentData.rewards)//奖励可能不止一个所以需要循环列表
  38.         {
  39.             QuestUI.Instance.SetupRewardItem(item.itemData, item.amount);
  40.         }
  41.     }
  42. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class QuestRequirement : MonoBehaviour
  7. {
  8.     private Text requireName;
  9.     private Text progressNumber;
  10.  
  11.  
  12.     private void Awake()
  13.     {
  14.         requireName = GetComponent<Text>();
  15.         progressNumber = transform.GetChild(0).GetComponent<Text>();
  16.     }
  17.  
  18.     public void SetupRequirement(string name,int amount,int currentAmount)
  19.     {
  20.         requireName.text = name;
  21.         progressNumber.text = currentAmount.ToString() + "/" + amount.ToString();
  22.     }
  23.  
  24.     public void SetupRequirement(string name, bool isFinished)
  25.     {
  26.         if (isFinished)
  27.         {
  28.             requireName.text = name;
  29.             progressNumber.text = "完成";
  30.             requireName.color = Color.gray;
  31.             progressNumber.color = Color.gray;
  32.         }
  33.     }
  34.  
  35. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.UI;
  5.  
  6. public class QuestUI : Singleton<QuestUI>
  7. {
  8.     [Header("Elements")]
  9.     public GameObject quesPanel;
  10.     public ItemToolTip tooltip;
  11.     bool isOpen;
  12.  
  13.     [Header("Quest Name")]
  14.     public RectTransform questListTransform;
  15.     public QuestNameButton questNameButton;
  16.  
  17.     [Header("Text Content")]
  18.     public Text quesContentText;
  19.  
  20.     [Header("Requirement")]
  21.     public RectTransform requireTransform;
  22.     public QuestRequirement requirement;
  23.  
  24.     [Header("Reward Panel")]
  25.     public RectTransform rewardTransform;
  26.     public ItemUI rewardUI;
  27.  
  28.     private void Update()
  29.     {
  30.         if (Input.GetKeyDown(KeyCode.Q))
  31.         {
  32.             isOpen = !isOpen;
  33.             quesPanel.SetActive(isOpen);
  34.             quesContentText.text = string.Empty;
  35.             SetupQuestList();
  36.         }
  37.  
  38.  
  39.         if (!isOpen)
  40.             tooltip.gameObject.SetActive(false);
  41.     }
  42.  
  43.     public void SetupQuestList()
  44.     {
  45.         //清除原来已有的任务
  46.         foreach(Transform item in questListTransform)
  47.         {
  48.             Destroy(item.gameObject);
  49.         }
  50.         foreach(Transform item in rewardTransform)
  51.         {
  52.             Destroy(item.gameObject);
  53.         }
  54.         foreach (Transform item in requireTransform)
  55.         {
  56.             Destroy(item.gameObject);
  57.         }
  58.  
  59.         //遍历列表中的list，接取任务
  60.         foreach(var task in QuestManager.Instance.tasks)
  61.         {
  62.             var newTask = Instantiate(questNameButton, questListTransform);
  63.             newTask.SetupNameButton(task.questData);
  64.             //newTask.questContentText = quesContentText;
  65.         }
  66.  
  67.  
  68.     }
  69.  
  70.     public void SetupRequireList(QuestData_SO questData)
  71.     {
  72.         quesContentText.text = questData.description;
  73.         //将涉及到QuestNameButton中的三处questContentText关闭，不使用在里面传东西然后赋值的形式了，改为在此处直接修改
  74.  
  75.         foreach (Transform item in requireTransform)
  76.         {
  77.             Destroy(item.gameObject);
  78.         }
  79.         foreach(var require in questData.questRequires)
  80.         {
  81.             var q = Instantiate(requirement, requireTransform);
  82.             if (questData.isFinished)
  83.                 q.SetupRequirement(require.name, true);
  84.             else
  85.                 q.SetupRequirement(require.name, require.requireAmount, require.currentAmount);
  86.         }
  87.     }
  88.  
  89.     public void SetupRewardItem(ItemData_SO itemData,int amount)
  90.     {
  91.         var item = Instantiate(rewardUI, rewardTransform);
  92.         item.SetupItemUI(itemData, amount);
  93.     }
  94.  
  95. }
  1. using System.Collections;
  2. using System.Collections.Generic;
  3. using UnityEngine;
  4. using UnityEngine.EventSystems;
  5.  
  6. public class ShowTooltip : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
  7. {
  8.     private ItemUI currentItemUI;
  9.  
  10.     void Awake()
  11.     {
  12.         currentItemUI = GetComponent<ItemUI>();
  13.     }
  14.     public void OnPointerEnter(PointerEventData eventData)
  15.     {
  16.         Debug.Log("mouse in slot");
  17.         QuestUI.Instance.tooltip.gameObject.SetActive(true);
  18.         QuestUI.Instance.tooltip.SetupTooltip(currentItemUI.currentItemData);
  19.     }
  20.  
  21.     public void OnPointerExit(PointerEventData eventData)
  22.     {
  23.         QuestUI.Instance.tooltip.gameObject.SetActive(false);
  24.     }
  25. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/90701
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号