devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用23种设计模式打造一个cocos creator的游戏框架----(十二)状态模式_cocoscreator游戏框架

作者：菜鸟追梦旅行 | 2024-02-27 11:15:29

赞

踩

cocoscreator游戏框架

1、模式标准

模式名称：状态模式

模式分类：行为型

模式意图：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

结构图：

适用于：

1、一个对象的行为决定于它的状态，并且它必须在运行时刻根据状态改变它的行为。

2、一个操作中含有庞大的多分支的条件语句，且这些分支依赖丁该对象的状态。这个状态常用一个或多个枚举常量表示。通常，有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这使得开发者可以根据对象自身的情况将对象的状态作为一个对象，这一对象可以不依赖于其他对象独立变化。

主要成员：

  • 上下文（Context）：它定义了客户端感兴趣的接口，并且维护一个指向当前状态的实例变量。
  • 状态抽象（State）：这是一个接口或者抽象类，它定义了每个状态必须实现的方法。
  • 具体状态（Concrete States）：它们是实现状态接口的类，每个类对应一种状态，且包含了该状态下的行为实现。

2、分析与设计  

在一般的游戏开发中状态值通常是一个枚举值，但在状态模式中，状态值是一个通过实现了 IUnitState 接口的对象表示的。这种方法的优点是它更加灵活和强大，因为这个状态值不仅仅是一个值，它还是一组行为的集合（即方法实现）。这允许您在不同的状态之间切换行为，而不是仅仅改变一个表示状态的值。

在游戏中的单位一般有以下几种状态：站立，移动，攻击，释放技能中,眩晕中,死亡。比较常见的是单位正在释放一个技能，这个时候一个飞锤飞过来，将他击晕了，他停止了技能的释放。

接下来我们修改一下我们的意图

意图：允许一个对象(单位)在其内部状态改变时(由其状态对象来)改变它的行为。对象看起来似乎修改了它的类(实际是状态对象干的)。

