如何实现一个HTML5 RPG游戏引擎——第五章，实现人物和人物特效

上一次，我们实现了对话类，今天就来做一个游戏中不可缺少的——人物类。

当然，你全然是能够自己写一个人物类，可是为了方便起见，还是决定把人物类封装到这个引擎里。

为了使这个类更有意义，我还给人物类加了几个特效，在以下解说中会提到。

以下是本系列文章的文件夹：

怎样制作一款HTML5 RPG游戏引擎——第一篇，地图类的实现

http://blog.csdn.net/yorhomwang/article/details/8892305

怎样制作一款HTML5 RPG游戏引擎——第二篇，烟雨+飞雪效果

http://blog.csdn.net/yorhomwang/article/details/8915020

怎样制作一款HTML5 RPG游戏引擎——第三篇，利用幕布切换场景

http://blog.csdn.net/yorhomwang/article/details/9042571

怎样制作一款HTML5 RPG游戏引擎——第四篇，情景对话

http://blog.csdn.net/yorhomwang/article/details/9076103

该引擎是基于lufylegend开发的，学习时请先了解lufylegend。

官方站点地址：http://lufylegend.com/lufylegend

API地址：http://lufylegend.com/lufylegend/api

一，人物类LCharacter

首先来看LCharacter构造器：

/**
*LCharacter.js
*/
function LCharacter(data,row,col,speed,isFighter){
    var s = this;
    base(s,LSprite,[]);
    s.type = "LCharacter";
    if(!speed)speed = 0;
    if(isFighter == undefined)isFighter = false;
    s.speed = speed;
    s.speedIndex = 0;
    s.x = 0;
    s.y = 0;
    s.mode = "";
    s.index = 0;
    if(isFighter == true){
        s.hp = 0;
        s.attack = 0;
        s.defense = 0;
    }
    s.effect = null;
    s.avatarNum = 0;
    s.flickerNum = 0;
    s.img = data;
    s.row = row;
    s.col = col;
    s.effectSprite = new LSprite();
    s.addChild(s.effectSprite);
    s.nameSprite = new LSprite();
    s.addChild(s.nameSprite);
    var imgData = new LBitmapData(data);
    imgData.setProperties(0,0,imgData.image.width/col,imgData.image.height/row);
    var list = LGlobal.divideCoordinate(imgData.image.width,imgData.image.height,row,col);
    s.imgWidth = imgData.image.width/col;
    s.imgHeight = imgData.image.height/row;
    s.anime = new LAnimation(s,imgData,list);
    s.addEventListener(LEvent.ENTER_FRAME,function(){
        if(s.effect != null){
            s.showEffect(s,s.effect);
        }
    });
}

这个类有5个參数，功能例如以下：

data：人物图片
row：将图片切成多少行，以方便运行动画
col：将图片切成多少列，以方便运行动画
speed：人物动画播放频率相对屏幕刷新频率的倍数
isFighter：是否处于战斗状态

上面的介绍有些含糊，我接着解释一下。首先，data所代表的图片是一个装有每帧动画的图片，比方以下这样的图片：

然后我们的參数row和參数col就是用来表示这个图片能够分成几行，几列。比方上图，row就赋值成4，col也赋值成4，这样恰好能将每帧都切割出来。

speed是用来表示播放动画频率的，假设我们在用init初始化游戏时，传入游戏频率为30毫秒，那假设不给这个參数赋值，播放动画的频率就是30毫秒，可是假设你认为30毫秒播放一帧太快了，想慢一点，便能够用到这个參数。比方说你想让播放频率达到每120毫秒播放一帧，而游戏频率设的是30毫秒，那就能够把这个參数设置为4。假设达到每150毫秒播放一帧，那就能够把这个參数设置为5。但要注意，这个參数赋值必须是正整数。

isFighter这个參数是用来推断是否这个角色是处于战斗状态的。假设是就设为true，不是就设为false，当然你不设定就默认为false。当这个參数为true时，人物类就能够加几个属性，它们用来控制人物的hp，战斗力，防御力等，推断代码例如以下：

if(isFighter == true){
    s.hp = 0;
    s.attack = 0;
    s.defense = 0;
}

为了给这个类更方便地增加特效，我给它自身创建了一个叫effectLayer的LSprite。用于特效的几个属性还例如以下几个：

s.effect = null;
s.avatarNum = 0;
s.flickerNum = 0;

