[CreateAssetMenu]
public class Item : ScriptableObject
{
    public Sprite sprite;
}

public const int numItemSlots = 4; // The number of items that can be carried.  This is a constant so that the number of Images and Items are always the same. 槽数为UI中物品数

public Image[] itemImages = new Image[numItemSlots]; // The Image components that display the Items.将引用图像组件，初始化为相同大小数组
public Item[] items = new Item[numItemSlots]; // The Items that are carried by the player.

// This function is called by the PickedUpItemReaction in order to add an item to the inventory.
    public void AddItem(Item itemToAdd)
    {
        // Go through all the item slots...
        for (int i = 0; i < items.Length; i++)
        {
            // ... if the item slot is empty...
            if (items[i] == null)
            {
                // ... set it to the picked up item and set the image component to display the item's sprite.
                items[i] = itemToAdd;
                itemImages[i].sprite = itemToAdd.sprite;
                itemImages[i].enabled = true;
                return;
            }
        }
    }

// This function is called by the LostItemReaction in order to remove an item from the inventory.
    public void RemoveItem (Item itemToRemove)
    {
        // Go through all the item slots...
        for (int i = 0; i < items.Length; i++)
        {
            // ... if the item slot has the item to be removed...
            if (items[i] == itemToRemove)
            {
                // ... set the item slot to null and set the image component to display nothing.
                items[i] = null;
                itemImages[i].sprite = null;
                itemImages[i].enabled = false;
                return;
            }
        }
    }

using UnityEditor;

public class InventoryEditor : Editor

[CustomEditor(typeof(Inventory))]

private bool[] showItemSlots = new bool[Inventory.numItemSlots];    // Whether the GUI for each Item slot is expanded.每个项目槽是否展开显示image组件和item
    private SerializedProperty itemImagesProperty;             // Represents the array of Image components to display the Items.代表itemImages数组
    private SerializedProperty itemsProperty;                  // Represents the array of Items. Items数组

//给出序列化属性要查找的名字，名字字符串可与虚查找原名相同（变量名为：属性所在类Prop字段名）
    private const string inventoryPropItemImagesName = "itemImages";    // The name of the field that is an array of Image components.
    private const string inventoryPropItemsName = "items";              // The name of the field that is an array of Items.

private void OnEnable ()
    {
        // Cache the SerializedProperties.
        itemImagesProperty = serializedObject.FindProperty (inventoryPropItemImagesName);
        itemsProperty = serializedObject.FindProperty (inventoryPropItemsName);
    }

public override void OnInspectorGUI ()
    {
        // Pull all the information from the target into the serializedObject. 确保序列化对象中信息与之相同
        serializedObject.Update ();

// Display GUI for each Item slot.
        for (int i = 0; i < Inventory.numItemSlots; i++)
        {
            ItemSlotGUI (i);
        }

// Push all the information from the serializedObject back into the target.
        serializedObject.ApplyModifiedProperties ();//改变目标对象
    }

private void ItemSlotGUI (int index)
    {
        EditorGUILayout.BeginVertical (GUI.skin.box);//垂直安排接下来的项，样式参数GUI.skin.box为所有布局组中的都在box中显示，
        EditorGUI.indentLevel++;//缩进
        
        // Display a foldout to determine whether the GUI should be shown or not.显示折叠index索引（Item Slot0/1/2/3）
        showItemSlots[index] = EditorGUILayout.Foldout (showItemSlots[index], "Item slot " + index);

// If the foldout is open then display default GUI for the specific elements in each array.点击时改变当前展开情况
        if (showItemSlots[index])//如果状态为展开，则显示
        {
            EditorGUILayout.PropertyField (itemImagesProperty.GetArrayElementAtIndex (index));//显示默认值，不在每个item中显示完整的数组，GetArrayElementAtIndex找到子对象元素，显示特定的数组元素

//使用序列化属性的默认值PropertyField
            EditorGUILayout.PropertyField (itemsProperty.GetArrayElementAtIndex (index));
        }

EditorGUI.indentLevel--;//退回缩进
        EditorGUILayout.EndVertical ();//结束竖直布局组，没有其他重叠GUI
    }

using UnityEngine;

// This class is used to determine whether or not Reactions
// should happen.（判断是否要发生反应）  Instances of Condition exist in two places:（Condition的实例在两个地方存在）
// as assets which are part of the AllConditions asset and as
// part of ConditionCollections.（AllConditions asset和ConditionCollections的一部分-assets）  

//The Conditions that are part of the AllConditions asset are those that are set by
// Reactions and reflect the state of the game.（AllConditions asset中的Conditions通过Reactions设置，反应了游戏状态）  

//Those that are on ConditionCollections are compared to the
// AllConditions asset to determine whether other Reactions
// should happen.（ConditionCollections与AllConditions asset比较，确定是否其他反应需要发生）
public class Condition : ScriptableObject
{
    public string description;      // A description of the Condition, for example 'BeamsOff'.
    public bool satisfied;          // Whether or not the Condition has been satisfied, for example are the beams off?
    public int hash;                // A number which represents the description.  This is used to compare ConditionCollection Conditions to AllConditions Conditions.
}

public class AllConditions : ResettableScriptableObject

public Condition[] conditions;// All the Conditions that exist in the game.条件数组

private static AllConditions instance;// The singleton instance.单例的实例，引用自身，每次访问AllConditions类，可以用AllConditions. instance找到

private const string loadPath = "AllConditions";// The path within the Resources folder that 存储路径

public static AllConditions Instance// The public accessor for the singleton instance.私有单例的公共访问器（get&set）
    {
        get
        {
// If the instance is currently null, try to find an AllConditions instance already in memory.如果没有实例，在memory找AllConditions实例
            if (!instance)
                instance = FindObjectOfType<AllConditions> ();
            // If the instance is still null, try to load it from the Resources folder.在资源文件夹加载
            if (!instance)
                instance = Resources.Load<AllConditions> (loadPath);
            // If the instance is still null, report that it has not been created yet.资源文件里也没有，报错-需要创建
            if (!instance)
                Debug.LogError ("AllConditions has not been created yet.  Go to Assets > Create > AllConditions.");
            return instance;
        }
        set { instance = value; }
    }

