从零开始学AS3游戏开发

从零开始学AS3游戏开发【一】响应键盘移动的方块

注：本系列教程每周一篇，旨在引导刚刚接触FLASH的新手通过实例进行游戏开发的学习。在过程中逐步说明涉及到的类及对应的使用方法。从一个光秃秃的方块开始，根据不同的控制方式、玩法产生不同的分支，最终完善成一个个可玩的游戏。希望对各位入门的朋友有所帮助！在教程涉及的各种处理方法，可能不够完善，也希望各位高手指正：）

转载请注名来源于天地会。

第一篇响应键盘事件的方块

准备工作：FLASH CS3/4/5,FlashDevelop （https://www.360docs.net/doc/948401717.html,/community/viewforum.php?f=11）

开发目标：实现一个受键盘控制的方块

相关API：Sprite,KeyboradEvent

我们即将开始构建一个游戏世界……

任何属于这个世界的物体，我们都叫它游戏对象(gameObject)。它是游戏的基本元素，所有的一切都是从它衍生而来。有的游戏对象可以被我们操作，因此，我们需要分配给它一个控制器(controller)，并通过这个装置来控制它。我们一次不可能看遍全部世界，所以，我们必须有一个舞台(gameScene)，让我们想看到的游戏对象来到这个舞台上表演。所有的一切。都通过这个舞台开始……

首先，做一下准备工作：

首先打开FlashDevelop，新建一个项目。

选择FLASH IDE项目，选择一个保存目录，并选择一个你喜欢的名字。

在项目名上点右键，选择Add -> New Class，输入文件名Main，选择base Class后面的Browse按钮，输入Sprite

这样，我们就建立了一个继承自Sprite类的对象Main。Sprite是FLASH的一个基本显示元素，它没有时间轴的概念。

打开FLASH CS3，新建一个ActionScript 3.0文件，并把它保存到刚才建立的项目的目录中。在属性栏里，把帧频改成30，文档类输入Main。

这样，我们就建立了一个可以由Main.as控制的FLASH文件。把刚才生成的Main.as改成像下面这样：

1.package

2.{

3. import flash.display.Sprite;

4.

5. public class Main extends Sprite

6. {

7.

8. public function Main()

9. {

10. trace('我运行咯！');

11. }

12.

13. }

14.

15.}

复制代码

回到FLASH CS里，按下ctrl+enter进行测试：

看到输出框里出现的输出，说明程序已经可以运行了。trace是FLASH中的消息输出命令，我们在今后的开发过程中会经常使用的。至此，准备工作完成。开始我们的创建之旅吧。

首先来建立游戏时间里的“亚当”——gameObject。在我们的项目里新建文件夹D5Power（起个自己喜欢的名字），并在D5Power下面再建一个文件夹Objects，最后，在Ojbects里Add一个New Class，输入文

件名gameObject，同样，base class选择Sprite。建立完成后，我们的项目看起来应该像这样了：

在FlashDevelop给我们生成的代码中，我们看到了package D5Power.Objects 这样的字眼。package即是包，我们的源代码可以存放在不同的包中，这样可以保持代码的结构清晰。包的名字实际上就是对应目录的名字。如package D5Power.Objects 这样，我们就可以知道gameObject文件是保存在D5Power/Objects/这个目录下面，如果package后面没有任何内容（比如我们刚才建立的Main），那么这个文件就是在项目的默认包（源代码的顶级目录）中。不同层级的包之间的访问，必须通过improt进行包含，而同级，以及访问默认包内的文件，是不需要的。这个我们以后会再继续详细的说明

回来考虑一下我们的“亚当”——gameObject，它是最基础的元素，所以，我们只给他定义最简单的可以做的事情，首先，他可以做一些事（至于做什么，我们先不考虑），另外，他会死亡。既然他可以产生在这个游戏世界里，那么他就必须可以从这个世界里消失的无影无踪：

1.package D5Power.Objects

2.{

3. import flash.display.Sprite;

4.

5. /**

6. * 基础游戏对象

7. * @author D5Power

8. */

9. public class gameObject extends Sprite

10. {

11.

12. public function gameObject()

13. {

14.

15. }

16. /**

17. * 做些什么

18. */

19. public function Do():void { }

20. /**

21. * 死亡

22. */

23. public function die():void{}

24.

25. }

26.

27.}

复制代码

我们定义了一个空的die函数，它什么也没做，我们将在以后慢慢的去补足它。现在，gameObject除了活着，就是死了。这显然不能满足我们的要求。所以我们必须让他繁衍下一代，并产生进化。在Objects里再新建一个类，命名为actionObject，把它的base class输入gameObject。现在，我们获得了一个“亚当的儿子”。他继承了亚当的全部特性（可以死亡），并可以有自己独特的事情可以做。