接着我创建了一个LAnimation对象，用它来显示人物动画，代码例如以下：

var imgData = new LBitmapData(data);
imgData.setProperties(0,0,imgData.image.width/col,imgData.image.height/row);
var list = LGlobal.divideCoordinate(imgData.image.width,imgData.image.height,row,col);
s.imgWidth = imgData.image.width/col;
s.imgHeight = imgData.image.height/row;
s.anime = new LAnimation(s,imgData,list);

详细LAnimation用法能够去lufylegend官方API中查看。这里就先不多讲了~

为了使特效使用方便，我设计为直接通过调整effect属性来完成。可是effect在实例化前值是null，所以假设不做处理就调整了属性依旧是不会显示的。所以我添加了一个时间轴事件，让它不断地推断effect属性，以至于达到一改effect属性就能立马显示效果。代码例如以下：

s.addEventListener(LEvent.ENTER_FRAME,function(){
    if(s.effect != null){
        s.showEffect(s,s.effect);
    }
});

关于时间轴，说白了就是一个死循环，仅仅只是是停顿一段时间调用一次，javascript中通常常使用setInerval来实现，详细方法Google一下或百度一下就OK，我不多解释了。

当然，详细怎样显示效果留到以下讲，我们先看其它方法。

因为我们在开发的过程中要用到改动数据的方法，因此我们还得加一个setData方法：

LCharacter.prototype.setData = function(data,row,col,speed,isFighter){
    var s = this;
    if(!speed)speed = 0;
    if(isFighter == undefined)isFighter = false;
    s.speed = speed;
    s.img = data;
    s.row = row;
    s.col = col;
    if(isFighter == true){
        s.hp = 0;
        s.attack = 0;
        s.defense = 0;
    }
    var imgData = new LBitmapData(data);
    imgData.setProperties(0,0,imgData.image.width/col,imgData.image.height/row);
    var list = LGlobal.divideCoordinate(imgData.image.width,imgData.image.height,row,col);
    s.imgWidth = imgData.image.width/col;
    s.imgHeight = imgData.image.height/row;
    s.removeChild(s.anime);
    s.anime = new LAnimation(s,imgData,list);
}

參数和构造器的參数是一样的，方法也几乎相同，大家能够自己看一下。

二，动画操作

上面我们做好了构造器和重设数据方法，并解释了大半天，接下来就要讲讲动画操作了。

动画操作一般有这几种：1，设置动画 2，获取动画信息 3，添加动画监听事件 4，播放动画

还好，这三种方法在lufylegend中都封装得有，我们用起来就非常方便了。增加addActionEventListener方法，以达到给动画添加监听事件：

LCharacter.prototype.addActionEventListener = function(type,listener){
    var s = this;
    s.anime.addEventListener(type,listener);
}

增加setAction方法，以达到设置动画：

LCharacter.prototype.setAction = function(rowIndex,colIndex,mode,isMirror){
    var s = this;
    s.anime.setAction(rowIndex,colIndex,mode,isMirror);
}

增加getAction方法，以达到获取动画信息：

LCharacter.prototype.getAction = function(){
    var s = this;
    var returnAction = s.anime.getAction();
    return returnAction;
}

增加onframe方法，以达到播放动画：

LCharacter.prototype.onframe = function(){
    var s = this;
    if(s.speedIndex++ < s.speed)return;
    s.speedIndex = 0;
    s.anime.onframe();
}

有了这些使用时就方便多了。开发到这里，事实上是已经能够显示人物动画了。仅仅用这样写即可：

var backLayer = new LSprite();
addChild(backLayer);
var chara = new LCharacter(imglist["player"],4,4,3);
backLayer.addChild(chara);
backLayer.addEventListener(LEvent.ENTER_FRAME,onframe);
function onframe(){
    chara.onframe();
}

三，moveTo方法

为了简化操作，我添加moveTo方法来控制人物移动。

moveTo方法的代码：