// This function will be called at Start once per run of the game.每次加载游戏时调用
    public override void Reset ()
    {
        // If there are no conditions, do nothing.
        if (conditions == null)
            return;

// Set all of the conditions to not satisfied.设置所有条件为初始（未达成）状态
        for (int i = 0; i < conditions.Length; i++)
        {
            conditions[i].satisfied = false;
        }
    }

// This is called from ConditionCollections when they are being checked by an Interactable that has been clicked on.用来检测条件的静态函数，比较场景inspector设置的条件，ConditionCollections传入需要的条件
    public static bool CheckCondition (Condition requiredCondition)­­­­
    {
        // Cache the condition array.
        Condition[] allConditions = Instance.conditions;//取出实例中的条件
        Condition globalCondition = null;//想要去比较的全局条件
        
        // If there is at least one condition...列表有条件
        if (allConditions != null && allConditions[0] != null)
        {
            // ... go through all the conditions...
            for (int i = 0; i < allConditions.Length; i++)
            {
                // ... and if they match the given condition then this is the global version of the requiredConditiond. 找到列表中那个是需要比较的条件
                if (allConditions[i].hash == requiredCondition.hash)
                    globalCondition = allConditions[i];
            }
        }

// If by this point a globalCondition hasn't been found then return false.如果没有全局条件，没有找到匹配的条件，返回检验条件为假
        if (!globalCondition)
            return false;

// Return true if the satisfied states match, false otherwise.找到条件后将其与需要的条件对比
        return globalCondition.satisfied == requiredCondition.satisfied;
    }

public class ConditionCollection : ScriptableObject

public string description;                                  // Description of the ConditionCollection.  This is used purely for identification in the inspector.在属性栏识别条件是关于什么的
    public Condition[] requiredConditions = new Condition[0];   // The Conditions that need to be met in order for the ReactionCollection to React.条件数组，初始化，就不会返回null
    public ReactionCollection reactionCollection;               // Reference to the ReactionCollection that will React should all the Conditions be met.引用ReactionCollection，需要所有条件被满足

// This is called by the Interactable one at a time for each of its ConditionCollections until one returns true.由可交互物调用，依次检查每个ConditionCollections，直到返回true
    public bool CheckAndReact()
    {
        // Go through all Conditions...循环所有需要条件
        for (int i = 0; i < requiredConditions.Length; i++)
        {
            // ... and check them against the AllConditions version of the Condition.  If they don't have the same satisfied flag, return false.用AllConditions检查添加，如果没有满足，返回假
            if (!AllConditions.CheckCondition (requiredConditions[i]))
                return false;
        }

// If there is an ReactionCollection assigned, call its React function. 如果有条件匹配成功，调用它的反应
        if(reactionCollection)
            reactionCollection.React();

// A Reaction happened so return true.
        return true;
    }

using UnityEngine;

// This script acts as a collection for all the individual Reactions that happen as a result of an interaction.交互后发生的单反应的集合
public class ReactionCollection : MonoBehaviour
{
    public Reaction[] reactions = new Reaction[0];      // Array of all the Reactions to play when React is called.被调用时的反应数组

private void Start ()
    {
        // Go through all the Reactions and call their Init function.初始化所有反应
        for (int i = 0; i < reactions.Length; i++)
        {
            // The DelayedReaction 'hides' the Reaction's Init function with it's own.延迟反应的初始化在它自己那里写
            // This means that we have to try to cast the Reaction to a DelayedReaction and then if it exists call it's Init function.将反应转换为延迟反应，如果存在就初始化
            // Note that this mainly done to demonstrate hiding and not especially for functionality.（这样做主要是为了演示隐藏）
            DelayedReaction delayedReaction = reactions[i] as DelayedReaction;

if (delayedReaction)
                delayedReaction.Init ();
            else
                reactions[i].Init ();
        }
    }

public void React ()
    {
        // Go through all the Reactions and call their React function.调用所有反应函数
        for (int i = 0; i < reactions.Length; i++)
        {
            // The DelayedReaction hides the Reaction.React function.延迟反应隐藏反应函数
            // Note again this is mainly done for demonstration purposes.
            DelayedReaction delayedReaction = reactions[i] as DelayedReaction;

if(delayedReaction)
                delayedReaction.React (this);
            else
                reactions[i].React (this);
        }
    }
}

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

