游戏设计模式(游戏引擎:Cocos creator,Laya air等一系列游戏引擎,都是一样的)

原创于 2025-04-19 18:46:03 发布 · 560 阅读 ·

本内容遵循CC 4.0 BY-SA版权协议

等待你的到来e

关注

标签

#游戏 #设计模式 #游戏引擎

分类游戏开发

今天来给大家详细的说一下几款游戏设计模式:

有两种游戏引擎:

Cocos creator 和 Laya air

Cocos creator他继承的时候是extends Component,以及他写类型的时候直接写就可以了

Laya air 他继承的是extends Laya.Script，以及他写类型的时候必须要加上Laya.类型就可以了

以下示例各别有区分请认真查看:

一.单例模式

简介:

单例模式是一种创建型设计模式,他确保一个类只有一个实例,并提供一个全局访问的点来访问该实例.

代码：

//类
export class Main{
      static interface:Main;//类型写本类的类名//静态属性,他是用来访问该实例的
      static getInterface(){
      
             if(!this.interface){
                 return this.interface=new Main();
             }else{
                 return this.interface;
             }
 
      }
//接下来我们写一些方法
//创建物体,这里只是写一些案例,根据自己真实情况来写
//Cocos creator写法
    createWt(data:prefab,node:Node){
           let wt=instantiate(data);
               node.addChild(wt);
    }
//Laya air写法
    createWt(data:Laya.Prefab,node:any){
           let wt=data.create();
               node.addChild(wt);
    }  
}

//类
import Main from "./Main";
export class Role extends Component{
//Cocos creator写法
       @property(Prefab)
       wt:Prefab;
//Laya air写法
       @property(Laya.Prefab)
       wt:Prefab;
       start(){
//Cocos creator写法
          Main.getInterface().createWt(this.wt,this.node);
//Laya air写法
          Main.getInterface().createWt(this.wt,this.owner);
       }
       update(){
       

       }
}

二.工厂模式

简介:

工厂模式是一种创建型设计模式,该模式提供了专门创建对象的接口,但允许子类决定实例化哪个类,工厂模式将对象的创建与使用分离,是代码更加灵活和可呵护.

代码:

简单工厂模式

//接口写法
//原因:多个类要实现同样的方法,所以直接继承接口,直接实现接口就行了
export Interface Method{
       //案例,具体方法根据自己真是情况来写
//Cocos creator写法
       huoyqn(data:Prefab):void;//火焰魔法攻击
       bing(data:Prefab):void;//冰系魔法攻击
       siwang(data:any):void;//死亡
//Laya air写法
       huoyqn(data:Laya.Prefab):void;//火焰魔法攻击
       bing(data:Laya.Prefab):void;//冰系魔法攻击
       siwang(data:any):void;//死亡

}
//抽象类写法原始写法
export class Method{
       constructor(){
                if (new.target === Method) {
                      throw new Error('抽象类不能直接实例化');
                }//这个的意思就是如果这个类被实例化了那么,条件就成功了,直接抛出错误
       }
       //案例,具体方法根据自己真是情况来写
//Cocos creator写法
       huoyqn(data:Prefab){
               throw new Error("抽象方法必须由子类实现");
       }//火焰魔法攻击
       bing(data:Prefab){
               throw new Error("抽象方法必须由子类实现");
       }//冰系魔法攻击
       siwang(data:any){
               throw new Error("抽象方法必须由子类实现");
       }//死亡
//Laya air写法
       huoyqn(data:Laya.Prefab){
               throw new Error("抽象方法必须由子类实现");
       }//火焰魔法攻击
       bing(data:Laya.Prefab){
              throw new Error("抽象方法必须由子类实现");
       }//冰系魔法攻击
       siwang(data:any){
              throw new Error("抽象方法必须由子类实现");
       }//死亡
}
//抽象类现代写法

export abstract class Method {
//Cocos creator写法
    abstract huoyqn(data: Prefab):void; //抽象方法必须被继承之后重写的
    bing(data:Prefab,node:Node){
               let wt=instantiate(data);
               node.addChild(wt);
    } //可以直接用的不用重写
//Laya air写法
    abstract huoyqn(data: Laya.Prefab):void; //抽象方法必须被继承之后重写的
    bing(data:Laya.Prefab,node:any){
               let wt=instantiate(data);
               node.addChild(wt);
    } //可以直接用的不用重写
}


