c#GDI+游戏编程：《疯狂的炸弹之幽灵之战v1.0》角色动画、绘制、走动 .

/*_______________________________________________________________

 

     动画的原理就是连续绘制/播放图片，当每秒绘制/播放不同表情、动作图片一定幅数的时候就是造成视觉错觉，就会看到很流畅的动画效果！有了动画，物体才有了灵魂和生命。

     游戏对象分析：

     游戏中只有一部分对象是有生命的，主要包括主角和幽灵等。下面先看下游戏的结构图：

 

     可以看到游戏主要分为2个部分，静止的对象和活动的对象，大家都继承一个基类，基类有一个抽象方法，就是绘制，所有的对象必须重写绘制方法以呈现自己的画面。

BaseEntity

[c-sharp] view plain copy print ?

1. public abstract class BaseEntity  
2. {  
3.     /// <summary>   
4.     /// 对象坐标   
5.     /// </summary>   
6.     public Point Poi;  
7.   
8.     /// <summary>   
9.     ///  绘制对象   
10.     /// </summary>   
11.     public abstract void Draw(Graphics g);  
12. }  

public abstract class BaseEntity { /// <summary> /// 对象坐标 /// </summary> public Point Poi; /// <summary> /// 绘制对象 /// </summary> public abstract void Draw(Graphics g); }

     以游戏中炸弹的绘制为例，代码如下：

Bomb

[c-sharp] view plain copy print ?

1. /// <summary>   
2.   /// 炸弹   
3.   /// </summary>   
4.   public class Bomb : BaseEntity  
5.   {  
6.       //爆炸延迟时间   
7.       public int ExplodeDelay = 50;  
8.       Bitmap[] bmps = new Bitmap[Utility.BombFrames];  
9.   
10.       /// <summary>   
11.       /// 默认从资源初始化数据   
12.       /// </summary>   
13.       public Bomb()  
14.       {  
15.           bmps = InitResources.Instance.InitStaticObjects(  
16.               Utility.BombValue,  
17.               Utility.BombFrames,  
18.               new Size(Utility.BombSizeWidth, Utility.BombSizeHeight),  
19.               InitMode.FromResource);  
20.       }  
21.   
22.       private int i = 0;  
23.       public override void Draw(Graphics g)  
24.       {  
25.           i = i + 1 < Utility.BombFrames ? i + 1 : 0;  
26.           g.DrawImage(bmps[i], Poi.X, Poi.Y, Utility.GridSize,Utility.GridSize);  
27.       }  
28.   }  

/// <summary> /// 炸弹 /// </summary> public class Bomb : BaseEntity { //爆炸延迟时间 public int ExplodeDelay = 50; Bitmap[] bmps = new Bitmap[Utility.BombFrames]; /// <summary> /// 默认从资源初始化数据 /// </summary> public Bomb() { bmps = InitResources.Instance.InitStaticObjects( Utility.BombValue, Utility.BombFrames, new Size(Utility.BombSizeWidth, Utility.BombSizeHeight), InitMode.FromResource); } private int i = 0; public override void Draw(Graphics g) { i = i + 1 < Utility.BombFrames ? i + 1 : 0; g.DrawImage(bmps[i], Poi.X, Poi.Y, Utility.GridSize,Utility.GridSize); } }

     首先初始化炸弹素材，然后重写绘制方法，逐帧绘制，这样一个简单的动画效果就出现了！

     区别于静止的对象，活动的对象自然会有自己运动的方法，比如移动、跳跃等动作，这也很简单，只是改变对象x,y坐标即可。游戏中的主角和怪物都是有生命的活动体，基本属性成员一致，所以定义一个ActivityEntity类，以便更好重用代码。

ActivityEntity

[c-sharp] view plain copy print ?

1. /// <summary>   
2.     /// 方向枚举   
3.     /// </summary>   
4.     public enum Direction  
5.     {  
6.         Left,   //向左   
7.         Up,     //向上   
8.         Right,  //向右   
9.         Down,   //向下   
10.         Static  //原地不动   
11.     }  
12.   
13.     /// <summary>   
14.     /// 有生命的对象   
15.     /// </summary>   
16.     public class ActivityEntity:BaseEntity  
17.     {  
18.         //角色(包括主角和敌人)   
19.         public string Role;  
20.         //生命   
21.         public int Life;  
22.         //速度   
23.         public int Speed=1;  
24.         //方向   
25.         public Direction Direction;  
26.         //记录帧   
27.         private int Frame=0;  
28.   
29.         //存放角色行走图   
30.         protected Bitmap[][] bmps = new Bitmap[Utility.RoleDirections][]  
31.             {  
32.                 new Bitmap[Utility.RoleSteps], //下   
33.                 new Bitmap[Utility.RoleSteps], //左   
34.                 new Bitmap[Utility.RoleSteps], //右   
35.                 new Bitmap[Utility.RoleSteps]  //上   
36.             };  
37.   
38.         //默认从资源访问   
39.         public ActivityEntity(string role)  
40.         {  
41.             if (!string.IsNullOrEmpty(role))  
42.             {  
43.                 this.Role = role;  
44.                 InitActivityEntity(Role, InitMode.FromResource);  
45.             }  
46.         }  
47.   
48.         public ActivityEntity(string role, InitMode mode)  
49.         {  
50.             if (!string.IsNullOrEmpty(role))  
51.             {  
52.                 this.Role = role;  
53.                 InitActivityEntity(Role, mode);  
54.             }  
55.         }  
56.   
57.         /// <summary>   
58.         /// 初始化游戏角色   
59.         /// </summary>   
60.         /// <param name="role">角色名称</param>   
61.         /// <param name="mode"></param>   
62.         private void InitActivityEntity(string role, InitMode mode)  
63.         {  
64.             switch (mode)  
65.             {  
66.                 case InitMode.FromResource:  
67.                     bmps = InitResources.Instance.InitActivityObjects(role, InitMode.FromResource);  
68.                     break;  
69.                 case InitMode.FromFilePath:  
70.                     if (System.IO.File.Exists(role))  
71.                         bmps = InitResources.Instance.InitActivityObjects(role, InitMode.FromFilePath);  
72.                     break;  
73.             }  
74.         }  
75.   
76.         /// <summary>   
77.         /// 角色移动   
78.         /// </summary>   
79.         public virtual void Move()  
80.         {  
81.             switch (Direction)  
82.             {  
83.                 case Direction.Left:  
84.                     Poi.X -= Speed;  
85.                     break;  
86.                 case Direction.Up:  
87.                     Poi.Y -= Speed;  
88.                     break;  
89.                 case Direction.Right:  
90.                     Poi.X += Speed;  
91.                     break;  
92.                 case Direction.Down:  
93.                     Poi.Y += Speed;  
94.                     break;  
95.                 case Direction.Static:  
96.                     break;  
97.             }  
98.         }  
99.   
100.         /// <summary>   
101.         /// 记录帧   
102.         /// </summary>   
103.         public void RecordFrame()  
104.         {  
105.             switch (Direction)  
106.             {  
107.                 case Direction.Left:  
108.                     Frame = 1;  
109.                     break;  
110.                 case Direction.Up:  
111.                     Frame = 3;  
112.                     break;  
113.                 case Direction.Right:  
114.                     Frame = 2;  
115.                     break;  
116.                 case Direction.Down:  
117.                     Frame = 0;  
118.                     break;  
119.                 case Direction.Static:  
120.                     break;  
121.             }  
122.         }  
123.   
124.         /// <summary>   
125.         /// 重写绘制对象方法   
126.         /// </summary>   
127.         private int i = 0;  
128.         public override void Draw(Graphics g)  
129.         {  
130.             switch (Direction)  
131.             {  
132.                 case Direction.Down:   
133.                 case Direction.Left:  
134.                 case Direction.Right:  
135.                 case Direction.Up:  
136.                     i = i + 1 < Utility.RoleSteps ? i + 1 : 0;  
137.                     break;  
138.                 case Direction.Static:  
139.                     i = 0;  
140.                     break;  
141.             }  
142.             g.DrawImage(bmps[Frame][i], Poi.X, Poi.Y, Utility.GridSize, Utility.GridSize);  
143.         }  
144.     }  

/// <summary> /// 方向枚举 /// </summary> public enum Direction { Left, //向左 Up, //向上 Right, //向右 Down, //向下 Static //原地不动 } /// <summary> /// 有生命的对象 /// </summary> public class ActivityEntity:BaseEntity { //角色(包括主角和敌人) public string Role; //生命 public int Life; //速度 public int Speed=1; //方向 public Direction Direction; //记录帧 private int Frame=0; //存放角色行走图 protected Bitmap[][] bmps = new Bitmap[Utility.RoleDirections][] { new Bitmap[Utility.RoleSteps], //下 new Bitmap[Utility.RoleSteps], //左 new Bitmap[Utility.RoleSteps], //右 new Bitmap[Utility.RoleSteps] //上 }; //默认从资源访问 public ActivityEntity(string role) { if (!string.IsNullOrEmpty(role)) { this.Role = role; InitActivityEntity(Role, InitMode.FromResource); } } public ActivityEntity(string role, InitMode mode) { if (!string.IsNullOrEmpty(role)) { this.Role = role; InitActivityEntity(Role, mode); } } /// <summary> /// 初始化游戏角色 /// </summary> /// <param name="role">角色名称</param> /// <param name="mode"></param> private void InitActivityEntity(string role, InitMode mode) { switch (mode) { case InitMode.FromResource: bmps = InitResources.Instance.InitActivityObjects(role, InitMode.FromResource); break; case InitMode.FromFilePath: if (System.IO.File.Exists(role)) bmps = InitResources.Instance.InitActivityObjects(role, InitMode.FromFilePath); break; } } /// <summary> /// 角色移动 /// </summary> public virtual void Move() { switch (Direction) { case Direction.Left: Poi.X -= Speed; break; case Direction.Up: Poi.Y -= Speed; break; case Direction.Right: Poi.X += Speed; break; case Direction.Down: Poi.Y += Speed; break; case Direction.Static: break; } } /// <summary> /// 记录帧 /// </summary> public void RecordFrame() { switch (Direction) { case Direction.Left: Frame = 1; break; case Direction.Up: Frame = 3; break; case Direction.Right: Frame = 2; break; case Direction.Down: Frame = 0; break; case Direction.Static: break; } } /// <summary> /// 重写绘制对象方法 /// </summary> private int i = 0; public override void Draw(Graphics g) { switch (Direction) { case Direction.Down: case Direction.Left: case Direction.Right: case Direction.Up: i = i + 1 < Utility.RoleSteps ? i + 1 : 0; break; case Direction.Static: i = 0; break; } g.DrawImage(bmps[Frame][i], Poi.X, Poi.Y, Utility.GridSize, Utility.GridSize); } }

    可以看到Move()方法就是根据不同方向改变对象的x,y，这样简单的几句我们的主角就可以移动了。以主角为例：

Actor

[c-sharp] view plain copy print ?

1. /// <summary>   
2. /// 游戏主角   
3. /// </summary>   
4. public class Actor : ActivityEntity  
5. {  
6.     //财富   
7.     public int Money;  
8.   
9.     public Actor()  
10.         : base(Utility.ActorValue)  
11.     {  
12.     }  
13.   
14.     public Actor(string role, InitMode mode)  
15.         : base(role, mode)  
16.     { }  
17.   
18.     public void Move(bool passable)  
19.     {  
20.         if (passable)  
21.         {  
22.             base.Move();  
23.             base.RecordFrame();  
24.         }  
25.         else  
26.         {  
27.             base.RecordFrame();  
28.         }  
29.     }  
30. }  

/// <summary> /// 游戏主角 /// </summary> public class Actor : ActivityEntity { //财富 public int Money; public Actor() : base(Utility.ActorValue) { } public Actor(string role, InitMode mode) : base(role, mode) { } public void Move(bool passable) { if (passable) { base.Move(); base.RecordFrame(); } else { base.RecordFrame(); } } }

    继承活动体，并重载了Move()方法，这个方法主要是实现如果没有障碍物，则移动并实现主角动画；反之只记录帧。

效果图：(看不到效果保存到本地浏览)