LCharacter.prototype.moveTo = function(x,y,timer,type,style,completefunc){
    var s = this;
    if(!timer)timer = 1;
    if(!type)type = Quad.easeIn;
    if(!style)style = LMoveStyle.direct;

    switch(style){
        case LMoveStyle.direct:
            var vars = {
                x:x,
                y:y,
                ease:type,
                onComplete:completefunc
            };
            LTweenLite.to(s,timer,vars);
            break;
        case LMoveStyle.horizontal:
            LTweenLite.to(s,timer,{
                x:x,
                ease:type,
                onComplete:function(){
                    LTweenLite.to(s,timer,{
                        y:y,
                        ease:type,
                        onComplete:completefunc
                    });
                }
            });
            break;
        case LMoveStyle.vertical:
            LTweenLite.to(s,timer,{
                y:y,
                ease:type,
                onComplete:function(){
                    LTweenLite.to(s,timer,{
                        x:x,
                        ease:type,
                        onComplete:completefunc
                    });
                }
            });
            break;
        default:
            trace("Error: Value of last param is wrong!");
    }
}

參数分别为：目标x坐标，目标y坐标，移动时间，缓动类型，移动样式，移动完成后调用的函数

目标x坐标，目标y坐标不用解释。关键是后面几个比較重要。首先，因为这个效果我使用lufylegend的缓动类LTweenLite做的，所以timer就代表LTweenLite參数$duration，type就代表LTweenLite中的ease（缓动函数），LTweenLite的用法非常广，能够上官网看看。

我们创建一个JSON对象，叫LMoveStyle，例如以下：

var LMoveStyle = {
    horizontal:"horizontal",
    vertical:"vertical",
    direct:"direct"
};

style这个參数传得值为LMoveStyle中的成员，就是LMoveStyle.horizontal，LMoveStyle.vertical，LMoveStyle.direct。LMoveStyle.horizontal是先横向移动，再竖向移动；LMoveStyle.vertical则是先竖向移动，再横向移动；LMoveStyle.direct则是直接移到该地点。以后也许还会加许多其他效果，这里就先做3个。

使用时这么写就可以了：

charaObj.moveTo(200,100,10,Quad.easeIn,LMoveStyle.direct,function(){});

四，添加角色名称

曾经在lufy博客上看到有人问怎样给人物加一个名称，当时看到了就想到了要加这个方案。事实上实现起来非常easy，代码例如以下：

LCharacter.prototype.addName = function(name,style){
    var s = this;
    s.nameSprite.removeAllChild();
    if(!name)name = 0;
    if(!style)style = [];
    if(!style[0])style[0] = 0;
    if(!style[1])style[1] = 0;
    if(!style[2])style[2] = "black";
    if(!style[3])style[3] = "11";
    if(!style[4])style[4] = "utf-8";
    var nameText = new LTextField();
    nameText.text = name;
    nameText.x = style[0];
    nameText.y = style[1];
    nameText.color = style[2];
    nameText.size = style[3];
    nameText.font = style[4];
    s.nameSprite.addChild(nameText);
}

代码非常easy，要用的时候直接这么写：

charaObj.addName("yorhom",[0,0,"black",10,"黑体"]);

五，人物特效

1，分身术

分身效果一般是出如今游戏的战斗过程中放大招什么的，实现起来也不是非常难，主要也是用到LTweenLite缓动类。

首先我们来看看showEffect方法：

LCharacter.prototype.showEffect = function(s,type){
    switch(type){

    }
}

这个方案是用时间轴驱动的，因此里面的内容是不断调用的。这个參数非常特别，首先是将自身指针传入，然后将效果类型传入。接着在内部推断类型为何，然后依据类型来作出对应的效果。

我们创建一个LSkill对象，它是一个JSON对象，例如以下：

var LSkill = {
    avatar:"LSkillAvatar"
};

avatar音译为阿凡达，分身的意思（据我初步地了解应该是这样）。在这里就代表分身效果。写的时候就仅仅用写：

charaObj.effect = LSkill.avatar;

但详细怎么实现呢，能够看看以下代码：

