策略模式在游戏客户端中的应用

mvc不讲了。说一个非常有用的：策略模式。

策略模式的思想在设计模式里面写的非常清楚，概括下来就是将行为和行为的实现分离。在head 设计模式这本书里面讲的例子也非常容易理解，基本上可以直接搬到游戏中来。

如图：

在游戏中，玩家，怪味，NPC，坐骑，宠物，侠客等等，他们都是可以活动的对象，也有一些共同的行为，所以都可以由一个基类派生出来，但是他们也有很多不同的行为，比如NPC不能战斗，坐骑不能说话，等等。

策略模式为我们很好地解决了这个问题，方法如下：

1 将各个行为在基类做出相应的接口，比如上面图章actor这个类拥有6个接口，移动，跳跃，跑动，谈话，换装，战斗。然后actor类用空的实现（什么事情都不做）来实现这些接口。然后各个子类在继承actor类时，就有了对所有接口的一个空实现了。

2 分析各个子类需要的实现方式，分别实现为各个行为类，比如玩家需要跳跃，那么实现一个玩家跳跃类，在role对象初始化时，将这个跳跃类的对象复制给行为变量，这样玩家就可以跳跃了；

下面贴一些伪代码，帮助理解：

[csharp]   view plain copy

1. public class Actor  
2. {  
3.     public TalkInterface talk;  
4.     public MoveInterface move;  
5.     public FightInterface fight;  
6.       
7.     public Actor()  
8.     {  
9.         talk = new DefaultTalk();  
10.         move = new DefaultMove();  
11.         fight = new DefaultFight();  
12.     }  
13. }  
14.   
15. public class Role : Actor  
16. {  
17.     public Role()  
18.     {  
19.         move = new NormalMove();  
20.         fight = new RoleFight();  
21.     }  
22. }  
23.   
24. public class Horse : Actor  
25. {  
26.     public Horse()  
27.     {  
28.         move = new HorseMove();  
29.     }  
30. }  
31.   
32. public class NPC : Actor  
33. {  
34.     public NPC()  
35.     {  
36.         talk = new NpcTalk();  
37.     }  
38. }  
39.   
40. interface TalkInterface  
41. {  
42.     void doTalk();  
43. }  
44.   
45. interface MoveInterface  
46. {  
47.     void doMove();  
48. }  
49.   
50. interface FightInterface  
51. {  
52.     void doFight();  
53. }  
54.   
55. public class DefaultTalk : TalkInterface  
56. {  
57.     void doTalk() // do nothing  
58.     {  
59.     }  
60. }  
61.   
62. public class DefaultMove : MoveInterface  
63. {  
64.     void doMove() // do nothing  
65.     {  
66.     }  
67. }  
68.   
69. public class DefaultFight : FightInterface  
70. {  
71.     void doFight() // do nothing  
72.     {  
73.     }  
74. }  
75.   
76. public class NpcTalk : TalkInterface  
77. {  
78.     public void doTalk()  
79.     {  
80.         ...  
81.     }  
82. }  
83.   
84. public class NormalMove : MoveInterface  
85. {  
86.     public void doMove()  
87.     {  
88.         ...  
89.     }  
90. }  
91.   
92. public class HorseMove : MoveInterface  
93. {  
94.     public void doMove()  
95.     {  
96.         ...  
97.     }  
98. }  
99.   
100. public class RoleFight : FightInterface  
101. {  
102.     public void doFight()  
103.     {  
104.         ...  
105.     }  
106. }  

这样的好处就有很多了，比如用基类的引用类型去调用各个子类对象的各个行为都可以正常工作了。