//以上几种写法都是用来被继承的
-----------------------------------------------------------------------------------------
//继承接口
export class A implements Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       bing(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//冰系魔法攻击
       siwang(name:any):void{
              console.log(name,"已经死亡");
       };//死亡
}




export class B implements Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       bing(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//冰系魔法攻击
       siwang(name:any):void{
              console.log(name,"已经死亡");
       };//死亡
}







export class C implements Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       bing(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//冰系魔法攻击
       siwang(name:any):void{
              console.log(name,"已经死亡");
       };//死亡
}


工厂类
import A from "./A";
import B from "./B";
import C from "./C";
export class Gc(){
      select(name:any){
          switch(name){
                case "A":
                   return new A();
                case "B":
                   return new B();
                case "C":
                   return new C();
                default :
                   return "没有您要找的类";
          }     
      }
}



//使用类(调用类)
import Gc from "./Gc";
export class Main extends Component{

        Gc:Gc;
        @property(Prefab)
        huoqyn:Prefab;
        start(){
            this.Gc=new Gc();
            let A=this.Gc.select('A');
                A.huoyqn(this.huoyqn,this.ndoe);
        }
        update(){

        }
}

-----------------------------------------------------------------------------------------

//继承抽象类原始


export class A extends Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       bing(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//冰系魔法攻击
       siwang(name:any):void{
              console.log(name,"已经死亡");
       };//死亡
}




export class B extends Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       bing(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//冰系魔法攻击
       siwang(name:any):void{
              console.log(name,"已经死亡");
       };//死亡
}







export class C extends Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       bing(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//冰系魔法攻击
       siwang(name:any):void{
              console.log(name,"已经死亡");
       };//死亡
}




工厂类
import A from "./A";
import B from "./B";
import C from "./C";
export class Gc(){
      select(name:any){
          switch(name){
                case "A":
                   return new A();
                case "B":
                   return new B();
                case "C":
                   return new C();
                default :
                   return "没有您要找的类";
          }     
      }
}



//使用类(调用类)
import Gc from "./Gc";
export class Main extends Component{
        Gc:Gc;
        @property(Prefab)
        huoqyn:Prefab;
        start(){
            this.Gc=new Gc();
            let A=this.Gc.select('A');
                A.huoyqn(this.huoyqn,this.ndoe);
        }
        update(){

        }
}
-----------------------------------------------------------------------------------------
//继承抽象类现代


export class A extends Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       //另一个方法可以直接使用
}




export class B extends Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       //另一个方法可以直接使用
}







export class C extends Method{
       huoyqn(data:Prefab,node:Node):void{
               let wt=instantiate(data);
               node.addChild(wt);
       };//火焰魔法攻击
       //另一个方法可以直接使用
}


工厂类
import A from "./A";
import B from "./B";
import C from "./C";
export class Gc(){
      select(name:any){
          switch(name){
                case "A":
                   return new A();
                case "B":
                   return new B();
                case "C":
                   return new C();
                default :
                   return "没有您要找的类";
          }     
      }
}



//使用类(调用类)
import Gc from "./Gc";
export class Main extends Component{
        Gc:Gc;
        @property(Prefab)
        bing:Prefab;
        start(){
            this.Gc=new Gc();
            let A=this.Gc.select('A');
                A.bing(this.huoyqn,this.ndoe);//这里这个类继承抽象类之后没有重写这个类,但是可以用,这就是我说的没有加抽象的方法都可以直接使用
        }
        update(){

        }
}

工厂方法模式

代码:

//接口

export Interface jk1{
       caizhi(name:any):void;
       ab():void;
}
export Interface jk2{
       color(name:any):void;
}

//实现接口
import jk1 from "./jk1";
export Class A1 implements jk1{
       caizhi(name:any):void{
           console.log(name,"材质");
       }
       ab():void{

       }
}
import jk1 from "./jk2";
export Class A2 implements jk2{
       color(name:any):void{
           console.log(name,"颜色");
       }
}

import jk1 from "./jk1";
export Class B1 implements jk1{
       caizhi(name:any):void{
           console.log(name,"材质");
       }
       ab():void{

       }
}
import jk1 from "./jk2";
export Class B2 implements jk2{
       color(name:any):void{
           console.log(name,"颜色");
       }
}

//定义接口
export Interface classjk{
       caizhi(name:any):void;
       color(name:any):void;
}

//定义实现接口的类
import classjk from "./classjk";
import A1 from "./A1";
import B1 from "./A2";
export class sxjk1 implements classjk{
        caizhi():void{
             return new A1();
        }
        color():void{
             return new A2();
        }
}






