用23种设计模式打造一个cocos creator的游戏框架----(九)访问者模式_cocos creator 用户数据结构设计

1、模式标准

模式名称：访问者模式

模式分类：行为型

模式意图：将数据操作与数据结构分离，使得在不修改数据结构的前提下，可以添加或改变对数据的操作。

结构图：

适用于：

1. 当你需要对一个复杂对象结构执行一些操作，并且你希望实现这些操作与该对象结构的类无关时。访问者模式使得你可以在不修改现有类的情况下添加新的操作。

2. 当你需要清洁并且有逻辑的方式来操作复杂的对象结构时。将相关的操作逻辑放在一个访问者类中，使得你可以将复杂的操作逻辑与数据结构的类分离。

3. 当你需要在不同的类上执行类似的操作，而不希望污染这些类的接口时。访问者模式允许你在不影响其他类的情况下添加新的操作。

2、分析与设计  

访问者模式，简单描述就是一个访问者访问了你，对你提了一些建议和操作。这里打个比方，比如本来你只会发1234567乐符发音，音乐老师访问者过来说，听他的指挥，你说好的(accept)，之后你就听从音乐老师的指挥，哼出了一个曲调。老师一走，你就啥都不会了。

在游戏设计中，不确定其他人是如何用这个访问者模式的，但是我的第一感觉是是否能用在攻击上面，比如单位A对单位B发动了一个火球攻击，火球在遇到单位B时，对其产生了伤害。这个火球只是一个特效，火球的伤害就是伤害访问者。

来问一下GPT是如何说的

在游戏开发中，访问者模式可以被用于处理各种复杂的游戏逻辑，包括你所描述的攻击和属性修改的场景。让我们来看一下这种方式的一些可能优点和缺点。

优点：

1. 分离游戏逻辑：访问者模式可以将攻击逻辑和单位属性的修改逻辑从实体类（如单位类）中分离出来，使得代码更易于理解和维护。

2. 易于添加新的操作：如果你在未来需要添加新的攻击方式或者修改属性的方式，你可以通过添加新的访问者类来实现，而不需要修改现有的单位类。

缺点：

1. 可能会破坏封装：访问者模式需要访问者类能够访问被访问元素的内部状态（在这个案例中是单位的属性），这可能会破坏被访问元素的封装。

2. 可能导致代码更复杂：如果游戏的逻辑不是很复杂，使用访问者模式可能会使代码变得不必要的复杂。

总的来说，将一次攻击作为攻击访问者，然后在攻击访问者中计算对被攻击单位的属性的修改，是一种可行的方式。但是，是否应该使用这种方式，取决于你的具体需求，包括你的游戏的复杂性，你对易于理解和维护的需求，以及你对封装的考虑等。

会破坏封装？什么意思，继续问

“这句话有些不理解，“可能会破坏被访问元素的封装””

“封装”是面向对象编程中的一个重要概念，它指的是将对象的内部状态和实现细节隐藏起来，只暴露出一组公开的接口供外部使用。封装有助于保护对象的内部状态不被外部直接修改，也有助于减少代码之间的耦合，使得代码更易于理解和维护。

在访问者模式中，访问者类需要访问被访问元素的内部状态，以便执行一些操作。这就意味着被访问元素需要提供一些公开的接口来暴露其内部状态，这可能会破坏被访问元素的封装。具体来说，一些本应该是私有的数据或者实现细节可能会被暴露出来，这可能使得被访问元素变得更加脆弱，也可能使得代码更难以理解和维护。

例如，假设你有一个Unit类，它有一些私有的属性，如health（生命值）和armor（护甲）。在一般情况下，你可能只会提供一些公开的方法来修改这些属性，如decreaseHealth和increaseArmor，而不会直接暴露这些属性。但是，如果你使用访问者模式，你可能需要提供一些公开的接口来让AttackVisitor能够直接访问和修改health和armor，这就破坏了Unit的封装。

你有什么好的建议吗？

 对于这个问题，一种可能的解决方案是使用 "双重分派"（double dispatch）。在这种模式下，你可以在被访问者（如单位）中定义一个接受访问者的方法，并在这个方法中调用访问者的相应方法。这样，访问者可以在被访问者的上下文中执行操作，而不需要直接访问被访问者的内部状态。下面是一个简化的示例：