我们决定教他如何行走：

1.package D5Power.Objects

2.{

3. /**

4. * 可活动的游戏对象

5. * @author D5Power

6. */

7. public class ActionObject extends gameObject

8. {

9. /**

10. * 移动速度

11. */

12. protected var speed:Number = 1.2;

13. /**

14. * 移动方向

15. */

16. protected var walkDirection:uint=0

17.

18. public static const UP:uint = 1;

19. public static const DOWN:uint = 2;

20. public static const LEFT:uint = 3;

21. public static const RIGHT:uint = 4;

22.

23. public function ActionObject()

24. {

25.

26. }

27. /**

28. * 修改移动方向

29. */

30. public function set direction(dir:uint):void

31. {

32. walkDirection = dir;

33. }

34. /**

35. * 移动

36. */

37. protected function move():void

38. {

39. // 根据不同的方向进行移动

40. switch(walkDirection)

41. {

42. case UP:

43. y -= speed;

44. break;

45. case DOWN:

46. y += speed;

47. break;

48. case LEFT:

49. x -= speed;

50. break;

51. case RIGHT:

52. x += speed;

53. break;

54. default:break;

55. }

56. }

57.

58. /**

59. * 覆盖父类的Do方法

60. */

61. override public function Do():void

62. {

63. if (walkDirection != 0) move();

64. super.Do();

65. }

66. }

67.}

复制代码

在这段代码中，我们第一次接触到了一些关键字，下面对他们进行说明

var FLASH中定义变量用的前缀，比如var num:int = 5;定义一个整型变量num，默认值为5

function FLASH中定义函数的前缀，比如 function test():void{} 定义一个名为test的函数，没有返回值

public 这个关键字之后的定义是公有的，可以被外部的类访问。比如，大家都知道你的名字，所以你的名字是public的。

private 这个关键字之后的定义是完全私有的，只能被类自己访问。比如，你银行的密码只有你自己知道，所以他是private的。

protected 这个关键字之后的定义，是私有的，但家族成员可以访问。比如，你儿子知道你屁股上有一颗痣，其他人不知道。。。笑，所以这个痣是protected的

override 覆盖父级类的定义

set 在上例代码中，可以通过某actionObject.direction这样来访问这个函数，而不是.direction()，和它类似的还有get关键字。你可以用他们来生成一个只读或只写的“变量”

现在，“亚当的儿子”可以行走了。但是，我们不知道怎样才能通知他走，怎样走。我们必须有一个控制他的方法，让他来听从我们的指挥。因为，我们必须创建一个控制器来控制它。在这之前，我们要学习一些操作这个世界的方法和技巧（上帝也需要学习么，呵呵）

从零开始学AS3游戏开发【二】随机移动的敌人

注：本系列教程每周一篇，旨在引导刚刚接触FLASH的新手通过实例进行游戏开发的学习。在过程中逐步说明涉及到的类及对应的使用方法。从一个光秃秃的方块开始，根据不同的控制方式、玩法产生不同的分支，最终完善成一个个可玩的游戏。希望对各位入门的朋友有所帮助！在教程涉及的各种处理方法，可能不够完善，也希望各位高手指正：）

转载请注名来源于天地会。

第二篇随机移动的敌人

在上一篇教程中，我们搭建了一个简单的程序结构，并编写了程序，通过键盘的控制，让游戏场景中的一个方块根据我们的要求移动。对于一个游戏来讲，只有主角是不够的，我们需要敌人。

敌人和主角拥有相同的属性：他们都有长相（外表，虽然现在只是一个方块。。。），有控制器进行控制。所以，我们可以从ActionObject来进行扩展，产生两个不同的分支来实现他们。我们先来构建整个程序的结构：

可以看出，ActionObject是不具备“长相”这个特征的，而不管是主角或敌人，都有自己不同的样式。在上一篇的教程中，我们把黑色的方框直接指定为了ActionObject类，这样扩展性显然不好。因此，我们单独建立一个具备长相特征的类，继承自ActionObject。具体的操作方法可以参考上一篇教程。注意，因为ActionObject的构造函数是有参数的，所以我们勾选匹配基类的构造函数，让FD自动帮我们生成构造函数。

1.package D5Power.Objects