LCharacter.prototype.showEffect = function(s,type){
    switch(type){
        case LSkill.avatar:
            if(s.avatarNum++ < 3){
                var nowImg = s.anime.getAction();
                var nowY = nowImg[0];
                var nowX = nowImg[1];

                var bitmapData = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
                var bitmap = new LBitmap(bitmapData);
                bitmap.x = 0;
                bitmap.y = 0;
                LTweenLite.to(bitmap,0.5,{
                    x:(s.imgWidth)*s.avatarNum,
                    alpha:0.2,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(bitmap,0.5,{
                            x:(s.imgWidth)*s.avatarNum,
                            ease:Quad.easeIn,
                        });
                    }
                });
                s.effectSprite.addChild(bitmap);

                var bitmapData2 = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
                var bitmap2 = new LBitmap(bitmapData2);
                bitmap2.x = 0;
                bitmap2.y = 0;
                LTweenLite.to(bitmap2,0.5,{
                    x:(s.imgWidth)*s.avatarNum * -1,
                    alpha:0.2,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(bitmap2,0.5,{
                            x:(s.imgWidth)*s.avatarNum * -1,
                            ease:Quad.easeIn,
                            onComplete:function(){
                                s.avatarNum = 0;
                                s.effect = null;
                                s.effectSprite.removeAllChild();
                            }
                        });
                    }
                });
                s.effectSprite.addChild(bitmap2);
            }
            break;
    }
}

代码非常长，只是逻辑非常easy，我们慢慢解释：

首先我们的分身有六个也就是3对，然后我们推断是否达到3对，假设是就不再显示分身。接着我们取出动画的前几帧，作为分身的图片，例如以下：

var nowImg = s.anime.getAction();
var nowY = nowImg[0];
var nowX = nowImg[1];

然后创建左边分身的LBitmap对象，例如以下：

var bitmapData = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
var bitmap = new LBitmap(bitmapData);
bitmap.x = 0;
bitmap.y = 0;

bitmap对象的显示区域大小就是人物动画的显示区域大小，图片就是人物本身那张图片。有了这些，就能够将人物的分身和人物本身做得一模一样了，仅仅只是分身是静态的，人物本身是动态的。

接着我们開始将右边的分身缓动操作：

LTweenLite.to(bitmap,0.5,{
    x:(s.imgWidth)*s.avatarNum,
    alpha:0.2,
    ease:Quad.easeIn,
    onComplete:function(){
        LTweenLite.to(bitmap,0.5,{
            x:(s.imgWidth)*s.avatarNum,
            ease:Quad.easeIn,
        });
    }
});
s.effectSprite.addChild(bitmap);

这个缓动是一个特别的缓动，因为它是缓动套缓动，这样做就能够让分身移动的速度达到 慢->快->慢->快 的效果。并切在移动的过程中改变透明度。

右边的分身效果非常左边得几乎相同，就是改一改方向而已。例如以下：

var bitmapData2 = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
var bitmap2 = new LBitmap(bitmapData2);
bitmap2.x = 0;
bitmap2.y = 0;
LTweenLite.to(bitmap2,0.5,{
    x:(s.imgWidth)*s.avatarNum * -1,
    alpha:0.2,
    ease:Quad.easeIn,
    onComplete:function(){
        LTweenLite.to(bitmap2,0.5,{
            x:(s.imgWidth)*s.avatarNum * -1,
            ease:Quad.easeIn,
            onComplete:function(){
                s.avatarNum = 0;
                s.effect = null;
                s.effectSprite.removeAllChild();
            }
        });
    }
});
s.effectSprite.addChild(bitmap2);

当右边缓动结束后，就会将effect属性设为null，然后移除全部分身。

为了让大家见证一下分身效果，发两张截图：

2，闪烁

闪烁非常easy，直接用缓动调整透明度就可以了。例如以下：

if(s.flickerNum++ < 3){
    LTweenLite.to(s,0.3,{
        alpha:0.5,
        ease:Quad.easeIn,
        onComplete:function(){
            LTweenLite.to(s,0.5,{
                alpha:1,
                ease:Quad.easeIn,
                onComplete:function(){
                    s.effect = null;
                    s.flickerNum = 0;
                }
            });
        }
    });
}

同一时候为LSkill增加一项，完整LSkill代码例如以下：

var LSkill = {
    avatar:"LSkillAvatar",
    flicker:"LSkillFlicker"
};

效果例如以下：

完整showEffect代码例如以下：