3、开始打造

  1. export enum UnitStateType {
  2.     Standing,
  3.     Moving,
  4.     Attacking,
  5.     CastSkilling,
  6.     Stuning,
  7.     Die
  8. }
  1. export interface IUnitState {
  2.     enterState(unitItem: IUnitItem): void
  3.     //
  4.     stand(): void; // 站立
  5.     move(): void; // 移动
  6.     attack(): void; // 攻击
  7.     castSkill(): void; // 释放技能
  8.     stun(): void; // 击晕
  9.     die(): void; // 死亡
  10.     // 
  11.     getType(): UnitStateType
  12. }
  1. // 状态基类，包含一个指向Unit的引用
  2. export abstract class BaseState implements IUnitState {
  3.     protected unitItem: IUnitItem;
  4.  
  5.     enterState(unitItem: IUnitItem) {
  6.         this.unitItem = unitItem;
  7.     }
  8.     // 获取状态的type值
  9.     abstract getType(): UnitStateType;
  10.     // 状态
  11.     stand() {
  12.         console.log(this.unitItem, "单位准备进入站立状态");
  13.         this.unitItem.setState(new StandingState());
  14.     }
  15.     move() {
  16.         console.log(this.unitItem, "单位准备进入移动状态");
  17.         this.unitItem.setState(new MovingState());
  18.     }
  19.     attack(): void {
  20.         console.log(this.unitItem, "单位准备进入攻击状态");
  21.         this.unitItem.setState(new AttackingState());
  22.     }
  23.     castSkill(): void {
  24.         console.log(this.unitItem, "单位准备进入释放技能状态");
  25.         this.unitItem.setState(new CastSkillingState());
  26.     }
  27.     stun(): void {
  28.         console.log(this.unitItem, "单位准备进入击晕状态");
  29.         this.unitItem.setState(new StuningState());
  30.     }
  31.     die() {
  32.         console.log(this.unitItem, "单位准备进入死亡状态");
  33.         this.unitItem.setState(new DeadState());
  34.     }
  35.  
  36. }
  1.  
  2. // 站立状态
  3. export class StandingState extends BaseState {
  4.  
  5.     getType(): UnitStateType {
  6.         return UnitStateType.Standing;
  7.     }
  8.  
  9.     // 重写方法
  10.     stand() {
  11.         console.log(this.unitItem, "单位已经进入站立状态");
  12.     }
  13.  
  14. }
  15.  
  16. // 移动状态
  17. export class MovingState extends BaseState {
  18.  
  19.     getType(): UnitStateType {
  20.         return UnitStateType.Moving;
  21.     }
  22.  
  23.     // 重写方法
  24.     move() {
  25.         console.log(this.unitItem, "单位已经进入移动状态");
  26.     }
  27.  
  28. }
  29.  
  30. // 攻击状态
  31. export class AttackingState extends BaseState {
  32.  
  33.     getType(): UnitStateType {
  34.         return UnitStateType.Attacking;
  35.     }
  36.     enterState(unitItem: IUnitItem) {
  37.         super.enterState(unitItem);
  38.         this.doAction();
  39.     }
  40.  
  41.     doAction() {
  42.         // 执行攻击
  43.         this.unitItem.role.attack(); // 攻击
  44.         // 如果攻击顺利完成，进行清理并返回到正常状态
  45.         // 例如，设置一个延时来模拟攻击动作的时间
  46.         let attackDuration = 1000
  47.         setTimeout(() => {
  48.             if (this.unitItem.getCurrentState().getType() == UnitStateType.Attacking) {
  49.                 console.log('单位已从攻击状态到站立状态')
  50.                 this.unitItem.setState(new StandingState());
  51.             }
  52.         }, attackDuration);
  53.     }
  54.     // 重写方法
  55.     attack(): void {
  56.         console.log(this.unitItem, "单位已经进入攻击状态");
  57.     }
  58.  
  59. }
  60.  
  61. // 释放技能状态
  62. export class CastSkillingState extends BaseState {
  63.  
  64.     getType(): UnitStateType {
  65.         return UnitStateType.CastSkilling;
  66.     }
  67.  
  68.     enterState(unitItem: IUnitItem) {
  69.         super.enterState(unitItem);
  70.         this.doAction();
  71.     }
  72.  
  73.     doAction() {
  74.         // 执行攻击
  75.         // this.unitItem.role.attack(); // 攻击
  76.         // 如果攻击顺利完成，进行清理并返回到正常状态
  77.         // 例如，设置一个延时来模拟攻击动作的时间
  78.         let attackDuration = 1000
  79.         setTimeout(() => {
  80.             if (this.unitItem.getCurrentState().getType() == UnitStateType.CastSkilling) {
  81.                 console.log('单位已从技能释放状态到站立状态')
  82.                 this.unitItem.setState(new StandingState());
  83.             }
  84.         }, attackDuration);
  85.     }
  86.     // 重写方法
  87.     castSkill(): void {
  88.         console.log(this.unitItem, "单位已经进入释放技能状态");
  89.     }
  90.  
  91. }
  92.  
  93.  
  94. // 击晕状态
  95. export class StuningState extends BaseState {
  96.  
  97.     getType(): UnitStateType {
  98.         return UnitStateType.Stuning;
  99.     }
  100.  
  101.     enterState(unitItem: IUnitItem) {
  102.         super.enterState(unitItem);
  103.         this.stopCurrentAction();
  104.     }
  105.     // 重写方法
  106.     stun(): void {
  107.         console.log(this.unitItem, "单位已经进入击晕状态");
  108.     }
  109.  
  110.     stopCurrentAction() {
  111.         console.log(this.unitItem, "单位所有动作停止，因为被击晕");
  112.         // 如果有正在进行的释放技能的操作，这里将其中断
  113.         // 这可能包括清除技能计时器、动画等
  114.     }
  115.  
  116. }
  117. // 死亡状态
  118. export class DeadState extends BaseState {
  119.  
  120.     getType(): UnitStateType {
  121.         return UnitStateType.Dead;
  122.     }
  123.  
  124.     enterState(unitItem: IUnitItem) {
  125.         super.enterState(unitItem);
  126.         this.stopCurrentAction();
  127.     }
  128.     // 重写方法
  129.     die() {
  130.         console.log(this.unitItem, "单位已经进入死亡状态");
  131.     }
  132.  
  133.     stopCurrentAction() {
  134.         console.log(this.unitItem, "单位所有动作停止，因为已死亡");
  135.         // 如果有正在进行的释放技能的操作，这里将其中断
  136.         // 这可能包括清除技能计时器、动画等
  137.     }
  138. }