2.{

3. import flash.display.Sprite;

4. import D5Power.Controller.basicController;

5. /**

6. * 具备外表皮肤的ActionObject

7. * @author D5Power

8. */

9. public class FaceObject extends ActionObject

10. {

11. protected var _face:Sprite;

12. /**

13. *

14. * @param ctrl 控制器

15. * @param face 外观

16. */

17. public function FaceObject(ctrl:basicController,face:Sprite)

18. {

19. super(ctrl);

20. _face = face;

21. addChild(_face);

22. }

23.

24. }

25.

26.}

复制代码

FaceObject在ActionObject的基础上，增加了_face属性，并在构造函数中，通过addChild把_face显示了出来，这样，我们就可以给他赋予不同的外观了。

接下来来实现主角类和敌人类。继承自我们刚刚写好的FaceObject类。暂时直接继承就可以了，不用写其他的代码。

1.package D5Power.Objects

2.{

3. import flash.display.Sprite;

4. import D5Power.Controller.basicController;

5. /**

6. * 主角类

7. * @author D5Power

8. */

9. public class Player extends FaceObject

10. {

11.

12. public function Player(ctrl:basicController, face:Sprite)

13. {

14. super(ctrl, face);

15.

16. }

17.

18. }

19.

20.}

复制代码

1.package D5Power.Objects

2.{

3. import flash.display.Sprite;

4. import D5Power.Controller.basicController;

5. /**

6. * 敌人类

7. * @author D5Power

8. */

9. public class Monster extends FaceObject

10. {

11.

12. public function Monster(ctrl:basicController, face:Sprite)

13. {

14. super(ctrl, face);

15.

16. }

17.

18. }

19.

20.}

复制代码

既然结构改变了，那我们在上一篇教程中使用的黑色方块就没必要再定义为ActionObject了，我们现在只把它作为皮肤使用，在库中右键选择，在弹出菜单中选择属性，把类名改为Skin1。由于我们并没有编写Skin1，FLASH会帮我们自动生成一个Skin1类，以后就可以通过new Skin1()来进行声明了。用同样的办法，我们再重新绘制一个红色的方块，作为敌人的皮肤。定义类名为Skin2

而主场景中，我们原来的代码就需要做一下修改了：

1....

2.var obj:Player = new Player(ctrl,new Skin1());

3....

复制代码

当然，也可以试一下用敌人的皮肤：

1....

2.var obj:Player = new Player(ctrl,new Skin2());

3....

复制代码

这样，大体的结构就已经建好了。接下来。我们来针对问题进行不同的处理。

首先，既然敌人和主角都可以移动。那么，我们就有必要增加限制。因为它们势必只能在允许的范围内移动。就我们目前的需求来看，他们只能在屏幕的区域范围内移动（因为我们暂时没有任何障碍物）。因此，在移动前，我们要检查它的下一个目标点是否可以移动。很显然，这个检查是同时针对敌人和主角的，因此，我们在ActionObject上进行扩展，修改ActionObject的代码，增加nextCanMove方法：

1./**

2. * 下一目标点是否可以移动

3. */

4. public function get nextCanMove():Boolean

5. {

6. // 下一X位置

7. var nx:uint = 0;

8. // 下一Y位置

9. var ny:uint = 0;

10. // 根据移动方向进行处理，计算出下一目标点位置

11. switch(walkDirection)

12. {

13. case UP:

14. ny = y-speed;

15. break;

16. case DOWN:

17. ny = y+speed;

18. break;

19. case LEFT:

20. nx = x-speed;

21. break;

22. case RIGHT:

23. nx = x+speed;

24. break;

25. default:break;

26. }

27.

28. // 如果下一目标点超出屏幕范围，则不能移动

29. if (nx > Global.stage.stageWidth - width || nx < 0) return false;

30. if (ny > Global.stage.stageHeight - height || ny < 0) return false;

31.

32. // 检测通过

33. return true;

34. }

复制代码

同时，修改move方法：

1./**

2. * 移动

3. */

4. protected function move():void

5. {

6. if (!nextCanMove) return; // 增加了这句代码

7. // 根据不同的方向进行移动

8. switch(walkDirection)

9. {

10. case UP:

11. y -= speed;

12. break;

13. case DOWN:

14. y += speed;

15. break;

16. case LEFT:

17. x -= speed;

18. break;

19. case RIGHT:

20. x += speed;

21. break;

22. default:break;

23. }

24. }

复制代码

这样，只有下一目标点可以移动的前提下，才能进行移动。移动限制的问题解决了。

其次。敌人是可以自动移动的，而不是受键盘的控制。那么控制器应该可以自己运行，所以，我们扩展basicController，增加空的AutoRun方法

1./**

2. * 自动运行

3. */

4. public function AutoRun():void{}

复制代码