// This is the Editor for the ReactionCollection MonoBehaviour.这是反应集合ReactionCollection的编辑器
// However, since the ReactionCollection contains many Reactions, it requires many sub-editors to display them.但由于ReactionCollection包含多种反应，需要子编辑器展示
//more details see the EditorWithSubEditors class.子编辑器类
// There are two ways of adding Reactions to the ReactionCollection:两种方法可将反应添加到反应集合
// a type selection popup with confirmation button and a drag and drop area.  带确认按钮的弹出窗，和拖放区域Details on these are found below.
[CustomEditor(typeof(ReactionCollection))]
public class ReactionCollectionEditor : EditorWithSubEditors<ReactionEditor, Reaction>
{
    private ReactionCollection reactionCollection;          // Reference to the target.目标引用
    private SerializedProperty reactionsProperty;           // Represents the array of Reactions.反应数组

private Type[] reactionTypes;                           // All the non-abstract types which inherit from Reaction.  This is used for adding new Reactions. 所有继承反应的非抽象类型。 这用于添加新的反应
    private string[] reactionTypeNames;                     // The names of all appropriate Reaction types.反应类型名称
    private int selectedIndex;                              // The index of the currently selected Reaction type.当前选定的反应类型索引

private const float dropAreaHeight = 50f;               // Height in pixels of the area for dropping scripts.删除脚本的区域的高度
    private const float controlSpacing = 5f;                // Width in pixels between the popup type selection and drop area. 弹出类型选择和放置区域之间的宽度 (以像素为单位)。
    private const string reactionsPropName = "reactions";   // Name of the field for the array of Reactions.反应数组的字段名

private readonly float verticalSpacing = EditorGUIUtility.standardVerticalSpacing;
                                                            // Caching the vertical spacing between GUI elements. gui 元素之间的垂直间距

private void OnEnable ()
    {
        // Cache the target.得到目标
        reactionCollection = (ReactionCollection)target;

// Cache the SerializedProperty序列化对象
        reactionsProperty = serializedObject.FindProperty(reactionsPropName);

// If new editors are required for Reactions, create them.如果反应需要新的编辑器，则创建
        CheckAndCreateSubEditors (reactionCollection.reactions);

// Set the array of types and type names of subtypes of Reaction.设置反应子类型的数组类型和类型名
        SetReactionNamesArray ();
    }

private void OnDisable ()
    {
        // Destroy all the subeditors.销毁所有子编辑器
        CleanupEditors ();
    }

// This is called immediately after each ReactionEditor is created.每个反应编辑器创建时立即调用
    protected override void SubEditorSetup (ReactionEditor editor)
    {
        // Make sure the ReactionEditors have a reference to the array that contains their targets. 确保反应编辑器具有包含其目标的数组的引用。
        editor.reactionsProperty = reactionsProperty;
    }

public override void OnInspectorGUI ()
    {
        // Pull all the information from the target into the serializedObject.从目标到序列化对象同步信息
        serializedObject.Update ();

// If new editors for Reactions are required, create them.创建新反应编辑器
        CheckAndCreateSubEditors(reactionCollection.reactions);

// Display all the Reactions.展示所有反应
        for (int i = 0; i < subEditors.Length; i++)
        {
            subEditors[i].OnInspectorGUI ();
        }

// If there are Reactions, add a space.若存在反应，加空格
        if (reactionCollection.reactions.Length > 0)
        {
            EditorGUILayout.Space();
            EditorGUILayout.Space ();
        }

// Create a Rect for the full width of the inspector with enough height for the drop area.创建足够宽高的放置区域（与inspector同宽）
        Rect fullWidthRect = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, GUILayout.Height(dropAreaHeight + verticalSpacing));

// Create a Rect for the left GUI controls.为左侧控制创建方框
        Rect leftAreaRect = fullWidthRect;

// It should be in half a space from the top.到顶部有一半空间
        leftAreaRect.y += verticalSpacing * 0.5f;

// The width should be slightly less than half the width of the inspector.宽度略小于inspector一半
        leftAreaRect.width *= 0.5f;
        leftAreaRect.width -= controlSpacing * 0.5f;

// The height should be the same as the drop area.高度与放置区域同
        leftAreaRect.height = dropAreaHeight;

// Create a Rect for the right GUI controls that is the same as the left Rect except...右侧GUI控件与左侧类似
        Rect rightAreaRect = leftAreaRect;

// ... it should be on the right.但位置不同
        rightAreaRect.x += rightAreaRect.width + controlSpacing;

// Display the GUI for the type popup and button on the left.左侧显示类型弹窗和按钮
        TypeSelectionGUI (leftAreaRect);

// Display the GUI for the drag and drop area on the right.展示右侧拖放区域的GUI
        DragAndDropAreaGUI (rightAreaRect);

// Manage the events for dropping on the right area.管理放置在右侧区域的事件
        DraggingAndDropping(rightAreaRect, this);

// Push the information back from the serializedObject to the target.将信息从序列化对象传回目标
        serializedObject.ApplyModifiedProperties ();
    }

private void TypeSelectionGUI (Rect containingRect)
    {
        // Create Rects for the top and bottom half.
        Rect topHalf = containingRect;
        topHalf.height *= 0.5f;
        Rect bottomHalf = topHalf;
        bottomHalf.y += bottomHalf.height;

// Display a popup in the top half showing all the reaction types.上半部分显示弹窗，展示所有反应类型
        selectedIndex = EditorGUI.Popup(topHalf, selectedIndex, reactionTypeNames);

// Display a button in the bottom half that if clicked...下半部分显示按钮，点击按钮
        if (GUI.Button (bottomHalf, "Add Selected Reaction"))
        {
            // ... finds the type selected by the popup, creates an appropriate reaction and adds it to the array.查找窗口选择的类型，创建适当的反应并将其添加到数组中。
            Type reactionType = reactionTypes[selectedIndex];
            Reaction newReaction = ReactionEditor.CreateReaction (reactionType);
            reactionsProperty.AddToObjectArray (newReaction);
        }
    }

private static void DragAndDropAreaGUI (Rect containingRect)
    {
        // Create a GUI style of a box but with middle aligned text and button text color.创建GUI框样式，文本居中，按钮文本颜色
        GUIStyle centredStyle = GUI.skin.box;
        centredStyle.alignment = TextAnchor.MiddleCenter;
        centredStyle.normal.textColor = GUI.skin.button.normal.textColor;

// Draw a box over the area with the created style.绘制框，应用创建的样式
        GUI.Box (containingRect, "Drop new Reactions here", centredStyle);
    }

private static void DraggingAndDropping (Rect dropArea, ReactionCollectionEditor editor)
    {
        // Cache the current event.当前事件
        Event currentEvent = Event.current;

// If the drop area doesn't contain the mouse then return.防止区域没有mouse则返回
        if (!dropArea.Contains (currentEvent.mousePosition))
            return;

switch (currentEvent.type)
        {
            // If the mouse is dragging something...鼠标拖拽
            case EventType.DragUpdated:

// ... change whether or not the drag *can* be performed by changing the visual mode of the cursor based on the IsDragValid function.改变能否拖拽显示，用IsDragValid方法改变鼠标显示模式
                DragAndDrop.visualMode = IsDragValid () ? DragAndDropVisualMode.Link : DragAndDropVisualMode.Rejected;

// Make sure the event isn't used by anything else.保证事件没被其他内容使用
                currentEvent.Use ();

break;

// If the mouse was dragging something and has released...鼠标拖拽并释放
            case EventType.DragPerform:
                
                // ... accept the drag event.接收拖拽事件
                DragAndDrop.AcceptDrag();
                
                // Go through all the objects that were being dragged...遍历所有被拖拽对象
                for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
                {
                    // ... and find the script asset that was being dragged...找到被拖的脚本asset
                    MonoScript script = DragAndDrop.objectReferences[i] as MonoScript;

// ... then find the type of that Reaction...找到反应类型
                    Type reactionType = script.GetClass();

// ... and create a Reaction of that type and add it to the array.创建该类型反应，加到数组
                    Reaction newReaction = ReactionEditor.CreateReaction (reactionType);
                    editor.reactionsProperty.AddToObjectArray (newReaction);
                }

// Make sure the event isn't used by anything else.
                currentEvent.Use();

break;
        }
    }