接着是单位里的

  1. export class UnitItem  extends Component implements IItem, IUnitItem {
  2.  
  3.     ad: number = 100;
  4.     mp: number = 0;
  5.     role: Fighter;
  6.     private currentState: IUnitState = null;
  7.  
  8.     accept(visitor: IAttackVisitor) {
  9.         visitor.visitUnitItem(this)
  10.     }
  11.  
  12.  
  13.     setRole(role: Fighter): void {
  14.         this.role = role;
  15.     }
  16.  
  17.     setState(state: IUnitState) {
  18.         this.currentState = state;
  19.         state.enterState(this);
  20.     }
  21.     getCurrentState(): IUnitState {
  22.         if (this.currentState == null) {
  23.             this.setState(new StandingState())
  24.         }
  25.         return this.currentState;
  26.     }
  27.     move() {
  28.         this.getCurrentState().move()
  29.     }
  30.     idle() {
  31.         this.getCurrentState().stand()
  32.     }
  33.     attack(unitItem: UnitItem<T>) {
  34.         if (!this.canAttack()) {
  35.             // 不能处理攻击的逻辑，可能是显示消息或者进入其他状态
  36.             return;
  37.         }
  38.         // 尝试进入攻击状态
  39.         this.getCurrentState().attack()
  40.         let damage = this.ad
  41.         let attackVisitor = new MonomerAttackVisitor(damage)
  42.         unitItem.accept(attackVisitor)
  43.  
  44.         // 临时 todo 删除
  45.         console.log('假装本次攻击带有击晕效果')
  46.         unitItem.getCurrentState().stun()
  47.  
  48.     }
  49.     skill() {
  50.         if (!this.canSkill()) {
  51.             // 不能处理攻击的逻辑，可能是显示消息或者进入其他状态
  52.             return;
  53.         }
  54.         // 尝试进入攻击状态
  55.         this.getCurrentState().castSkill()
  56.     }
  57.  
  58.     die() {
  59.         this.getCurrentState().die()
  60.     }
  61.     private canSkill(): boolean {
  62.         // 检查单位是否可以进行技能攻击
  63.         // 例如，单位是否处于晕眩状态或者攻击是否冷却中
  64.         if (this.mp < 100) {
  65.             console.log('不能处理skill攻击的逻辑,因为魔法值不足100')
  66.             return false
  67.         }
  68.         if (this.getCurrentState().getType() == UnitStateType.CastSkilling) {
  69.             console.log('不能处理skill攻击的逻辑,因为已经处于技能释放中')
  70.             return false
  71.         }
  72.         if (this.getCurrentState().getType() == UnitStateType.Stuning) {
  73.             console.log('不能处理skill攻击的逻辑,因为已经被击晕')
  74.             return false
  75.         }
  76.         if (this.getCurrentState().getType() == UnitStateType.Dead) {
  77.             console.log('不能处理skill攻击的逻辑,因为已经死亡')
  78.             return false
  79.         }
  80.         return true;
  81.     }
  82.  
  83.     private canAttack(): boolean {
  84.         // 检查单位是否可以进行攻击
  85.         // 例如，单位是否处于晕眩状态或者攻击是否冷却中
  86.         if (this.getCurrentState().getType() == UnitStateType.Attacking) {
  87.             console.log('不能处理攻击的逻辑,因为已经处于攻击中')
  88.             return false
  89.         }
  90.         if (this.getCurrentState().getType() == UnitStateType.Stuning) {
  91.             console.log('不能处理攻击的逻辑,因为已经被击晕')
  92.             return false
  93.         }
  94.         if (this.getCurrentState().getType() == UnitStateType.Dead) {
  95.             console.log('不能处理攻击的逻辑,因为已经死亡')
  96.             return false
  97.         }
  98.         return true;
  99.     }
  100. }

 在非状态对象类中使用时都是用以下的方式调用

  1. this.getCurrentState().stand()
  2. this.getCurrentState().move()

   在方法里面会执行从当前状态到下一个状态所需要的动作

在状态类中，如果需要到下一个状态就需要再状态类中new一个新的状态，如

  1.     castSkill(): void {
  2.         console.log(this.unitItem, "单位准备进入释放技能状态");
  3.         this.unitItem.setState(new CastSkillingState());
  4.     }

接着在下一个状态CastSkillingState中的enterState，方法内其他动作

4、开始使用

  

  1.         let unitItem001 = xhgame.itemFactory.createUnitItem('kuloubing', UnitType.UnitSpine)
  2.         let unitItem002 = xhgame.itemFactory.createUnitItem('kuloubing', UnitType.UnitSpine)
  3.  
  4.         unitItem001.idle()
  5.         unitItem002.idle()
  6.         unitItem002.skill()
  7.         unitItem002.mp = 100;
  8.         unitItem002.skill()
  9.  
  10.         unitItem001.setRole(new Cavalry(new Sword()));
  11.         console.log('unitItem001(骑兵)准备使用【剑】对unitItem002发起了攻击')
  12.         unitItem001.attack(unitItem002)
  13.  
  14.         unitItem001.setRole(new Cavalry(new Bow()));
  15.         console.log('unitItem001(骑兵)准备使用【弓】对unitItem002发起了攻击')
  16.         unitItem001.attack(unitItem002)

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

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

  

闽ICP备14008679号