得,果然是无限套娃,我还在好奇它的费用是怎么传递的,结果还真是;

这个例子举得真的是一点都不方便, 不如直接拿数据保存举例, 套壳使用另一种方式保存数据

果然是套壳, 我愿称之为皮包公司模式

为什么不使用事件呢,现在还要单独写个类,观察者模式本身就是谁需要谁注册,被观察者进行触发的流程; 本身用事件的方式去添加方法,逻辑上也是一样的, 真没必要搞得这么绕,其流程是一样的,都需要对stageSystem进行修改操作;

他写的太绕了,看的难受,重新写了下

//示例
public class _09ObserverMode : MonoBehaviour
{
    private void Start()
    {
        //
        S1 s1 = new S1();

        Observer ob1 = new Observer("ob1");
        Observer ob2 = new Observer("ob2");

        // 订阅事件  
        s1.Add(ob1);
        s1.Add(ob2);

        // 状态变化，通知所有观察者 
        s1.State = "温度 37";

        // 取消订阅示例  
        s1.Remove(ob1);
        s1.Remove(ob2);
    }
}

//观察者
public class Observer
{
    // 名称
    private string name;

    // 构造函数
    public Observer(string name)
    {
        this.name = name;
    }

    // 更新
    public void Update(string str)
    {
        Debug.Log(name + " 收到了通知,更新了 " + str);
    }
}

//定义被观察者
public class Subject
{
    // 定义事件  
    private Action<string> onEvent;

    // 订阅事件  
    public void Add(Observer ob)
    {
        this.onEvent += ob.Update;
    }

    // 取消订阅事件  
    public void Remove(Observer ob)
    {
        this.onEvent -= ob.Update;
    }

    // 触发事件，通知所有观察者  
    public void Trigger(string str)
    {
        this.onEvent?.Invoke(str);
    }
}

//实现被观察者
public class S1 : Subject
{
    // 状态
    private string mState;

    // 属性
    public string State
    {
        get
        {
            return this.mState;
        }
        set
        {
            // 状态变化，通知所有观察者  
            this.mState = value;              
            this.Trigger(value);
        }
    }
}

其实真没必要搞那么麻烦,直接在角色系统那边增加两个死亡列表就行,然后让IEnemy和ISoldier死亡后通过GameFacade调用方法添加到死亡列表,最后和视频一样,在CharacterSystem的Update中处理死亡列表

其实在这一块可以顺便教一下SO; 注意模型名字错了

这个升级兵营 武器 训练士兵,里面的逻辑也拆的太散了吧,这种方式大可不必吧,而且兵营UI属于表现层, 没必要把判断逻辑放在这里面

关于查找父物体下子物体可以改成如下

//从父物体下找到对应名称子物体
public static Transform FindChild(GameObject father, string name)
{
    Transform[] childList = father.GetComponentsInChildren<Transform>();
    Transform child = null;
    bool isFinded = false;
    foreach (var temp in childList)
    {
        if (temp.name == name)
        {
            if (isFinded == true)
            {
                //查找是否有重名的 //缺点是要把整个列表都遍历一遍
                Debug.Log(father.name + " 下存在重名的物体 " + name);
            }
            else
            {
                child = temp;
                isFinded = true;
            }
        }
    }

    return child;
}

public static T FindChild<T>(string fatherName, string name)
{
    GameObject father = GameObject.Find(fatherName);
    return FindChild(father, name).GetComponent<T>();
}

您老就不能使用固定分辨率吗,在设计模式搞这个有什么意义

public enum EWeaponType
{
    WeaponGun,
    WeaponRifle,
    WeaponRocket,
}

这里把枚举重写下,和预制体名字一样

string assetName = weaponType.ToString();

然后枚举变量转文本

有需要的同学也可以这样写; 我不太喜欢让子持有父, 所以让子返回信息给父

//控制
public class Context
{
    //由于state是私有的,外部不能访问,所以需要提供以下方法
    private IState state;

    //封装一次方法
    public void Handle(int num)
    {
        IState tempState = this.state.Handle(num);
        if (tempState != null)
            this.ChangeState(tempState);
    }

    //切换状态
    public void ChangeState(IState state)
    {
        this.state = state;
    }
}

//接口
public interface IState
{
    public IState Handle(int num);
}

//实现接口
public class StateA : IState
{
    public IState Handle(int num)
    {
        Debug.Log(this + "  " + num);

        if (num > 10)
            return new StateB();
        else
            return null;
    }
}

//实现接口
public class StateB : IState
{
    public IState Handle(int num)
    {
        Debug.Log(this + "  " + num);

        if (num <= 10)
            return new StateA();
        else
            return null;
    }
}

老师，时代变了，5.6已经没人用了

父类有带参数的构造方法，子类也必须提供带参数的构造方法

Ctrl+F可以方便得替换

实现继承的抽象类中的函数记得要用override

抽象类的抽象方法前也要用abstract声明

单例模式的一般实现

1.类实例化

2.构造方法私有化

3.公有方法访问

挂载在游戏物体身上就要继承自MonoBehaviour

各种类互相调用就是耦合性高