private static bool IsDragValid ()
    {
        // Go through all the objects being dragged...遍历被拖对象
        for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
        {
            // ... and if any of them are not script assets, return that the drag is invalid.如果不是脚本assets，返回无效拖动
            if (DragAndDrop.objectReferences[i].GetType () != typeof (MonoScript))
                return false;
            
            // Otherwise find the class contained in the script asset.在脚本asset找到类型
            MonoScript script = DragAndDrop.objectReferences[i] as MonoScript;
            Type scriptType = script.GetClass ();

// If the script does not inherit from Reaction, return that the drag is invalid.不继承反应Reaction，拖动无效
            if (!scriptType.IsSubclassOf (typeof(Reaction)))
                return false;

// If the script is an abstract, return that the drag is invalid.如果脚本是抽象类，拖动无效
            if (scriptType.IsAbstract)
                return false;
        }

// If none of the dragging objects returned that the drag was invalid, return that it is valid.如果没有返回无效拖动对象返回则有效
        return true;
    }

private void SetReactionNamesArray ()
    {
        // Store the Reaction type.存储反应类型
        Type reactionType = typeof(Reaction);

// Get all the types that are in the same Assembly (all the runtime scripts) as the Reaction type. 获取与 "反应" 类型位于同一程序集 (所有运行时脚本) 中的所有类型。
        Type[] allTypes = reactionType.Assembly.GetTypes();

// Create an empty list to store all the types that are subtypes of Reaction.创建空列表存储所有子反应类型
        List<Type> reactionSubTypeList = new List<Type>();

// Go through all the types in the Assembly...遍历所有类型
        for (int i = 0; i < allTypes.Length; i++)
        {
            // ... and if they are a non-abstract subclass of Reaction then add them to the list.是不抽象的反应子类则添加
            if (allTypes[i].IsSubclassOf(reactionType) && !allTypes[i].IsAbstract)
            {
                reactionSubTypeList.Add(allTypes[i]);
            }
        }

// Convert the list to an array and store it.列表转换为数组并存储
        reactionTypes = reactionSubTypeList.ToArray();

// Create an empty list of strings to store the names of the Reaction types.创建空列表存储反应类型名
        List<string> reactionTypeNameList = new List<string>();

// Go through all the Reaction types and add their names to the list.添加反应类型名到数组
        for (int i = 0; i < reactionTypes.Length; i++)
        {
            reactionTypeNameList.Add(reactionTypes[i].Name);
        }

// Convert the list to an array and store it.转换为数组
        reactionTypeNames = reactionTypeNameList.ToArray();
    }
}

using UnityEngine;

// This Reaction has a delay but is not a DelayedReaction. This is because the TextManager component handles the delay instead of the Reaction.这个反应有延迟，但不是延迟反应，因为TextManager组件处理延迟而不是反应类产生
public class TextReaction : Reaction//继承反应基类
{
    public string message;                      // The text to be displayed to the screen.显示文本到屏幕
    public Color textColor = Color.white;       // The color of the text when it's displayed (different colors for different characters talking).颜色
    public float delay;                         // How long after the React function is called before the text is displayed.显示文字前调用反应方法延迟的时间

private TextManager textManager;            // Reference to the component to display the text.引用显示文字组件

protected override void SpecificInit()//特殊类型初始化
    {
        textManager = FindObjectOfType<TextManager> ();
    }

protected override void ImmediateReaction()
    {
        textManager.DisplayMessage (message, textColor, delay);
    }
}

using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(TextReaction))]//target
public class TextReactionEditor : ReactionEditor
{
    private SerializedProperty messageProperty;         // Represents the string field which is the message to be displayed. 要显示的消息的字符串字段
    private SerializedProperty textColorProperty;       // Represents the color field which is the color of the message to be displayed.文本颜色属性
    private SerializedProperty delayProperty;           // Represents the float field which is the delay before the messaage is displayed延迟属性

private const float messageGUILines = 3f;           // How many lines tall the GUI for the message field should be.消息字段的GUI行数
    private const float areaWidthOffset = 19f;          // Offset to account for the message GUI being made of two GUI calls.  It makes the GUI line up.偏移，使GUI排成一行
    private const string textReactionPropMessageName = "message";
                                                        // The name of the field which is the message to be written to the screen.写到屏幕的消息字段的名字
    private const string textReactionPropTextColorName = "textColor";
                                                        // The name of the field which is the color of the message to be written to the screen.颜色字段名字
    private const string textReactionPropDelayName = "delay";
                                                        // The name of the field which is the delay before the message is written to the screen.延迟

protected override void Init ()
    {
        // Cache all the SerializedProperties.获取所有序列化属性
        messageProperty = serializedObject.FindProperty (textReactionPropMessageName);
        textColorProperty = serializedObject.FindProperty (textReactionPropTextColorName);
        delayProperty = serializedObject.FindProperty (textReactionPropDelayName);
    }

protected override void DrawReaction ()
    {
        EditorGUILayout.BeginHorizontal ();
        
        // Display a label whose width is offset such that the TextArea lines up with the rest of the GUI.显示标签，宽度是offset，使TextArea与其余GUI对齐
        EditorGUILayout.LabelField ("Message", GUILayout.Width (EditorGUIUtility.labelWidth - areaWidthOffset));

// Display an interactable GUI element for the text of the message to be displayed over several lines.在几行上显示消息文本的interactable的GUI元素
        messageProperty.stringValue = EditorGUILayout.TextArea (messageProperty.stringValue, GUILayout.Height (EditorGUIUtility.singleLineHeight * messageGUILines));
        EditorGUILayout.EndHorizontal ();

// Display default GUI for the text color and the delay.文本颜色和延迟的显示默认GUI
        EditorGUILayout.PropertyField (textColorProperty);
        EditorGUILayout.PropertyField (delayProperty);
    }

protected override string GetFoldoutLabel ()
    {
        return "Text Reaction";
    }
}