LCharacter.prototype.showEffect = function(s,type){
    switch(type){
        case LSkill.avatar:
            if(s.avatarNum++ < 3){
                var nowImg = s.anime.getAction();
                var nowY = nowImg[0];
                var nowX = nowImg[1];

                var bitmapData = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
                var bitmap = new LBitmap(bitmapData);
                bitmap.x = 0;
                bitmap.y = 0;
                LTweenLite.to(bitmap,0.5,{
                    x:(s.imgWidth)*s.avatarNum,
                    alpha:0.2,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(bitmap,0.5,{
                            x:(s.imgWidth)*s.avatarNum,
                            ease:Quad.easeIn,
                        });
                    }
                });
                s.effectSprite.addChild(bitmap);

                var bitmapData2 = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
                var bitmap2 = new LBitmap(bitmapData2);
                bitmap2.x = 0;
                bitmap2.y = 0;
                LTweenLite.to(bitmap2,0.5,{
                    x:(s.imgWidth)*s.avatarNum * -1,
                    alpha:0.2,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(bitmap2,0.5,{
                            x:(s.imgWidth)*s.avatarNum * -1,
                            ease:Quad.easeIn,
                            onComplete:function(){
                                s.avatarNum = 0;
                                s.effect = null;
                                s.effectSprite.removeAllChild();
                            }
                        });
                    }
                });
                s.effectSprite.addChild(bitmap2);
            }
            break;
        case LSkill.flicker:
            if(s.flickerNum++ < 3){
                LTweenLite.to(s,0.3,{
                    alpha:0.5,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(s,0.5,{
                            alpha:1,
                            ease:Quad.easeIn,
                            onComplete:function(){
                                s.effect = null;
                                s.flickerNum = 0;
                            }
                        });
                    }
                });
            }
            break;
        default:
            trace("Error: LSkill has no property that named " + "'" + type + "'");
    }
}

最后把DEMO呈现给大家，方便大家測试

Demo URL：http://www.cnblogs.com/yorhom/articles/3134031.html

六，源码

人物类要实现的功能有非常多，所以，代码也有些多，例如以下：

