D5PowerAS入门教程一.docx
《D5PowerAS入门教程一.docx》由会员分享,可在线阅读,更多相关《D5PowerAS入门教程一.docx(19页珍藏版)》请在冰豆网上搜索。
![D5PowerAS入门教程一.docx](https://file1.bdocx.com/fileroot1/2023-4/20/a0ac8fb7-43ab-4c1a-96ff-5116099729c7/a0ac8fb7-43ab-4c1a-96ff-5116099729c71.gif)
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