之后，在需要实现自动运行的控制器里覆盖它来实现具体的功能就可以了。既然我们要敌人随机移动，那实际上也就是随机地给于敌人移动方向。因此我们来修改MonsterController控制器，增加随机修改方向的方法：

1./**

2. * 随机修改方向

3. */

4. private function changeDir():void

5. {

6. var me:ActionObject = _target as ActionObject;

7. me.direction = 1+int(Math.random() * 4);

8. }

复制代码

我们知道，MonsterController的控制对象肯定是ActionObject（Monster是它的子类），因此，我们把_target转换成ActionObject以获得direction属性。Math.random()将随机产生一个0-1的小数（注意，有可能为0，但永远都不会取到1），我们把他乘以4，就获得了0-4的一个随机数（0-3.99999999...）。把他转换为整型，实际上我们随机取得了0-3.而我们的方向是1-4，因此，在这个基础上+1，即可随机获得一个正确的方向值。

接下来，我们覆盖实现AutoRun方法，继续修改MonsterController控制器：

1.override public function AutoRun():void

2. {

3. var me:ActionObject = _target as ActionObject;

4. if (!me.nextCanMove) changeDir();

5. }

复制代码

同样，把_target转换成ActionObject，如果他的下一个移动点无法移动了，则自动转换移动方向，这个方向是随机的。

小提示：你也可以把_target转换成Monster，如果Monster有属于自己的独特函数需要使用的话，不过，一定要确认你传递进来的的确是Monster类哦：）

从零开始学AS3游戏开发【三】向敌人开火!

注：本系列教程每周一篇，旨在引导刚刚接触FLASH的新手通过实例进行游戏开发的学习。在过程中逐步说明涉及到的类及对应的使用方法。从一个光秃秃的方块开始，根据不同的控制方式、玩法产生不同的分支，最终完善成一个个可玩的游戏。希望对各位入门的朋友有所帮助！在教程涉及的各种处理方法，可能不够完善，也希望各位高手指正：）

转载请注名来源于天地会。

前篇勘误：gameScene.as的public function removeObject中，（48行）if (id != -1) return;应为if (id == -1) return;特此更正。请各位谅解。本篇源码已修正本错误。

第三篇向敌人开火！

在上一篇教程中，我们向游戏场景中增加了随机移动的3个敌人（当然，你也可以改成更多），同时，我们的角色也可以在场景中进行移动。但是，并没有产生攻击。在这次的教程中，我们将让自己的角色可以发射子弹，并攻击敌人。

为了实现这个功能，我们必须逐一实现以下内容：

1.构建子弹类

2.修改控制器，让自己可以射击

3.在子弹类中控制子弹的飞行

4.检测子弹是否击中敌人或飞出屏幕

5.新增敌人和自己的HP属性，当被子弹击中后，HP减少

6.敌人死亡

下面，我们来逐一进行实现。

0.一些必要的结构调整。

可以预见的，子弹的飞行方向应该与角色的移动方向相符。但在目前我们的程序中，ActionObject具备方向这个属性，但是它除了控制方向外，还肩负了是否产生运动的判断。（当walkDirection为0的时候，不执行move方法）。这样，当角色处于停止状态（walkDirection为0），我们就不好判断子弹的发射方向了。因此，必须进行一点小的修改。

在ActionObject中，把walkDirection的默认值改为1（向上），增加一个属性_isWalk

1./**

2. * 移动方向

3. */

4. protected var walkDirection:uint = 1;

5.

6. /**

7. * 是否移动

8. */

9. protected var _isWalk:Boolean = false;

10. ...

11. public function set isWalk(val:Boolean):void

12. {

13. _isWalk = val;

14. }

复制代码

修改Do方法为根据_isWalk属性来判断是否移动

1. /**

2. * 覆盖父类的Do方法

3. */

4. override public function Do():void

5. {

6. if (_isWalk != 0) move();

7. super.Do();

8. }

复制代码

最后，修改KeyController的按键侦听函数:

1. /**

2. * 当按键按下时触发

3. * @param e

4. */

5. protected function onKeyDown(e:KeyboardEvent):void

6. {

7. var me:Player = _target as Player; // 将me修改为Player类，方便

后面的射击实现

8. switch(e.keyCode)

9. {

10. case 38:

11. me.direction = ActionObject.UP;

12. me.isWalk = true;// 增加了这一句，将isWalk设置为

true，进入行走状态

13. break;

14. case 40:

15. me.direction = ActionObject.DOWN;

16. me.isWalk = true;// 增加了这一句，将isWalk设置为

true，进入行走状态

17. break;

18. case 37:

19. me.direction = ActionObject.LEFT;

20. me.isWalk = true;// 增加了这一句，将isWalk设置为

true，进入行走状态

21. break;

22. case 39:

23. me.direction = ActionObject.RIGHT;

24. me.isWalk = true;// 增加了这一句，将isWalk设置为

true，进入行走状态

25. break;

26. default:trace(e.keyCode); break;

27. }

28. }