/**
*LCharacter.js
*/
function LCharacter(data,row,col,speed,isFighter){
    var s = this;
    base(s,LSprite,[]);
    s.type = "LCharacter";
    if(!speed)speed = 0;
    if(isFighter == undefined)isFighter = false;
    s.speed = speed;
    s.speedIndex = 0;
    s.x = 0;
    s.y = 0;
    s.mode = "";
    s.index = 0;
    if(isFighter == true){
        s.hp = 0;
        s.attack = 0;
        s.defense = 0;
    }
    s.effect = null;
    s.avatarNum = 0;
    s.flickerNum = 0;
    s.img = data;
    s.row = row;
    s.col = col;
    s.effectSprite = new LSprite();
    s.addChild(s.effectSprite);
    s.nameSprite = new LSprite();
    s.addChild(s.nameSprite);
    var imgData = new LBitmapData(data);
    imgData.setProperties(0,0,imgData.image.width/col,imgData.image.height/row);
    var list = LGlobal.divideCoordinate(imgData.image.width,imgData.image.height,row,col);
    s.imgWidth = imgData.image.width/col;
    s.imgHeight = imgData.image.height/row;
    s.anime = new LAnimation(s,imgData,list);
    s.addEventListener(LEvent.ENTER_FRAME,function(){
        if(s.effect != null){
            s.showEffect(s,s.effect);
        }
    });
}
LCharacter.prototype.setData = function(data,row,col,speed,isFighter){
    var s = this;
    if(!speed)speed = 0;
    if(isFighter == undefined)isFighter = false;
    s.speed = speed;
    s.img = data;
    s.row = row;
    s.col = col;
    if(isFighter == true){
        s.hp = 0;
        s.attack = 0;
        s.defense = 0;
    }
    var imgData = new LBitmapData(data);
    imgData.setProperties(0,0,imgData.image.width/col,imgData.image.height/row);
    var list = LGlobal.divideCoordinate(imgData.image.width,imgData.image.height,row,col);
    s.imgWidth = imgData.image.width/col;
    s.imgHeight = imgData.image.height/row;
    s.removeChild(s.anime);
    s.anime = new LAnimation(s,imgData,list);
}
LCharacter.prototype.addActionEventListener = function(type,listener){
    var s = this;
    s.anime.addEventListener(type,listener);
}
LCharacter.prototype.setAction = function(rowIndex,colIndex,mode,isMirror){
    var s = this;
    s.anime.setAction(rowIndex,colIndex,mode,isMirror);
}
LCharacter.prototype.getAction = function(){
    var s = this;
    var returnAction = s.anime.getAction();
    return returnAction;
}
LCharacter.prototype.onframe = function(){
    var s = this;
    if(s.speedIndex++ < s.speed)return;
    s.speedIndex = 0;
    s.anime.onframe();
}
LCharacter.prototype.moveTo = function(x,y,timer,type,style,completefunc){
    var s = this;
    if(!timer)timer = 1;
    if(!type)type = Quad.easeIn;
    if(!style)style = LMoveStyle.direct;

    switch(style){
        case LMoveStyle.direct:
            var vars = {
                x:x,
                y:y,
                ease:type,
                onComplete:completefunc
            };
            LTweenLite.to(s,timer,vars);
            break;
        case LMoveStyle.horizontal:
            LTweenLite.to(s,timer,{
                x:x,
                ease:type,
                onComplete:function(){
                    LTweenLite.to(s,timer,{
                        y:y,
                        ease:type,
                        onComplete:completefunc
                    });
                }
            });
            break;
        case LMoveStyle.vertical:
            LTweenLite.to(s,timer,{
                y:y,
                ease:type,
                onComplete:function(){
                    LTweenLite.to(s,timer,{
                        x:x,
                        ease:type,
                        onComplete:completefunc
                    });
                }
            });
            break;
        default:
            trace("Error: Value of last param is wrong!");
    }
}
LCharacter.prototype.addName = function(name,style){
    var s = this;
    s.nameSprite.removeAllChild();
    if(!name)name = 0;
    if(!style)style = [];
    if(!style[0])style[0] = 0;
    if(!style[1])style[1] = 0;
    if(!style[2])style[2] = "black";
    if(!style[3])style[3] = "11";
    if(!style[4])style[4] = "utf-8";
    var nameText = new LTextField();
    nameText.text = name;
    nameText.x = style[0];
    nameText.y = style[1];
    nameText.color = style[2];
    nameText.size = style[3];
    nameText.font = style[4];
    s.nameSprite.addChild(nameText);
}
LCharacter.prototype.showEffect = function(s,type){
    switch(type){
        case LSkill.avatar:
            if(s.avatarNum++ < 3){
                var nowImg = s.anime.getAction();
                var nowY = nowImg[0];
                var nowX = nowImg[1];

                var bitmapData = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
                var bitmap = new LBitmap(bitmapData);
                bitmap.x = 0;
                bitmap.y = 0;
                LTweenLite.to(bitmap,0.5,{
                    x:(s.imgWidth)*s.avatarNum,
                    alpha:0.2,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(bitmap,0.5,{
                            x:(s.imgWidth)*s.avatarNum,
                            ease:Quad.easeIn,
                        });
                    }
                });
                s.effectSprite.addChild(bitmap);

                var bitmapData2 = new LBitmapData(s.img,nowX*s.imgWidth,nowY*s.imgHeight,s.imgWidth,s.imgHeight);
                var bitmap2 = new LBitmap(bitmapData2);
                bitmap2.x = 0;
                bitmap2.y = 0;
                LTweenLite.to(bitmap2,0.5,{
                    x:(s.imgWidth)*s.avatarNum * -1,
                    alpha:0.2,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(bitmap2,0.5,{
                            x:(s.imgWidth)*s.avatarNum * -1,
                            ease:Quad.easeIn,
                            onComplete:function(){
                                s.avatarNum = 0;
                                s.effect = null;
                                s.effectSprite.removeAllChild();
                            }
                        });
                    }
                });
                s.effectSprite.addChild(bitmap2);
            }
            break;
        case LSkill.flicker:
            if(s.flickerNum++ < 3){
                LTweenLite.to(s,0.3,{
                    alpha:0.5,
                    ease:Quad.easeIn,
                    onComplete:function(){
                        LTweenLite.to(s,0.5,{
                            alpha:1,
                            ease:Quad.easeIn,
                            onComplete:function(){
                                s.effect = null;
                                s.flickerNum = 0;
                            }
                        });
                    }
                });
            }
            break;
        default:
            trace("Error: LSkill has no property that named " + "'" + type + "'");
    }
}
var LMoveStyle = {
    horizontal:"horizontal",
    vertical:"vertical",
    direct:"direct"
};
var LSkill = {
    avatar:"LSkillAvatar",
    flicker:"LSkillFlicker"
};

几乎相同引擎中的功能就这么多了，再看看有沒有什么漏掉了。假设沒有就能够公布了，敬请期待。

谢谢大家阅读本文，支持就是最大的鼓舞。

----------------------------------------------------------------

欢迎大家转载我的文章。

转载请注明：转自Yorhom's Game Box

http://blog.csdn.net/yorhomwang