[读书笔记] 设计模式与游戏完美开发

最近在看《设计模式与游戏完美开发》，文章将记录一些要点和一些设计模式实现

GoF定义的23种设计模式及应用场景

  • 系统设计可以采用的设计模式：单例、状态（场景切换）、外观（保证高内聚）、中介者（保证低解耦）
  • 角色设计可以采用的设计模式：桥接（武器、技能）、策略（属性计算）、模板方法（重复流程）、状态（AI）
  • 对象管理可以采用的设计模式：工厂（角色产生）、建造者（生产流程与功能表现分离）、享元（子弹、特效）
  • 逻辑设计可以采用的设计模式：命令（撤销回退）、责任链（关卡）
  • 辅助功能可以采用的设计模式：组合（UI、红点）、观察者（好友、成就）、备忘录（存档）、访问者（管理某一类对象）
  • 游戏优化可以采用的设计模式：装饰、适配器、代理
  • 其他模式：迭代器、原型、解释器、抽象工厂

中介者模式

在这里插入图片描述
关于中介者模式，我们想象在一家互联网公司，有多个Colleague（同事），Colleague（同事）之间需要合作开发，不管是采用哪种版本控制软件，都可以抽象为一个Mediator（中介者）。而每个Colleague（同事）需要有版本控制的权限，即Mediator引用，而ConcreteMediator（具体中介者）则为ConcreteColleague（具体同事）提供服务。

Mediator.cs

public abstract class Mediator
{public abstract void SendMessage(Colleague theColleage, string message);
}

ConcreateMediator.cs

public class ConcreateMediator : Mediator
{ConcreateColleague1 m_Colleague1 = null;ConcreateColleague2 m_Colleague2 = null;public void SetColleage1(ConcreateColleague1 theColleague){m_Colleague1 = theColleague;}public void SetColleage2(ConcreateColleague2 theColleague){m_Colleague2 = theColleague;}public override void SendMessage(Colleague theColleague, string message){if (theColleague == m_Colleague1){m_Colleague2.Request(message);} else if (theColleague == m_Colleague2){m_Colleague1.Request(message);}}
}

Colleage.cs

public abstract class Colleague
{protected Mediator m_Mediator = null;public Colleague(Mediator mediator){m_Mediator = mediator;}public abstract void Request(string message);
}

ConcreateColleage1.cs、ConcreateColleage2.cs

using UnityEngine;
public class ConcreateColleague1 : Colleague
{public ConcreateColleague1(Mediator mediator) : base(mediator){}public void Action(){m_Mediator.SendMessage(this, "Concreate1执行");}public override void Request(string message){Debug.Log("C2已接收：" + message);}
}
using UnityEngine;
public class ConcreateColleague2 : Colleague
{public ConcreateColleague2(Mediator mediator) : base(mediator){}public void Action(){m_Mediator.SendMessage(this, "Concreate2执行");}public override void Request(string message){Debug.Log("C2已接收：" + message);}
}

Test.cs