using System.Collections;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;

public class PlayerMovement : MonoBehaviour
{
    public Animator animator;                   // Reference to the animator component.
    public NavMeshAgent agent;                  // Reference to the nav mesh agent component.
    public SaveData playerSaveData;             // Reference to the save data asset containing the player's starting position.
    public float turnSmoothing = 15f;           // The amount of smoothing applied to the player's turning using spherical interpolation.
    public float speedDampTime = 0.1f;          // The approximate amount of time it takes for the speed parameter to reach its value upon being set.
    public float slowingSpeed = 0.175f;         // The speed the player moves as it reaches close to it's destination.
    public float turnSpeedThreshold = 0.5f;     // The speed beyond which the player can move and turn normally.
    public float inputHoldDelay = 0.5f;         // How long after reaching an interactable before input is allowed again.

private Interactable currentInteractable;   // The interactable that is currently being headed towards.
    private Vector3 destinationPosition;        // The position that is currently being headed towards, this is the interactionLocation of the currentInteractable if it is not null.
    private bool handleInput = true;            // Whether input is currently being handled.
    private WaitForSeconds inputHoldWait;       // The WaitForSeconds used to make the user wait before input is handled again.

private readonly int hashSpeedPara = Animator.StringToHash("Speed");
                                                // An hash representing the Speed animator parameter, this is used at runtime in place of a string.
    private readonly int hashLocomotionTag = Animator.StringToHash("Locomotion");
                                                // An hash representing the Locomotion tag, this is used at runtime in place of a string.

public const string startingPositionKey = "starting position";
                                                // The key used to retrieve the starting position from the playerSaveData.

private const float stopDistanceProportion = 0.1f;
                                                // The proportion of the nav mesh agent's stopping distance within which the player stops completely.
    private const float navMeshSampleDistance = 4f;
                                                // The maximum distance from the nav mesh a click can be to be accepted.

private void Start()
    {
        // The player will be rotated by this script so the nav mesh agent should not rotate it.
        agent.updateRotation = false;

// Create the wait based on the delay.
        inputHoldWait = new WaitForSeconds (inputHoldDelay);

// Load the starting position from the save data and find the transform from the starting position's name.
        string startingPositionName = "";
        playerSaveData.Load(startingPositionKey, ref startingPositionName);
        Transform startingPosition = StartingPosition.FindStartingPosition(startingPositionName);

// Set the player's position and rotation based on the starting position.
        transform.position = startingPosition.position;
        transform.rotation = startingPosition.rotation;

// Set the initial destination as the player's current position.
        destinationPosition = transform.position;
    }

private void OnAnimatorMove()
    {
        // Set the velocity of the nav mesh agent (which is moving the player) based on the speed that the animator would move the player.
        agent.velocity = animator.deltaPosition / Time.deltaTime;
    }

private void Update()
    {
        // If the nav mesh agent is currently waiting for a path, do nothing.
        if (agent.pathPending)
            return;

// Cache the speed that nav mesh agent wants to move at.
        float speed = agent.desiredVelocity.magnitude;
        
        // If the nav mesh agent is very close to it's destination, call the Stopping function.
        if (agent.remainingDistance <= agent.stoppingDistance * stopDistanceProportion)
            Stopping (out speed);
        // Otherwise, if the nav mesh agent is close to it's destination, call the Slowing function.
        else if (agent.remainingDistance <= agent.stoppingDistance)
            Slowing(out speed, agent.remainingDistance);
        // Otherwise, if the nav mesh agent wants to move fast enough, call the Moving function.
        else if (speed > turnSpeedThreshold)
            Moving ();
        
        // Set the animator's Speed parameter based on the (possibly modified) speed that the nav mesh agent wants to move at.
        animator.SetFloat(hashSpeedPara, speed, speedDampTime, Time.deltaTime);
    }

// This is called when the nav mesh agent is very close to it's destination.
    private void Stopping (out float speed)
    {
        // Stop the nav mesh agent from moving the player.
        agent.isStopped = true;

// Set the player's position to the destination.
        transform.position = destinationPosition;

// Set the speed (which is what the animator will use) to zero.
        speed = 0f;

// If the player is stopping at an interactable...
        if (currentInteractable)
        {
            // ... set the player's rotation to match the interactionLocation's.
            transform.rotation = currentInteractable.interactionLocation.rotation;

// Interact with the interactable and then null it out so this interaction only happens once.
            currentInteractable.Interact();
            currentInteractable = null;

// Start the WaitForInteraction coroutine so that input is ignored briefly.
            StartCoroutine (WaitForInteraction ());
        }
    }

// This is called when the nav mesh agent is close to its destination but not so close it's position should snap to it's destination.
    private void Slowing (out float speed, float distanceToDestination)
    {
        // Although the player will continue to move, it will be controlled manually so stop the nav mesh agent.
        agent.isStopped = true;

// Find the distance to the destination as a percentage of the stopping distance.
        float proportionalDistance = 1f - distanceToDestination / agent.stoppingDistance;

// The target rotation is the rotation of the interactionLocation if the player is headed to an interactable, or the player's own rotation if not.
        Quaternion targetRotation = currentInteractable ? currentInteractable.interactionLocation.rotation : transform.rotation;

// Interpolate the player's rotation between itself and the target rotation based on how close to the destination the player is.
        transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, proportionalDistance);

// Move the player towards the destination by an amount based on the slowing speed.
        transform.position = Vector3.MoveTowards(transform.position, destinationPosition, slowingSpeed * Time.deltaTime);

// Set the speed (for use by the animator) to a value between slowing speed and zero based on the proportional distance.
        speed = Mathf.Lerp(slowingSpeed, 0f, proportionalDistance);
    }