import classjk from "./classjk";
import A1 from "./B1";
import B1 from "./B2";
export class sxjk2 implements classjk{
        caizhi():void{
             return new B1();
        }
        color():void{
             return new B2();
        }
}




//使用(调用)
import sxjk1 from "./sxjk1";
import sxjk2 from "./sxjk2";
export Class Main extends Component{
         sxjk1:sxjk1;
         sxjk2:sxjk2;
         start(){
             this.sxjk1=new sxjk1();
             this.sxjk2=new sxjk2();
             this.sxjk1.caizhi().caizhi("铁");
             this.sxjk1.caizhi().ab();     
             this.sxjk1.color().color("红");          
         }
         update(){

         }
}

抽象工厂模式:

代码:

//定义接口
export interface jk{
     move(player:any):void;
}


//实现接口
import { jk } from "./Interface";

export class Bzr implements jk {
    move(player: any): void {
            console.log(player+"移动了");
    }

}


import { jk } from "./Interface";


export class Heizr implements jk{
    move(player: any): void {
        console.log(player+"移动了");
    }

}


import { jk } from "./Interface";

export class Hzr implements jk {
    move(player: any): void {
        console.log(player+"移动了");
    }

}

//抽象类
import { jk } from "./Interface";
export abstract class Sxl{
       abstract zhixin():jk;//返回类型必须是继承接口类型的
       user(name:any){
            this.zhixin().move(name);
       }
}

//实现抽象类
import { Hzr } from "./Hzr";
import { jk } from "./Interface";
import { Sxl } from "./Sxl";

export class yeclass extends Sxl {
    zhixin(): jk {
            return new Hzr();
    }

}

import { Bzr } from "./Bzr";
import { jk } from "./Interface";
import { Sxl } from "./Sxl";

export class Bclass extends Sxl {
    zhixin(): jk {
         return new Bzr();
    }
}

import { Heizr } from "./Heizr";
import { jk } from "./Interface";
import { Sxl } from "./Sxl";

export class hclass extends Sxl{
    zhixin(): jk {
           return new Heizr();
    }

}
//调用
import { Bclass } from "./Bclass";
import { hclass } from "./hclass";
import { yeclass } from "./yeclass_1";

const { regClass, property } = Laya;

@regClass()
export class Main extends Laya.Script {
       onStart(): void {
           let b=new Bclass();
           let h=new yeclass();
           let black=new hclass();
           this.zhixing(b,h,black);
       }
       zhixing(b:any,h:any,black:any){
               b.user("白种人");
               h.user("黄种人");
               black.user("黑种人");
       }
}

三.代理模式

简介:

代理模式是一种结构型设计模式，它为其他对象提供一种代理（Proxy）以控制对这个对象的访问。

代码:

// 1. 定义银行账户接口
export Interface BankAccount {
  withdraw() {}  // 取款方法
  getBalance() {} // 查余额方法
}

//账户
import BankAccount from "./BankAccount";
export Class User implement BankAccount{
      money:number;
  constructor(balance) {
        this.balance = balance;
  }
  withdraw(money:any){
       this.money-=money;
       console.log("取出",money,"剩余",this.money);
  }
  getBalance(){
       return this.money;
  }
}
//保护代理
export Class Dl implements BankAccound{
      account:User；
      qx:boolean;
      construnctor(account,qx){
           this.account=account;
           this.qx=qx;
      }
  withdraw(money:any){
       if(this.qx){
           this.account.withdraw(money);
           return "取款成功";
       }else{
           return "您没有权限";
       }
  }
  getBalance(){
       return this.account.getBalance();
  }

}

//调用
import User from "./User";
import Dl from "./Dl";
export class Main extends Laya.Script {
       onStart(): void {
         let a1=new Dl(new User(1000),false);
         let a2=new Dl(new User(1000),true);
         a1.withdraw(500);//输出您还没有权限
         a1.getBalance();//输出1000
         a2.withdraw(500);//输出"取出",500,"剩余",500
       }
       update(){
       
       }
}

四.依赖注入模式

简介:

依赖注入（DI）是一种设计模式，用于管理对象之间的依赖关系。它的核心思想是：将对象的依赖项从外部注入，而不是在对象内部创建。

构造函数注入

代码：

//定义接口
export Interface jk{
       abc():void;
       def():void;
}
//实现接口
import jk from "./jk";
export Class A implements jk{
       abc():void{
            //方法里面的东西和具体的逻辑实现根据自己的真实情况来实现
            console.log("这个方法是用构造函数实现依赖注入的");
       }
       def():void{
            //方法里面的东西和具体的逻辑实现根据自己的真实情况来实现
       }
}