29.

30. /**

31. * 当按键弹起时触发

32. * @param e

33. */

34. protected function onKeyUp(e:KeyboardEvent):void

35. {

36. var me:ActionObject = _target as ActionObject;

37. var active:Array = new Array(37,38,39,40);

38. if (active.indexOf(e.keyCode) != -1)

39. {

40. me.isWalk = false; // 增加了这一句，恢复isWalk为false

41. }

42. }

复制代码

同理，修改MonsterController的changeDir方法：

1. /**

2. * 随机修改方向

3. */

4. private function changeDir():void

5. {

6. var me:ActionObject = _target as ActionObject;

7. me.direction = 1 + int(Math.random() * 4);

8. me.isWalk = true; // 增加了这一句

9. }

复制代码

1.构建子弹类。

首先简单分析一下子弹：它的计算比较简单，可以不需要控制器（当然，如果你喜欢，你可以给它加一个控制器），因此，我们直接从GameObject继承即可。子弹可以自己飞行，并会击中目标。我们需要在Do 方法里增加飞行控制。子弹有外观，我们现在可以暂时用绘图函数来自己绘制。同时，我们不难想到，子弹的飞行是有方向的。而这个方向和角色面对的方向有关。在我们目前的代码中，ActionObject是具备方向属性的。最后，子弹必须可以准确击中敌人，而不是自己。因此，子弹有必要记录发射者是谁，方便识别敌友。

我们逐一来实现功能。首先，当然是构造函数，我们需要在子弹被声明的时候就确认它是由谁发射出来的，因此，子弹首先需要有发射人这个属性，并在构造函数中予以声明。同时，子弹在发出的瞬间，应该获得发射人的方向，之后，不管发射人如何运动，子弹的运动轨迹不受影响。最后，通过绘图函数绘制出子弹：

1. /**

2. * 子弹发射人

3. */

4. protected var _shooter:gameObject;

5. /**

6. * 子弹的飞行方向

7. */

8. protected var _direction:uint;

9.

10. public function BulletObject(shooter:gameObject)

11. {

12. _shooter = shooter;

13. _direction = _shooter.direction;

14. graphics.beginFill(0x000000);// 用黑色开始填充

15. graphics.drawCircle( -1, -1, 1);// 绘制一个半径为1的圆，为了保证

圆心在正中，我们把圆从-1,-1这个坐标开始绘制

16. graphics.endFill();// 结束绘制

17. }

复制代码

graphics是一个Graphics类的实例。是Sprite的一个属性。我们可以通过他来绘制矢量图形。详细的方法可以参阅Graphics类的API文档

子弹的飞行需要速度，因此，子弹必须有速度这个属性，然后，通过发射人的方向来判断子弹的飞行方向，并做出处理：

1. /**

2. * 子弹飞行速度

3. */

4. protected var _speed:Number = 10.2;

5.

6. override public function Do():void

7. {

8. switch(_direction)

9. {

10. case ActionObject.UP:

11. y -= _speed;

12. break;

13. case ActionObject.DOWN:

14. y += _speed;

15. break;

16. case ActionObject.LEFT:

17. x -= _speed;

18. break;

19. case ActionObject.RIGHT:

20. x += _speed;

21. break;

22. default:break;

23. }

24. }

复制代码

最后，子弹击中目标后，应该消失。因为我们通过graphics绘制了图形，所以，一个好的习惯就是在它消失前，把graphics清理掉

1. override public function die():void

2. {

3. graphics.clear();

4. }

复制代码

到这里，子弹类的结构就搭建好了。我们将在后面再根据实际的需求逐步对子弹类进行完善。

2.修改控制器，让自己可以射击

首先，我们要让角色可以射击。我们可以预知，除了自己可以射击以外，敌人也应该可以射击（虽然在本次的教程中，我们暂时只实现了自己的角色进行射击）。所以，“射击”这个动作应该是一个统一的标准。因此，我们通过接口来实现它。

下面，我们来定义射击接口。

新建一个包MyInterface，在文件夹上点右键，选择New Interface选项

属性文件名IShoot.as，使用I作为接口的命名，是一个很好的习惯。以区分它和其他文件。

接口不实现任何方法，也不能包含任何属性。他只不过是一个标准的定制。射击接口的代码如下:

1.package D5Power.MyInterface

2.{

3.

4. /**

5. * 射击接口

6. * @author D5Power