// This is called when the player is moving normally.  In such cases the player is moved by the nav mesh agent, but rotated by this function.
    private void Moving ()
    {
        // Create a rotation looking down the nav mesh agent's desired velocity.
        Quaternion targetRotation = Quaternion.LookRotation(agent.desiredVelocity);

// Interpolate the player's rotation towards the target rotation.
        transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, turnSmoothing * Time.deltaTime);
    }

// This function is called by the EventTrigger on the scene's ground when it is clicked on.
    public void OnGroundClick(BaseEventData data)
    {
        // If the handle input flag is set to false then do nothing.
        if(!handleInput)
            return;
        
        // The player is no longer headed for an interactable so set it to null.
        currentInteractable = null;

// This function needs information about a click so cast the BaseEventData to a PointerEventData.
        PointerEventData pData = (PointerEventData)data;

// Try and find a point on the nav mesh nearest to the world position of the click and set the destination to that.
        NavMeshHit hit;
        if (NavMesh.SamplePosition (pData.pointerCurrentRaycast.worldPosition, out hit, navMeshSampleDistance, NavMesh.AllAreas))
            destinationPosition = hit.position;
        else
            // In the event that the nearest position cannot be found, set the position as the world position of the click.
            destinationPosition = pData.pointerCurrentRaycast.worldPosition;

// Set the destination of the nav mesh agent to the found destination position and start the nav mesh agent going.
        agent.SetDestination(destinationPosition);
        agent.isStopped = false;
    }

// This function is called by the EventTrigger on an Interactable, the Interactable component is passed into it.
    public void OnInteractableClick(Interactable interactable)
    {
        // If the handle input flag is set to false then do nothing.
        if(!handleInput)
            return;

// Store the interactble that was clicked on.
        currentInteractable = interactable;

// Set the destination to the interaction location of the interactable.
        destinationPosition = currentInteractable.interactionLocation.position;

// Set the destination of the nav mesh agent to the found destination position and start the nav mesh agent going.
        agent.SetDestination(destinationPosition);
        agent.isStopped = false;
    }

private IEnumerator WaitForInteraction ()
    {
        // As soon as the wait starts, input should no longer be accepted.
        handleInput = false;

// Wait for the normal pause on interaction.
        yield return inputHoldWait;

// Until the animator is in a state with the Locomotion tag, wait.
        while (animator.GetCurrentAnimatorStateInfo (0).tagHash != hashLocomotionTag)
        {
            yield return null;
        }

// Now input can be accepted again.
        handleInput = true;
    }
}

using System;
using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;//namespace使用场景管理

// This script exists in the Persistent scene and manages the content based scene's loading.  It works on a principle that the Persistent scene will be loaded first, then it loads the scenes that contain the player and other visual elements when they are needed.At the same time it will unload the scenes that are not needed when the player leaves them. 此脚本存在于持久场景中, 并管理基于场景加载的内容。 它的工作原理是, 首先加载持久场景, 然后在需要时加载包含玩家和其他视觉元素的场景。同时, 它将卸载玩家离开时不需要的场景。
public class SceneController : MonoBehaviour
{
    public event Action BeforeSceneUnload;          // Event delegate that is called just before a scene is unloaded.
    public event Action AfterSceneLoad;             // Event delegate that is called just after a scene is loaded.事件委托

public CanvasGroup faderCanvasGroup;            // The CanvasGroup that controls the Image used for fading to black.画布组控制淡入淡出的黑色图像
    public float fadeDuration = 1f;                 // How long it should take to fade to and from black.淡入淡出延迟时间
    public string startingSceneName = "SecurityRoom";
                                                    // The name of the scene that should be loaded first.起始场景名
    public string initialStartingPositionName = "DoorToMarket";
                                                    // The name of the StartingPosition in the first scene to be loaded.第一个场景初始位置名
    public SaveData playerSaveData;                 // Reference to the ScriptableObject which stores the name of the StartingPosition in the next scene.引用存储下一个场景初始位置名的脚本对象
    
    
    private bool isFading;                          // Flag used to determine if the Image is currently fading to or from black.图像是否正在淡入淡出

private IEnumerator Start ()
    {
        // Set the initial alpha to start off with a black screen. 将初始 alpha 设置为以黑屏开头。
        faderCanvasGroup.alpha = 1f;

// Write the initial starting position to the playerSaveData so it can be loaded by the player when the first scene is loaded. 将初始位置写入玩家数据存储（playerSaveData）, 以便在加载第一个场景时，玩家可以加载它。
        playerSaveData.Save (PlayerMovement.startingPositionKey, initialStartingPositionName);
        
        // Start the first scene loading and wait for it to finish.开始加载第一个场景, 并等待其完成
        yield return StartCoroutine (LoadSceneAndSetActive (startingSceneName));

// Once the scene is finished loading, start fading in. 一旦场景完成加载, 开始淡入淡出
        StartCoroutine (Fade (0f));
    }

// This is the main external point of contact and influence from the rest of the project. 这是项目其他部分的主要外部接触点和影响点。
    // This will be called by a SceneReaction when the player wants to switch scenes. 当玩家想要切换场景时, 这将被一个场景反应（SceneReaction）调用。
    public void FadeAndLoadScene (SceneReaction sceneReaction)
    {
        // If a fade isn't happening then start fading and switching scenes. 如果淡入淡出还没有开始, 那么就开始淡入淡出和切换场景。
        if (!isFading)
        {
            StartCoroutine (FadeAndSwitchScenes (sceneReaction.sceneName));
        }
    }

// This is the coroutine where the 'building blocks' of the script are put together. 这是将脚本的 "构建块building blocks " 组合在一起的协程
    private IEnumerator FadeAndSwitchScenes (string sceneName)
    {
        // Start fading to black and wait for it to finish before continuing.在继续前等待淡入淡出完成
        yield return StartCoroutine (Fade (1f));

// If this event has any subscribers, call it.如果事件有任何订阅者，调用他们
        if (BeforeSceneUnload != null)
            BeforeSceneUnload ();

// Unload the current active scene.卸载当前活动场景
        yield return SceneManager.UnloadSceneAsync (SceneManager.GetActiveScene ().buildIndex);

// Start loading the given scene and wait for it to finish. 开始加载给定的场景, 并等待其完成。
        yield return StartCoroutine (LoadSceneAndSetActive (sceneName));

// If this event has any subscribers, call it.调用事件订阅者
        if (AfterSceneLoad != null)
            AfterSceneLoad ();
        
        // Start fading back in and wait for it to finish before exiting the function. 开始淡入淡出, 并等待它完成后再退出该函数。
        yield return StartCoroutine (Fade (0f));
    }

private IEnumerator LoadSceneAndSetActive (string sceneName)
    {
        // Allow the given scene to load over several frames and add it to the already loaded scenes (just the Persistent scene at this point). 允许给定的场景加载到多个帧上, 并将其添加到已加载的场景 (此时只是 "持久" 场景)。异步加载场景
        yield return SceneManager.LoadSceneAsync (sceneName, LoadSceneMode.Additive);

// Find the scene that was most recently loaded (the one at the last index of the loaded scenes). 查找最近加载的场景 (加载的场景的最后一个索引中的场景)。
        Scene newlyLoadedScene = SceneManager.GetSceneAt (SceneManager.sceneCount - 1);

// Set the newly loaded scene as the active scene (this marks it as the one to be unloaded next). 将新加载的场景设置为活动场景 (这将其标记为下一步要卸载的场景)。
        SceneManager.SetActiveScene (newlyLoadedScene);
    }

private IEnumerator Fade (float finalAlpha)
    {
        // Set the fading flag to true so the FadeAndSwitchScenes coroutine won't be called again. 将淡入淡出的标志设置为 true, 这样就不会再调用转换场景。
        isFading = true;

// Make sure the CanvasGroup blocks raycasts into the scene so no more input can be accepted. 确保 canvasgroup 阻止向场景投掷射线raycasts, 以便不再接受任何输入。
        faderCanvasGroup.blocksRaycasts = true;

// Calculate how fast the CanvasGroup should fade based on it's current alpha, it's final alpha and how long it has to change between the two. 根据目前的alpha、最终的alpha以及两者之间的变化时间, 计算出画布组应该以多快的速度消失。
        float fadeSpeed = Mathf.Abs (faderCanvasGroup.alpha - finalAlpha) / fadeDuration;

// While the CanvasGroup hasn't reached the final alpha yet...还没有到final alpha，循环画布组
        while (!Mathf.Approximately (faderCanvasGroup.alpha, finalAlpha))
        {
            // ... move the alpha towards it's target alpha.像目标alpha移动
            faderCanvasGroup.alpha = Mathf.MoveTowards (faderCanvasGroup.alpha, finalAlpha,
                fadeSpeed * Time.deltaTime);

// Wait for a frame then continue.在下一帧继续
            yield return null;
        }

// Set the flag to false since the fade has finished.淡入淡出完成，设回false
        isFading = false;

// Stop the CanvasGroup from blocking raycasts so input is no longer ignored. 停止 canvasgroup 阻塞, 以便不再忽略输入。
        faderCanvasGroup.blocksRaycasts = false;
    }
}

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