using UnityEngine;public class Test : MonoBehaviour
{void Start(){// 定义具体中介者、具体同事ConcreateMediator pMediator = new ConcreateMediator();ConcreateColleague1 pColleage1 = new ConcreateColleague1(pMediator);ConcreateColleague2 pColleage2 = new ConcreateColleague2(pMediator);// 添加同事pMediator.SetColleage1(pColleage1);pMediator.SetColleage2(pColleage2);// 同事执行行为，中介者负责派发消息pColleage1.Action();pColleage2.Action();}void Update(){}
}

tips：有些情况下，Mediator会同时采用单例模式实现，在这种情况下，尽量避免从Mediator派生ConcreateMediator，这是因为当ConcreateMediator作为单例使用时，会因为单例只会存在唯一示例，当父类有多个派生类时会有“白马非马”的逻辑诡辩。同时为了遵循开闭原则，也要尽量依赖“接口”，而非依赖“实现”。

里氏替换原则有至少以下两种含义：
里氏替换原则是针对继承而言的，如果继承是为了实现代码重用，那么共享的父类方法就应该保持不变，不能被子类重新定义。 如果继承的目的是为了多态，而多态的前提就是子类覆盖并重新定义父类的方法，应该将父类定义为抽象类。不符合LSP的最常见的情况是，父类和子类都是可实例化的非抽象类，且父类的方法被子类重新定义，这一类的实现继承会造成父类和子类间的强耦合，也就是实际上并不相关的属性和方法牵强附会在一起，不利于程序扩展和维护。

工厂模式

在这里插入图片描述
工厂模式是最简单的一种设计模式，由ConcreteCreate(具体工厂)产生ConcreateProduct（具体产品）
Creator.cs

public abstract class Creator
{public abstract Product FactoryMethod();
}

ConcreateCreatorProductA.cs

using UnityEngine;public class ConcreateCreatorProductA : Creator
{public ConcreateCreatorProductA(){Debug.Log("产生工厂A");}public override Product FactoryMethod(){return new ConcreateProductA();}
}

Product.cs

public abstract class Product { }

ConcreateProductA

using UnityEngine;public class ConcreateProductA : Product
{public ConcreateProductA(){Debug.Log("生产A");}
}

tips：通过不同子类工厂产生不同品类的产品，当产品种类过多时，会导致“工厂子类暴增”。这时候可以配合FactoryMethod传参实现工厂模式

建造者模式

在这里插入图片描述
对于一个工厂来说，一条流水线应该可以生产多种产品吗，即生产流程与产品装配是可以解耦的。由Director（建造者指示者）对产品生产流程进行管控，而Builder（建造者）有很多ConcerteBuilder（具体建造者）则负责不同功能的装配。

Director.cs

public class Director
{public Product m_Product;public Director() { }public void Construct(Builder theBuilder){m_Product = new Product();theBuilder.BuilderPart1(m_Product);theBuilder.BuilderPart2(m_Product);}public Product GetResult(){return m_Product;}
}

Builder.cs

public abstract class Builder
{public abstract void BuilderPart1(Product theProduct);public abstract void BuilderPart2(Product theProduct);
}

ConcreateBuilderA.cs

public class ConcreateBuilderA : Builder
{public override void BuilderPart1(Product theProduct){theProduct.AddPart("产品A工人:生产部件1");}public override void BuilderPart2(Product theProduct){theProduct.AddPart("产品A工人:生产部件2");}
}

using UnityEngine;
using System.Collections;public class ConcreateBuilderB : Builder
{public override void BuilderPart1(Product theProduct){theProduct.AddPart("产品B工人:生产部件1");}public override void BuilderPart2(Product theProduct){theProduct.AddPart("产品B工人:生产部件2");}
}

Product.cs

using UnityEngine;
using System.Collections.Generic;public class Product
{private List<string> m_Part = new List<string>();public Product() { }public void AddPart(string v){m_Part.Add(v);}public void ShowProduct(){foreach(var part in m_Part){Debug.Log(part);}}
}

Test.cs

using UnityEngine;public class Test : MonoBehaviour
{Director director = new Director();Product theProduct = null;void Start(){director.Construct(new ConcreateBuilderA());theProduct = director.GetResult();theProduct.ShowProduct();director.Construct(new ConcreateBuilderB());theProduct = director.GetResult();theProduct.ShowProduct();}
}

享元模式

在这里插入图片描述
书中描述的案例，个人以为不适合理解，故此处暂留

组合模式

“将对象以树状结构进行组合，用以表现部分与整体的层次关系”，UI的层次结构正好适合使用这种设计模式。

在这里插入图片描述
Component（组件界面）用来定义树形结构，以及每个结点都能使用的操作，Composite（组合结点，即根结点），实现Component定义的各个方法，Leaf（叶结点，终端结点）
IComponent.cs

using UnityEngine;public abstract class IComponent
{protected string m_Value;public abstract void Operation();public virtual void Add(IComponent theComponent){Debug.Log("子类未实现");}public virtual void Remove(IComponent theComponent){Debug.Log("子类未实现");}public virtual IComponent GetChild(int index){Debug.Log("子类未实现");return null;}
}

Composite.cs

using UnityEngine;
using System.Collections.Generic;public class Composite : IComponent
{List<IComponent> m_Childs = new List<IComponent>();public Composite(string value){m_Value = value;}public override void Add(IComponent theComponent){m_Childs.Add(theComponent);}public override void Remove(IComponent theComponent){m_Childs.Remove(theComponent);}public override IComponent GetChild(int index){return m_Childs[index];}public override void Operation(){Debug.Log("根节点执行" + m_Value);foreach (IComponent theComponent in m_Childs){theComponent.Operation();}}
}

Leaf.cs

using UnityEngine;public class Leaf : IComponent
{public Leaf(string value){m_Value = value;}public override void Operation(){Debug.Log("叶节点执行:" + m_Value);}
}

test.cs

using UnityEngine;public class Test2 : MonoBehaviour
{IComponent theRoot;void Start(){theRoot = new Composite("Root");theRoot.Add(new Leaf("Leaf1"));theRoot.Add(new Leaf("Leaf2"));IComponent theChild1 = new Composite("Child1");theChild1.Add(new Leaf("child1.Leaf1"));theChild1.Add(new Leaf("child1.Leaf2"));theRoot.Add(theChild1);IComponent theChild2 = new Composite("Child1");theChild2.Add(new Leaf("child2.Leaf1"));theChild2.Add(new Leaf("child2.Leaf2"));theRoot.Add(theChild2);theRoot.Operation();}
}

tips:GameObject.Find()会遍历所有场景中的对象，而且在Unity中存在重名的问题，会产生性能问题。可以通过自己实现Find，保证只在指定的Canvas下查找
UI的功能在场景初始化时决定，保证UI逻辑与表现分离

责任链模式

在这里插入图片描述
责任链可以理解为数据结构的链表，每个Handler都有下一个Handler的引用。在关卡系统的设计上，很多项目会采用CreateStage（创建关卡）、CheckNextStage（检查进入下一关）方法来对场景进行操作，而采用责任链模式，则可以使用Handler（关卡对象）替代，通过类化关卡数据、通关条件能够提高关卡系统的灵活度。
Handler.cs

public abstract class Handler
{protected Handler m_NextHandle = null;public Handler(Handler theNextHandle){m_NextHandle = theNextHandle;}public virtual void HandleRequest(int cost){if (m_NextHandle != null){m_NextHandle.HandleRequest(cost);}}
}

ConcreateHandle1.cs

using UnityEngine;public class ConcreateHandle1 : Handler
{public int m_CostCheck = 10;public ConcreateHandle1(Handler theNextHandle) : base(theNextHandle) { }public override void HandleRequest(int cost){if (cost < m_CostCheck){Debug.Log("ConcreateHandle2核准");} else{base.HandleRequest(cost);}}
}

ConcreateHandle2.cs

using UnityEngine;public class ConcreateHandle2 : Handler
{public int m_CostCheck = 20;public ConcreateHandle2(Handler theNextHandle) : base(theNextHandle) { }public override void HandleRequest(int cost){if (cost <= m_CostCheck){Debug.Log("ConcreateHandle2核准");}else{base.HandleRequest(cost);}}
}

Test.cs

using UnityEngine;
using System.Collections;public class Test : MonoBehaviour
{void Start(){ConcreateHandle2 theHandle2 = new ConcreateHandle2(null);ConcreateHandle1 theHandle1 = new ConcreateHandle1(theHandle2);theHandle1.HandleRequest(5);theHandle1.HandleRequest(20);}
}

观察者模式

在这里插入图片描述
对于发布-订阅关系来说，一个Subject可以对应多个Observer，Subject维护观察者列表，并提供Notify()通知功能；Observer提供Update()方法，在Subject通知更新时调用。
Subject.cs

using System.Collections.Generic;public abstract class Subject
{List<Observer> m_Observer = new List<Observer>();public void Attach(Observer theObserver){m_Observer.Add(theObserver);}public void Detach(Observer theObserver){m_Observer.Remove(theObserver);}public void Notify(){// 通知所有观察者foreach (Observer observer in m_Observer){observer.Update();}}
}

ConcreateSubject.cs

using UnityEngine;
using System.Collections;public class ConcreateSubject : Subject
{string m_SubjectState;public void SetState(string state){m_SubjectState = state;Notify();}public string GetState(){return m_SubjectState;}
}

Observer.cs

using UnityEngine;
using System.Collections;public abstract class Observer
{public abstract void Update();
}

ConcreateObserver.cs

using UnityEngine;public class ConcreateObserver : Observer
{string m_ObjectState;ConcreateSubject m_Subject = null;public ConcreateObserver(ConcreateSubject subject){m_Subject = subject;}public override void Update(){Debug.Log("ConcreteObserver.Update");Debug.Log("ConcreateObserver1:Subject" + m_ObjectState);}
}

Test.cs

using UnityEngine;
using System.Collections;public class Test : MonoBehaviour
{ConcreateSubject theSubject = null;ConcreateObserver theObserver = null;// Use this for initializationvoid Start(){theSubject = new ConcreateSubject();theObserver = new ConcreateObserver(theSubject);theSubject.Attach(theObserver1); // 观察者参与订阅theSubject.SetState("Subject状态1"); // 主题修改状态，并通知theObserver1.ShowState(); // 观察者接收通知并执行Update()操作}
}

备忘录模式

在这里插入图片描述
在不违反封装的原则下，获取一个对象的内部状态并保留在外部。当我们想办法去获取游戏系统的数据时，现有系统难免被改动，而如果由游戏系统主动提供数据，则可以保证系统的封装性，这也是备忘录模式的精髓。Originator（记录拥有者）会自动产出需要保存的记录Memento（记录保存者，我称之为记忆体），由Caretaker（记录看守者）维护多个Memento。

Originator.cs

using UnityEngine;public class Originator
{string m_State;public void SetInfo(string state){m_State = state;}public void ShowInfo(){Debug.Log("Originator State" + m_State);}public Memento CreateMemento(){Memento newMemento = new Memento();newMemento.SetState(m_State);return newMemento;}public void SetMemento(Memento m){m_State = m.GetState();}
}

Memento.cs

public class Memento
{string m_State;public string GetState(){return m_State;}public void SetState(string state){m_State = state;}
}

Caretaker.cs

using System.Collections.Generic;public class Caretaker
{Dictionary<string, Memento> m_Mementos = new Dictionary<string, Memento>();public void AddMemento(string version, Memento theMemento){if (m_Mementos.ContainsKey(version) == false)m_Mementos.Add(version, theMemento);elsem_Mementos[version] = theMemento;}public Memento GetMemento(string version){if (m_Mementos.ContainsKey(version) == false)return null;return m_Mementos[version];}
}

Test.cs

using System.Collections;public class Test : MonoBehaviour
{void Start(){Originator theOriginator = new Originator();Caretaker theCaretaker = new Caretaker();theOriginator.SetInfo("version1");theOriginator.ShowInfo();theCaretaker.AddMemento("1", theOriginator.CreateMemento());theOriginator.SetInfo("version2");theOriginator.ShowInfo();theCaretaker.AddMemento("2", theOriginator.CreateMemento());theOriginator.SetInfo("version3");theOriginator.ShowInfo();theOriginator.SetMemento(theCaretaker.GetMemento("2"));theOriginator.ShowInfo();theOriginator.SetMemento(theCaretaker.GetMemento("1"));theOriginator.ShowInfo();}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/569590.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

auto关键字

auto关键字

使用前&#xff1a; #include<string> #include<vector> int main() {std::vector<std::string> vs;for (std::vector<std::string>::iterator i vs.begin(); i ! vs.end(); i){//...} } 使用后&#xff1a; #include<string> #include<vect…
阅读更多...
[读书笔记] 代码整洁之道

[读书笔记] 代码整洁之道

书的示例是Java语言编写的&#xff0c;虽说不会影响阅读&#xff0c;但是后面几章讲应用这套方法论的时候&#xff0c;大篇幅的Java代码分析还是挺难受的&#xff0c;而且连java测试框架Junit都要细讲&#xff0c;对于非Java系的开发者来说&#xff0c;一些内容确是云里雾里。 …
阅读更多...
iOS开发——GPUImage源码解析

iOS开发——GPUImage源码解析

一、基本概念 GPUImage&#xff1a;一个开源的、基于openGL的图片或视频的处理框架&#xff0c;其本身内置了多达120多种常见的滤镜效果&#xff0c;并且支持照相机和摄像机的实时滤镜&#xff0c;并且能够自定义图像滤镜。同时也很方便在原有基础上加入自己的滤镜Filter&#…
阅读更多...
[读书笔记] 敏捷软件开发：原则、模式与实践

[读书笔记] 敏捷软件开发：原则、模式与实践

关于面向对象编程的一些理解&#xff0c;这本书主要看六大原则的部分&#xff0c;书中关于设计模式的内容由于之前的那本《设计模式与游戏完美开发》已经很好的讲解了游戏开发领域的应用&#xff0c;所以不多关注。 面向对象的六大原则 单一职责原则SRP&#xff1a;一个类应该…
阅读更多...
Caffe-SSD相关源码说明和调试记录

Caffe-SSD相关源码说明和调试记录

1 对Blob的理解及其操作&#xff1a; Blob是一个四维的数组。维度从高到低分别是: (num_&#xff0c;channels_&#xff0c;height_&#xff0c;width_) 对于图像数据来说就是&#xff1a;图片个数&#xff0c;彩色通道个数&#xff0c;宽&#xff0c;高 Blob中数据是row-…
阅读更多...
[游戏策划] 读书笔记

[游戏策划] 读书笔记

交互式媒体最有趣的地方在于&#xff0c;它让玩家直面问题&#xff0c;思考、尝试各种解决方案&#xff0c;并体验各种解决方案的结果。然后玩家可以回到思考阶段&#xff0c;规划下一步行动。这种反复试错的过程中&#xff0c;玩家的脑海里就会构建出一个互动的世界。 [读书笔…
阅读更多...
YAML_02 playbook的ping脚本检测

YAML_02 playbook的ping脚本检测

ansible]# vim ping.yml---- hosts: allremote_user: roottasks:- ping:ansible]# ansible-playbook ping.yml //输出结果转载于:https://www.cnblogs.com/luwei0915/p/10615360.html
阅读更多...
ECS框架学习

ECS框架学习

DOTS Unity DOTS是Unity官方基于ECS架构开发的一套包含Burst编辑器和JobSystem的技术栈&#xff0c;它旨在充分利用多核处理器的特点&#xff0c;充分发挥ECS的优势。 安装 Entities、Burst、Jobs、Hybrid Renderer&#xff08;必选&#xff0c;用于DOTS的渲染相关&#xf…
阅读更多...
辅助排序和Mapreduce整体流程

辅助排序和Mapreduce整体流程

一、辅助排序 需求&#xff1a;先有一个订单数据文件&#xff0c;包含了订单id、商品id、商品价格&#xff0c;要求将订单id正序&#xff0c;商品价格倒序&#xff0c;且生成结果文件个数为订单id的数量&#xff0c;每个结果文件中只要一条该订单最贵商品的数据。 思路&#xf…
阅读更多...
关于游戏开发流程的分析

关于游戏开发流程的分析

问题 传统游戏开发过程中通常是&#xff1a;策划提出需求&#xff0c;美术制作需求中的资源&#xff0c;程序实现需求中的功能&#xff0c;并导入资源实现最终效果。你觉得策划、美术、程序三者在开发游戏的过程中应该是一种什么关系&#xff0c;是否存在多种开发模式&#xf…
阅读更多...
Ubuntu18.04应用程序安装集锦

Ubuntu18.04应用程序安装集锦

整理网上的资源&#xff1a; Python Web开发工具箱 ubuntu美化及超NB的zsh配置 api文档查询工具&#xff1a;zeal&#xff0c;dash(收费)转载于:https://www.cnblogs.com/johnyhe/p/10403967.html
阅读更多...
[读书笔记] 美的历程

[读书笔记] 美的历程

阅读更多...
final使用详解

final使用详解

final的使用及注意事项 final是一个可以修饰变量&#xff0c;方法&#xff0c;类的修饰符 final修饰的方法不能被重写 final修饰的类不能被继承 final修饰的变量为一个常量 final不能与abstract一起使用 注意&#xff1a;当final修饰一个变量时要么在声明时就给该变量赋值&…
阅读更多...
[读书笔记] 史玉柱自述：我的营销心得

[读书笔记] 史玉柱自述：我的营销心得

与下属的关系 从玩家角度设定目标 目标感的设计 论随机性 在前15分钟留住玩家 实际观察玩家对于游戏的翻译反应 好游戏是改出来的 注重细节 决策民主、责任人制度 论简单与复杂的关系 游戏经济中的投放与回收 避免进入降低压力的怪圈 创业初期的股份分配 单个行业…
阅读更多...
记一次面试腾讯的奇葩经历

记一次面试腾讯的奇葩经历

阅读本文大概需要 2.8 分钟。 作者&#xff1a;黄小斜 文章来源&#xff1a;微信公众号【程序员江湖】 ​ 上回说到&#xff0c;我腾讯面试出师不利&#xff0c;简历随即进入备胎池&#xff0c;不过没过多久&#xff0c;转机还是来了。 大概是一周之后&#xff0c;我的电话响起…
阅读更多...
foot

foot

码云链接&#xff1a;https://gitee.com/zyyyyyyyyyyy/codes/rcfdzmin4a82v975pl1ko47 效果图&#xff1a; 原网站截图&#xff1a; 源代码&#xff1a; <!DOCTYPE html><html><head><meta charset"UTF-8"><title></title><s…
阅读更多...
jsp标签在JavaScript中使用时，可能会出现的一个问题。

jsp标签在JavaScript中使用时，可能会出现的一个问题。

直接上代码 1 <script type"text/javascript">2 var E window.wangEditor;3 var editor new E(#editor);4 // 或者 var editor new E( document.getElementById(editor) )5 editor.create();6 $(function () {7 $("#btn1&…
阅读更多...
CTF小记录

CTF小记录

WEB 题目都说了flag在index里所以可以直接构造payloadhttp://120.24.86.145:8005/post/index.php?filephp://filter/convert.base64-encode/resourceindex.php F12 抓包 Base64 Hackbar post get 代码审计 暴力解法 Url编码 本地登录&#xff1a;X-Forwarded-For: 127.0.0…
阅读更多...
关于梦想（二）

关于梦想（二）

马丁.路德.金说过“如果你的梦想还站立的话&#xff0c;那么没有人能使你倒下”。 独自仰望夜空&#xff0c;从古至今&#xff0c;不知多少人面对着浩瀚的夜空&#xff0c;满天的繁星而放飞梦想&#xff0c;放飞希望、放飞未来。斑斓璀璨的星空又见证了多少伟大梦想的实现&…
阅读更多...
C学习笔记-gdb

C学习笔记-gdb

gdb即GNU debugger&#xff0c;用来调试程序 gdb使用前提 要使用gdb&#xff0c;则需要在编译源代码时候使用-g参数 gcc -g –o test test.c启动gdb gdb 程序名 [corefile]corefile是可选的&#xff0c;但能增强gdb的调试能力 Linux默认是不生成corefile的&#xff0c;所以需要…
阅读更多...
最新文章

Copyright @ 2022~2023