import jk form "./jk";
import A form "./A";
export Class B implements jk{
       A:A;
       constructor(class:A){
           this.A=class;
       }
       abc():void{
            //方法里面的东西和具体的逻辑实现根据自己的真实情况来实现
            this.A.abc();
          
       }
       def():void{
            //方法里面的东西和具体的逻辑实现根据自己的真实情况来实现
       }
}
//调用((使用)
import B from "./B";
import A from "./A";
export Class Main extends Laya.Sprite{
       start(){
          let B=new B(new A());
              B.abc();//输出这个方法是用构造函数实现依赖注入的
       }
       update(){

       }
}

Setter方法注入（可选依赖）

//定义接口
export Interface jk{
       abc():void;
       def():void;
}
//实现接口
import jk from "./jk";
export Class A implements jk{
       abc(name:any):void{
           console.log("A");
       }
       def(name:any):void{
           console.log("A");
       }
}


import jk from "./jk";
export Class B implements jk{
       abc(name:any):void{
           console.log("B");
       }
       def(name:any):void{
           console.log("B");
       }
}


import jk from "./jk";
export Class Zhi implements jk{
       class:any;
       abc(data:any):void{
           this.class=data;
       }
       def(name:any):void{
           this.class.abc(name);
       }
}



//调用(使用)
import jk from "./jk";
import A from "./A";
import B form "./B";
import Zhi from "./Zhi";
export Class Main extends Laya.sprite{
       start(){
            let a=new Zhi();
                a.abc(new A());
                a.def("aa");
       }
       update(){

       }
}

接口注入

//定义接口
export Interface jk{
       abc():void;
       def():void;
}
//实现接口
import jk from "./jk";
export Class A implements jk{
       abc(name:any):void{
           console.log("A");
       }
       def(name:any):void{
           console.log("A");
       }
}


import jk from "./jk";
export Class B implements jk{
       zhi:any;
       abc(name:any):void{
           this.zhi=name;
       }
       def(name:any):void{
           this.zhi.abc(name);
       }
}


//调用(使用)
import jk from "./jk";
import A from "./A";
import B form "./B";
export Class Main extends Laya.sprite{
       start(){
            let b=new B();
                b.abc(new A());
                b.def("a");
       }
       update(){

       }
}

属性注入

//定义接口
export Interface jk{
       abc():void;
       def():void;
}
//实现接口
import jk from "./jk";
export Class A implements jk{
       abc(name:any):void{
           console.log("A");
       }
       def(name:any):void{
           console.log("A");
       }
}


import jk from "./jk";
export Class B implements jk{
       zhi:any;
       abc(name:any):void{
           this.zhi.abc(name);
       }
       def(name:any):void{
           this.zhi.abc(name);
       }
}


//调用(使用)
import jk from "./jk";
import A from "./A";
import B form "./B";
export Class Main extends Laya.sprite{
       start(){
            let b=new B();
                b.zhi=new A();
                b.abc("a");
                b.def("b");
       }
       update(){

       }
}

map集合注入

//定义接口
export Interface jk{
       abc():void;
       def():void;
}
//实现接口
import jk from "./jk";
export Class A implements jk{
       abc(name:any):void{
           console.log("A");
       }
       def(name:any):void{
           console.log("A");
       }
}


import jk from "./jk";
export Class B implements jk{
       zhi:any;
       abc(name:any):void{
           this.zhi.abc(name);
       }
       def(name:any):void{
           this.zhi.abc(name);
       }
}

//map
export Class Maps{

       map:Map;
       start(){
          this.map=new Map<string:any>();
       }
       //添加实例
       sett(name:any,class:any){
          this.map.set(name,class);
       }
       //获取实例
       gett(name:any){
          return this.map.get("name");
       }
}
//调用(使用)
import jk from "./jk";
import A from "./A";
import B form "./B";
import Maps from "./Maps";
export Class Main extends Laya.sprite{
       start(){
          let map=new Maps();
              map.sett("A",new A());
              map.sett("B",new B());
              map.gett("A").abc("想在哪个类里面用就直接调用这个方法就行了");
       }
       update(){

       }
}

观察者模式

观察者模式是一种行为型设计模式，它定义了对象之间的一种一对多依赖关系，当一个对象（被观察者/主题）状态改变时，所有依赖它的对象（观察者）都会自动收到通知并更新。