// Instance of this class can be created as assets. 此类的实例可以创建为资产
// Each instance contains collections of data from the Saver monobehaviours they have been referenced by.  Since assets exist outside of the scene, the data will persist ready to be reloaded next time the scene is loaded.  Note that these assets DO NOT persist between loads of a build and can therefore NOT be used for saving the gamestate to disk. 每个实例都包含它们所引用的 Saver monobehaviours的数据集。 由于资产存在于场景之外, 因此数据将保持就绪（ready）, 以便在下次加载场景时重新加载。 请注意, 这些资产不会在生成的加载之间持续存在, 因此不能用于将游戏空间保存到磁盘。
[CreateAssetMenu]
public class SaveData : ResettableScriptableObject
{
    // This nested class is a lighter replacement for Dictionaries.  This is required because Dictionaries are not serializable.  It has a single generic type that represents the type of data to be stored in it. 此嵌套类（一个类在另一个类中）是字典（Dictionaries）的较轻替代。这是必需的, 因为字典不是可序列化的。 它只有一个泛型类型, 表示要存储在其中的数据类型。
    [Serializable]//嵌套代表可以将数据保存到磁盘
    public class KeyValuePairLists<T>
    {
        public List<string> keys = new List<string>();      // The keys are unique identifiers for each element of data. 这些键是数据的每个元素的唯一标识符。
        public List<T> values = new List<T>();              // The values are the elements of data. 这些值是数据的元素。

public void Clear ()
        {
            keys.Clear ();
            values.Clear ();
        }

public void TrySetValue (string key, T value)
        {
            // Find the index of the keys and values based on the given key. 根据给定的键查找键和值的索引。
            int index = keys.FindIndex(x => x == key);

// If the index is positive...如果索引为正
            if (index > -1)
            {
                // ... set the value at that index to the given value. 将该索引处的值设置为给定的值。
                values[index] = value;
            }
            else
            {
                // Otherwise add a new key and a new value to the collection. 否则, 向集合中添加新的键和新值。
                keys.Add (key);
                values.Add (value);
            }
        }

public bool TryGetValue (string key, ref T value)
        {
            // Find the index of the keys and values based on the given key. 根据给定的键查找键和值的索引。
            int index = keys.FindIndex(x => x == key);

// If the index is positive...
            if (index > -1)
            {
                // ... set the reference value to the value at that index and return that the value was found. 将参考值设置为该索引处的值, 并返回找到的值。
                value = values[index];
                return true;
            }

// Otherwise, return that the value was not found.
            return false;
        }
    }

// These are collections for various different data types. 这些是各种不同数据类型的集合。
    public KeyValuePairLists<bool> boolKeyValuePairLists = new KeyValuePairLists<bool> ();
    public KeyValuePairLists<int> intKeyValuePairLists = new KeyValuePairLists<int>();
    public KeyValuePairLists<string> stringKeyValuePairLists = new KeyValuePairLists<string>();
    public KeyValuePairLists<Vector3> vector3KeyValuePairLists = new KeyValuePairLists<Vector3>();
    public KeyValuePairLists<Quaternion> quaternionKeyValuePairLists = new KeyValuePairLists<Quaternion>();

public override void Reset ()
    {
        boolKeyValuePairLists.Clear ();
        intKeyValuePairLists.Clear ();
        stringKeyValuePairLists.Clear ();
        vector3KeyValuePairLists.Clear ();
        quaternionKeyValuePairLists.Clear ();
    }

// This is the generic version of the Save function which takes a collection and value of the same type and then tries to set a value. 这是 save 函数的通用版本, 它获取相同类型的集合和值, 然后设置值。
    private void Save<T>(KeyValuePairLists<T> lists, string key, T value)
    {
        lists.TrySetValue(key, value);
    }

// This is similar to the generic Save function, it tries to get a value. 这类似于通用的 save 函数, 它尝试获取值。
    private bool Load<T>(KeyValuePairLists<T> lists, string key, ref T value)
    {
        return lists.TryGetValue(key, ref value);
    }

// This is a public overload for the Save function that specifically chooses the generic type and calls the generic version. 这是save函数的public重载, 该函数专门选择泛型类型并调用泛型版本。
    public void Save (string key, bool value)
    {
        Save(boolKeyValuePairLists, key, value);
    }

public void Save (string key, int value)
    {
        Save(intKeyValuePairLists, key, value);
    }

public void Save (string key, string value)
    {
        Save(stringKeyValuePairLists, key, value);
    }

public void Save (string key, Vector3 value)
    {
        Save(vector3KeyValuePairLists, key, value);
    }

public void Save (string key, Quaternion value)
    {
        Save(quaternionKeyValuePairLists, key, value);
    }

// This works the same as the public Save overloads except it calls the generic Load function. 这与public Save overloads的工作原理相同, 但它调用通用Load函数。
    public bool Load (string key, ref bool value)
    {
        return Load(boolKeyValuePairLists, key, ref value);
    }

public bool Load (string key, ref int value)
    {
        return Load (intKeyValuePairLists, key, ref value);
    }

public bool Load (string key, ref string value)
    {
        return Load (stringKeyValuePairLists, key, ref value);
    }

public bool Load (string key, ref Vector3 value)
    {
        return Load(vector3KeyValuePairLists, key, ref value);
    }

public bool Load (string key, ref Quaternion value)
    {
        return Load (quaternionKeyValuePairLists, key, ref value);
    }
}

