D5PowerAS入门教程一.docx
《D5PowerAS入门教程一.docx》由会员分享，可在线阅读，更多相关《D5PowerAS入门教程一.docx（19页珍藏版）》请在冰豆网上搜索。
D5PowerAS入门教程一
D5POWER个人网站
官方网站
注：
本系列教程每周一篇，旨在引导刚刚接触FLASH的新手通过实例进行游戏开发的学习。
在过程中逐步说明涉及到的类及对应的使用方法。
从一个光秃秃的方块开始，根据不同的控制方式、玩法产生不同的分支，最终完善成一个个可玩的游戏。
希望对各位入门的朋友有所帮助！
在教程涉及的各种处理方法，可能不够完善，也希望各位高手指正：
）转载请注名来源于天地会。
第一篇响应键盘事件的方块
准备工作：
FLASHCS3/4/5,FlashDevelop
开发目标：
实现一个受键盘控制的方块
相关API：
Sprite,KeyboradEvent
我们即将开始构建一个游戏世界……
任何属于这个世界的物体，我们都叫它游戏对象（gameObject）。
它是游戏的基本元素，所有的一切都是从它衍生而来。
有的游戏对象可以被我们操作，因此，我们需要分配给它一个控制器（controller），并通过这个装置来控制它。
我们一次不可能看遍全部世界，所以，我们必须有一个舞台（gameScene），让我们想看到的游戏对象来到这个舞台上表演。
所有的一切。
都通过这个舞台开始……
首先，做一下准备工作：
首先打开FlashDevelop，新建一个项目。
选择FLASHIDE项目，选择一个保存目录，并选择一个你喜欢的名字。
在项目名上点右键，选择Add->NewClass，输入文件名Main，选择baseClass后面的Browse按钮，输入Sprite
这样，我们就建立了一个继承自Sprite类的对象Main。
Sprite是FLASH的一个基本显示元素，它没有时间轴的概念。
打开FLASHCS3，新建一个ActionScript3.0文件，并把它保存到刚才建立的项目的目录中。
在属性栏里，把帧频改成30，文档类输入Main。
这样，我们就建立了一个可以由Main.as控制的FLASH文件。
把刚才生成的Main.as改成像下面这样：
1.package
2.{
3.importflash.display.Sprite;
4.
5.publicclassMainextendsSprite
6.{
7.
8.publicfunctionMain（）
9.{
10.trace（'我运行咯！
'）;
11.}
12.
13.}
14.
15.}
回到FLASHCS里，按下ctrl+enter进行测试：
2010-9-3010:
58
看到输出框里出现的输出，说明程序已经可以运行了。
trace是FLASH中的消息输出命令，我们在今后的开发过程中会经常使用的。
至此，准备工作完成。
开始我们的创建之旅吧。
首先来建立游戏时间里的“亚当”——gameObject。
在我们的项目里新建文件夹D5Power（起个自己喜欢的名字），并在D5Power下面再建一个文件夹Objects，最后，在Ojbects里Add一个NewClass，输入文件名gameObject，同样，baseclass选择Sprite。
建立完成后，我们的项目看起来应该像这样了：
在FlashDevelop给我们生成的代码中，我们看到了packageD5Power.Objects这样的字眼。
package即是包，我们的源代码可以存放在不同的包中，这样可以保持代码的结构清晰。
包的名字实际上就是对应目录的名字。
如packageD5Power.Objects这样，我们就可以知道gameObject文件是保存在D5Power/Objects/这个目录下面，如果package后面没有任何内容（比如我们刚才建立的Main），那么这个文件就是在项目的默认包（源代码的顶级目录）中。
不同层级的包之间的访问，必须通过improt进行包含，而同级，以及访问默认包内的文件，是不需要的。
这个我们以后会再继续详细的说明
回来考虑一下我们的“亚当”——gameObject，它是最基础的元素，所以，我们只给他定义最简单的可以做的事情，首先，他可以做一些事（至于做什么，我们先不考虑），另外，他会死亡。
既然他可以产生在这个游戏世界里，那么他就必须可以从这个世界里消失的无影无踪：
1.packageD5Power.Objects
2.{
3.importflash.display.Sprite;
4.
5./**
6.*基础游戏对象
7.*@authorD5Power
8.*/
9.publicclassgameObjectextendsSprite
10.{
11.
12.publicfunctiongameObject（）
13.{
14.
15.}
16./**
17.*做些什么
18.*/
19.publicfunctionDo（）:
void{}
20./**
21.*死亡
22.*/
23.publicfunctiondie（）:
void{}
24.
25.}
26.
27.}
我们定义了一个空的die函数，它什么也没做，我们将在以后慢慢的去补足它。
现在，gameObject除了活着，就是死了。
这显然不能满足我们的要求。
所以我们必须让他繁衍下一代，并产生进化。
在Objects里再新建一个类，命名为actionObject，把它的baseclass输入gameObject。
现在，我们获得了一个“亚当的儿子”。
他继承了亚当的全部特性（可以死亡），并可以有自己独特的事情可以做。
我们决定教他如何行走：
1.packageD5Power.Objects
2.{
3./**
4.*可活动的游戏对象
5.*@authorD5Power
6.*/
7.publicclassActionObjectextendsgameObject
8.{
9./**
10.*移动速度
11.*/
12.protectedvarspeed:
Number=1.2;
13./**
14.*移动方向
15.*/
16.protectedvarwalkDirection:
uint=0
17.
18.publicstaticconstUP:
uint=1;
19.publicstaticconstDOWN:
uint=2;
20.publicstaticconstLEFT:
uint=3;
21.publicstaticconstRIGHT:
uint=4;
22.
23.publicfunctionActionObject（）
24.{
25.
26.}
27./**
28.*修改移动方向
29.*/
30.publicfunctionsetdirection（dir:
uint）:
void
31.{
32.walkDirection=dir;
33.}
34./**
35.*移动
36.*/
37.protectedfunctionmove（）:
void
38.{
39.//根据不同的方向进行移动
40.switch（walkDirection）
41.{
42.caseUP:
43.y-=speed;
44.break;
45.caseDOWN:
46.y+=speed;
47.break;
48.caseLEFT:
49.x-=speed;
50.break;
51.caseRIGHT:
52.x+=speed;
53.break;
54.default:
break;
55.}
56.}
57.
58./**
59.*覆盖父类的Do方法
60.*/
61.overridepublicfunctionDo（）:
void
62.{
63.if（walkDirection!
=0）move（）;
64.super.Do（）;
65.}
66.}
67.}
在这段代码中，我们第一次接触到了一些关键字，下面对他们进行说明
varFLASH中定义变量用的前缀，比如varnum:
int=5;定义一个整型变量num，默认值为5
functionFLASH中定义函数的前缀，比如functiontest（）:
void{}定义一个名为test的函数，没有返回值
public这个关键字之后的定义是公有的，可以被外部的类访问。
比如，大家都知道你的名字，所以你的名字是public的。
private这个关键字之后的定义是完全私有的，只能被类自己访问。
比如，你银行的密码只有你自己知道，所以他是private的。
protected这个关键字之后的定义，是私有的，但家族成员可以访问。
比如，你儿子知道你屁股上有一颗痣，其他人不知道。
。
。
笑，所以这个痣是protected的
override覆盖父级类的定义
set在上例代码中，可以通过某actionObject.direction这样来访问这个函数，而不是.direction（），和它类似的还有get关键字。
你可以用他们来生成一个只读或只写的“变量”
现在，“亚当的儿子”可以行走了。
但是，我们不知道怎样才能通知他走，怎样走。
我们必须有一个控制他的方法，让他来听从我们的指挥。
因为，我们必须创建一个控制器来控制它。
在这之前，我们要学习一些操作这个世界的方法和技巧（上帝也需要学习么，呵呵）
首先，我们必须能在任何的地方都可以访问到主场景的FLASH舞台（Stage，你可以把他理解成我们在FLASHCS里可以看到的那个白白的工作区，呵呵）.这样方便我们的操作。
刚才我们说过，不管任何一个包，都可以访问到默认包里的东西。
因此，我们在默认包里建立一个全局都可以访问的类Global,并用它来存放一些需要全局调用的东西：
1.package
2.{
3.importflash.display.Stage;
4./**
5.*全局通用类
6.*@authorD5Power
7.*/
8.publicclassGlobal
9.{
10./**
11.*直接调用FLASH舞台
12.*/
13.publicstaticvarstage:
Stage;
14.publicfunctionGlobal（）
15.{
16.}
17.}
18.}
之后，我们来创建控制器。
在D5Power/下面新建一个目录Controller，用来存放控制器。
和gameObject的结构一样，我们也建立一个最基础的控制器（basicController），其他控制器由它来衍生：
1.packageD5Power.Controller
2.{
3./**
4.*基础控制器
5.*@authorD5Power
6.*/
7.publicclassbasicController
8.{
9./**
10.*控制对象
11.*/
12.protectedvar_target:
gameObject;
13.
14.publicfunctionbasicController（）
15.{
16.
17.}
18./**
19.*设置控制对象
20.*/
21.publicfunctionsettarget（obj:
gameObject）:
void
22.{
23._target=obj;
24.}
25./**
26.*消亡
27.*/
28.publicfunctiondie（）:
void{}
29.}
30.
31.}
之后，再来创建专门针对键盘控制的控制器KeyController，当然，继承自basicController：
1.packageD5Power.Controller
2.{
3.importD5Power.Objects.ActionObject;
4.importD5Power.Objects.gameObject;
5.importflash.events.KeyboardEvent;
6./**
7.*键盘控制器
8.*@authorD5Power
9.*/
10.publicclassKeyControllerextendsbasicController
11.{
12.
13.
14.publicfunctionKeyController（）
15.{
16.super（）;
17.setupListener（）;
18.}
19./**
20.*安装侦听器
21.*/
22.publicfunctionsetupListener（）:
void
23.{
24.Global.stage.addEventListener（KeyboardEvent.KEY_DOWN,onKeyDown）;
25.Global.stage.addEventListener（KeyboardEvent.KEY_UP,onKeyUp）;
26.}
27./**
28.*消亡
29.*/
30.overridepublicfunctiondie（）:
void
31.{
32.Global.stage.removeEventListener（KeyboardEvent.KEY_DOWN,onKeyDown）;
33.Global.stage.removeEventListener（KeyboardEvent.KEY_UP,onKeyUp）;
34.}
35./**
36.*当按键按下时触发
37.*@parame
38.*/
39.protectedfunctiononKeyDown（e:
KeyboardEvent）:
void
40.{
41.varme:
ActionObject=_targetasActionObject;
42.switch（e.keyCode）
43.{
44.case38:
45.me.direction=ActionObject.UP;
46.break;
47.case40:
48.me.direction=ActionObject.DOWN;
49.break;
50.case37:
51.me.direction=ActionObject.LEFT;
52.break;
53.case39:
54.me.direction=ActionObject.RIGHT;
55.break;
56.default:
break;
57.}
58.}
59.
60./**
61.*当按键弹起时触发
62.*@parame
63.*/
64.protectedfunctiononKeyUp（e:
KeyboardEvent）:
void
65.{
66.varme:
ActionObject=_targetasActionObject;
67.varactive:
Array=newArray（37,38,39,40）;
68.if（active.indexOf（e.keyCode）!
=-1）me.direction=0;
69.}
70.
71.}
72.}
这里我们基础到了新的内容.Global.stage.addEventListener，即向舞台（你可以理解为CS中那个白色的工作区，所有动画的根容器）增加侦听器。
就是当触发某些事件的时候，会发生通知，我们这里侦听了KeyBoradEvent键盘事件。
可以从代码中看到，我们分别增加了2条侦听器，一个是KeyboradEvent.KEY_DOWN，另外一个是KeyboradEvent.KEY_UP。
他们的作用分别是，在按键按下的时候（KEY_DOWN）通知或者叫做触发onKeyDown函数，而当按键弹起的时候，触发onKeyUp函数。
而在随后，我们使用override覆盖了父级（basicController）的die函数，编写了移除侦听器的动作。
一定要记得，增加过什么，就一定要删除掉什么，不然你的游戏占用的内存会越来越大的！
再来看一下键盘事件触发的两个函数。
因为我们知道，这个按键控制器所控制的必然是ActionObject，因此，我们可以把控制器的控制目标转换成ActionObject，使用as来进行。
之后，就可以更方便的控制目标了。
可以看到，我们分别在onKeyDown函数里修改了ActionObject的行走方向，而在onKeyUp函数中恢复行走方向为0.结合前面的代码，当ActionObject的行走方向不为0的时候，它将根据不同的方向做出判断，并移动向不同的方向。
这里的e.KeyCode是键盘事件发送过来的，值即是按下的按键的ASCII码，我们通过它来确定键盘上被按下的是哪几个键，37-40分别是键盘上下左右四个方向键的键值。
在onKeyUp中，我们利用数组做了一次判断。
如果按下的按键键值在这四个数字组成的数组中，则恢复控制目标的移动方向为0
有了控制器，我们必须有方法把控制器安装到ActionObject中，于是，我们对代码做了如下的修改：
1....
2./**
3.*控制器
4.*/
5.protectedvarcontroller:
basicController;
6.
7./**
8.*在建立对象的时候，需要传递控制器进来
9.*@paramctrl
10.*/
11.publicfunctionActionObject（ctrl:
basicController）
12.{
13.controller=ctrl;
14.controller.target=this;//将控制器的控制目标设置为自己
15.
16.}
17....
18.overridepublicfunctiondie（）:
void
19.{
20.controller.die（）;//当自己被删除的时候，通知控制器卸载侦听，以释放内存
21.}
22....
复制代码
到这里，控制器部分已经实现了。
最后，我们通过游戏舞台把他们组装在一起。
在D5Power下新建Scene目录，并建立一个继承自Sprite类的对象gameScene，来作为游戏场景的基类（如果你喜欢听“亚当”的话，他们是一个意思）。
代码如下：
1.packageD5Power.Scene
2.{
3.importD5Power.Objects.gameObject;
4.importflash.display.Sprite;
5.importflash.display.Stage;
6.importflash.events.Event;
7.
8./**
9.*基本游戏场景
10.*@authorD5.Howard
11.*/
12.publicclassgameSceneextendsSprite
13.{
14./**
15.*舞台中的对象列表
16.*/
17.protectedvarobjectList:
Array;
18./**
19.*创建游戏基本场景需要传递基本舞台这个参数
20.*@param_stage舞台
21.*/
22.publicfunctiongameScene（_stage:
Stage）
23.{
24.Global.stage=_stage;
25.objectList=newArray（）;
26.Global.stage.addEventListener（Event.ENTER_FRAME,render）;
27.}
28.
29./**
30.*向游戏世界中增加新的游戏对象
31.*@paramobj
32.*/
33.publicfunctionaddObject（obj:
gameObject）:
void
34.{
35.if（objectList.indexOf（obj）!
=-1）return;//不重复添加
36.objectList.push（obj）;
37.addChild（obj）;
38.}
39.
40./**
41.*从游戏世界中删除游戏对象
42.*@paramobj
43.*/
44.publicfunctionremoveObject（obj:
gameObject）:
void
45.{
46.varid:
int=objectList.indexOf（obj）;
47.if（id==-1）return;
48.objectList.splice（id,1）;
49.removeChild（obj）;
50.obj.die（）;
51.}
52.
53./**
54.*渲染函数，通过本函数逐个计算游戏中各对象的动作
55.*/
56.publicfunctionrender（e:
Event）:
void
57.{
58.foreach（varobj:
gameObjectinobjectList）obj.Do（）;
59.}
60.
61.}
62.
63.}
游戏舞台就已经构建完成了。
我们通过objectList保存目前游戏中的全部游戏对象。
并对舞台增加了Event.ENTER_FRAME侦听。
这个侦听将在舞台开始播放后，持续不断的运行，来达到动画效果。
我们把这个侦听的响应函数设置为render函数，并在这里函数里，循环了场景中全部的游戏对象，并告诉他们，“要做什么"
最后的工作：
画一个方块，并选中它，按F8键将他转换成一个组件
我们在这里声明了，这个方框将是一个ActionO
升级会员 