class Unit {
    constructor(health, armor) {
        this.health = health;
        this.armor = armor;
    }
 
    accept(visitor) {
        visitor.visitUnit(this);
    }
 
    decreaseHealth(amount) {
        this.health -= amount;
    }
 
    increaseArmor(amount) {
        this.armor += amount;
    }
}
 
class AttackVisitor {
    constructor(damage) {
        this.damage = damage;
    }
 
    visitUnit(unit) {
        unit.decreaseHealth(this.damage);
        // 更复杂的攻击逻辑可以在这里添加
    }
}
 
let unit = new Unit(100, 50);
let attackVisitor = new AttackVisitor(10);
unit.accept(attackVisitor);

 

在上面的代码中，AttackVisitor可以通过调用visitUnit方法来修改Unit的状态，而不需要直接访问Unit的health和armor属性。这样，Unit的封装性就得到了保护。

这种方法的一个缺点是，如果你有多种类型的单位，你可能需要在AttackVisitor中为每种单位类型定义一个不同的visit方法。然而，这种问题可以通过使用一些设计模式，如"策略模式"或"组合模式"，来解决。

这种方法的一个优点是，你可以轻松地添加新的访问者，如DefenseVisitor，而不需要修改Unit类。这是访问者模式的一个主要优点。

总得来说的是可行的方案。

意图：将数据操作（伤害操作）与数据结构(受攻击者)分离，使得在不修改数据结构(受攻击者)的前提下，可以添加或改变对数据的操作（伤害操作）。

3、开始打造

import { IUnitItem } from "../items/IItem"
 
export interface IAttackVisitor {
    // 普通单位
    visitNormalUnitItem(unitItem: IUnitItem): void
    // 英雄单位
    visitHeroUnitItem(unitItem: IUnitItem): void
}

 

import { IUnitItem } from "../items/IItem";
import { IAttackVisitor } from "./IAttackVisitor";
 
// 单体攻击
export class MonomerAttackVisitor implements IAttackVisitor {
    damage: number = 0
    constructor(damage: number) {
        this.damage = damage
    }
    // 普通单位
    visitUnitItem(unitItem: IUnitItem): void {
        unitItem.subHp(this.damage)
    }
    // 英雄单位，受到伤害值为0.8
    visitHeroUnitItem(unitItem: IUnitItem): void {
        unitItem.subHp(this.damage * 0.8)
    }
}

 

import { IUnitItem } from "../items/IItem";
import { IAttackVisitor } from "./IAttackVisitor";
 
// 群体(衍射)攻击
export class GroupAttackVisitor implements IAttackVisitor {
    damage: number = 0
    constructor(damage: number) {
        this.damage = damage
    }
    // 普通单位
    visitUnitItem(unitItem: IUnitItem): void {
        unitItem.subHp(this.damage)
        // todo 周围单位也受到伤害
    }
    // 英雄单位，受到伤害值为0.8
    visitHeroUnitItem(unitItem: IUnitItem): void {
        unitItem.subHp(this.damage * 0.8)
        // todo 周围单位也受到伤害
    }
}

export interface IUnitItem {
    hp: number
    subHp(hp: number): void
    accept(visitor: IAttackVisitor): void
}

export class UnitItem extends Component implements IItem, IUnitItem {
 
    accept(visitor: IAttackVisitor) {
        visitor.visitUnitItem(this)
    }
 
 
}

4、开始使用 

export class UnitItem  extends Component implements IItem, IUnitItem {
 
    ad: number = 100;
 
    accept(visitor: IAttackVisitor) {
        visitor.visitUnitItem(this)
    }
 
    attack(unitItem: UnitItem) {
        let damage = this.ad
        let attackVisitor = new MonomerAttackVisitor(damage)
        unitItem.accept(attackVisitor)
    }
 
}

let unitItem001 = xhgame.itemFactory.createUnitItem('shibing_001')
let unitItem002 = xhgame.itemFactory.createUnitItem('shibing_002')
 
unitItem001.attack(unitItem002)

有了访问者模式后，伤害管理变得更简单，目前只是简单版本，后续还得继续完善