using UnityEngine;

// This is an abstract MonoBehaviour that is the base class for all classes that want to save data to persist between scene loads and unloads. For an example of using this class, see the PositionSaver script. 这是一个抽象的MonoBehaviour, 它是所有要保存数据以在场景加载和卸载之间保持不变的类的基类。有关使用此类的例子, 请参阅PositionSaver脚本。
public abstract class Saver : MonoBehaviour
{
    public string uniqueIdentifier;             // A unique string set by a scene designer to identify what is being saved. 用字符串存储所有数据。需要唯一标识要存的数据uniqueIdentigier
    public SaveData saveData;                   // Reference to the SaveData scriptable object where the data is stored. SaveData是保存数据的对象引用

protected string key;                       // A string to identify what is being saved.  This should be set using information about the data as well as the uniqueIdentifier. Key基于uniqueIdentigier和其他信息设置，标识要保存的内容

private SceneController sceneController;    // Reference to the SceneController so that this can subscribe to events that happen before and after scene loads. 引用sceneController，以便订阅场景加载前后发生的事件

private void Awake()
    {
        // Find the SceneController and store a reference to it. 找到 "SceneController" 并存储对它的引用。
        sceneController = FindObjectOfType<SceneController>();

// If the SceneController couldn't be found throw an exception so it can be added.找不到则抛出异常
        if(!sceneController)
            throw new UnityException("Scene Controller could not be found, ensure that it exists in the Persistent scene.");
        
        // Set the key based on information in inheriting classes. 根据继承类中的信息设置key
        key = SetKey ();
    }

private void OnEnable()
    {
        // Subscribe the Save function to the BeforeSceneUnload event.订阅save函数到卸载事件
        sceneController.BeforeSceneUnload += Save;

// Subscribe the Load function to the AfterSceneLoad event.
        sceneController.AfterSceneLoad += Load;
    }

private void OnDisable()
    {
        // Unsubscribe the Save function from the BeforeSceneUnloud event.销毁前取消订阅save函数
        sceneController.BeforeSceneUnload -= Save;

// Unsubscribe the Load function from the AfterSceneLoad event.
        sceneController.AfterSceneLoad -= Load;
    }

// This function will be called in awake and must return the intended key. 此函数将在唤醒时调用, 并且必须返回预期的密钥。
    // The key must be totally unique across all Saver scripts.key在所有saver脚本中唯一
    protected abstract string SetKey ();

// This function will be called just before a scene is unloaded. 在卸载场景之前调用
    // It must call saveData.Save and pass in the key and the relevant data. 它必须调用 savedata. 保存并传入密钥和相关数据。
    protected abstract void Save ();

// This function will be called just after a scene is finished loading. 场景加载完成后立即调用
    // It must call saveData.Load with a ref parameter to get the data out. 它必须调用 savedata.load 带有 ref 参数才能取出数据。
    protected abstract void Load ();
}

using UnityEngine;

public class PositionSaver : Saver//继承了Saver，所以也是monoBehaviour
{
    public Transform transformToSave;   // Reference to the Transform that will have its position saved from and loaded to. 转换的引用, 该转换将其位置保存并加载

protected override string SetKey()
    {
        // Here the key will be based on the name of the transform, the transform's type and a unique identifier.这个键将基于转换的名称、转换的类型和唯一标识符
        return transformToSave.name + transformToSave.GetType().FullName + uniqueIdentifier;
    }

protected override void Save()
    {
        saveData.Save(key, transformToSave.position);
    }

protected override void Load()
    {
        // Create a variable to be passed by reference to the Load function. 创建一个变量，要通过引用 load 函数传递
        Vector3 position = Vector3.zero;

// If the load function returns true then the position can be set. 如果load函数返回 true, 则可以设置位置
        if (saveData.Load(key, ref position))
            transformToSave.position = position;
    }
}