transition.lua主要是动作相关的操作。

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

-- @module transition

--[[--

为图像创造效果

]]

local transition = {}

local ACTION_EASING = {}

ACTION_EASING["BACKIN"]           = {cc.EaseBackIn, }

ACTION_EASING["BACKINOUT"]        = {cc.EaseBackInOut, }

ACTION_EASING["BACKOUT"]          = {cc.EaseBackOut, }

ACTION_EASING["BOUNCE"]           = {cc.EaseBounce, }

ACTION_EASING["BOUNCEIN"]         = {cc.EaseBounceIn, }

ACTION_EASING["BOUNCEINOUT"]      = {cc.EaseBounceInOut, }

ACTION_EASING["BOUNCEOUT"]        = {cc.EaseBounceOut, }

ACTION_EASING["ELASTIC"]          = {cc.EaseElastic, , 0.3}

ACTION_EASING["ELASTICIN"]        = {cc.EaseElasticIn, , 0.3}

ACTION_EASING["ELASTICINOUT"]     = {cc.EaseElasticInOut, , 0.3}

ACTION_EASING["ELASTICOUT"]       = {cc.EaseElasticOut, , 0.3}

ACTION_EASING["EXPONENTIALIN"]    = {cc.EaseExponentialIn, }

ACTION_EASING["EXPONENTIALINOUT"] = {cc.EaseExponentialInOut, }

ACTION_EASING["EXPONENTIALOUT"]   = {cc.EaseExponentialOut, }

ACTION_EASING["IN"]               = {cc.EaseIn, , }

ACTION_EASING["INOUT"]            = {cc.EaseInOut, , }

ACTION_EASING["OUT"]              = {cc.EaseOut, , }

ACTION_EASING["RATEACTION"]       = {cc.EaseRateAction, , }

ACTION_EASING["SINEIN"]           = {cc.EaseSineIn, }

ACTION_EASING["SINEINOUT"]        = {cc.EaseSineInOut, }

ACTION_EASING["SINEOUT"]          = {cc.EaseSineOut, }

local actionManager = cc.Director:getInstance():getActionManager()

-- start --

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

-- 创建一个缓动效果

-- @function [parent=#transition] newEasing

-- @param Action action     动作对象

-- @param string easingName 缓冲效果的名字, 具体参考 transition.execute() 方法

-- @param mixed  more       创建缓冲效果的参数

-- @return mixed#mixed ret (return value: mixed)  结果

-- end --

function transition.newEasing(action, easingName, more)

    local key = string.upper(tostring(easingName))

    if string.sub(key, , ) == "CCEASE" then

        key = string.sub(key, )

    end

    local easing

    if ACTION_EASING[key] then

        local cls, count, default = unpack(ACTION_EASING[key])

        if count ==  then

            easing = cls:create(action, more or default)

        else

            easing = cls:create(action)

        end

    end

    return easing or action

end

-- start --

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

-- 创建一个动作效果

-- @function [parent=#transition] create

-- @param Action action 动作对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

-- end --

function transition.create(action, args)

    args = checktable(args)

    if args.easing then

        if type(args.easing) == "table" then

            action = transition.newEasing(action, unpack(args.easing))

        else

            action = transition.newEasing(action, args.easing)

        end

    end

    local actions = {}

    local delay = checknumber(args.delay)

    if delay >  then

        actions[#actions + ] = cc.DelayTime:create(delay)

    end

    actions[#actions + ] = action

    local onComplete = args.onComplete

    if type(onComplete) ~= "function" then onComplete = nil end

    if onComplete then

        actions[#actions + ] = cc.CallFunc:create(onComplete)

    end

    if #actions >  then

        return transition.sequence(actions)

    else

        return actions[]

    end

end

-- start --

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

-- 执行一个动作效果

-- @function [parent=#transition] execute

-- @param cc.Node target 显示对象

-- @param Action action 动作对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

执行一个动作效果

~~~ lua

-- 等待 1.0 后开始移动对象

-- 耗时 1.5 秒，将对象移动到屏幕中央

-- 移动使用 backout 缓动效果

-- 移动结束后执行函数，显示 move completed

transition.execute(sprite, MoveTo:create(1.5, cc.p(display.cx, display.cy)), {

    delay = 1.0,

    easing = "backout",

    onComplete = function()

        print("move completed")

    end,

})

~~~

transition.execute() 是一个强大的工具，可以为原本单一的动作添加各种附加特性。

transition.execute() 的参数表格支持下列参数：

-    delay: 等待多长时间后开始执行动作

-    easing: 缓动效果的名字及可选的附加参数，效果名字不区分大小写

-    onComplete: 动作执行完成后要调用的函数

-    time: 执行动作需要的时间

transition.execute() 支持的缓动效果：

-    backIn

-    backInOut

-    backOut

-    bounce

-    bounceIn

-    bounceInOut

-    bounceOut

-    elastic, 附加参数默认为 0.3

-    elasticIn, 附加参数默认为 0.3

-    elasticInOut, 附加参数默认为 0.3

-    elasticOut, 附加参数默认为 0.3

-    exponentialIn, 附加参数默认为 1.0

-    exponentialInOut, 附加参数默认为 1.0

-    exponentialOut, 附加参数默认为 1.0

-    In, 附加参数默认为 1.0

-    InOut, 附加参数默认为 1.0

-    Out, 附加参数默认为 1.0

-    rateaction, 附加参数默认为 1.0

-    sineIn

-    sineInOut

-    sineOut

]]

-- end --

function transition.execute(target, action, args)

    assert(not tolua.isnull(target), "transition.execute() - target is not cc.Node")

    local action = transition.create(action, args)

    target:runAction(action)

    return action

end

-- start --

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

-- 将显示对象旋转到指定角度，并返回 Action 动作对象。

-- @function [parent=#transition] rotateTo

-- @param cc.Node target 显示对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

将显示对象旋转到指定角度，并返回 Action 动作对象。

~~~ lua

-- 耗时 0.5 秒将 sprite 旋转到 180 度

transition.rotateTo(sprite, {rotate = 180, time = 0.5})

~~~

]]

-- end --

function transition.rotateTo(target, args)

    assert(not tolua.isnull(target), "transition.rotateTo() - target is not cc.Node")

    -- local rotation = args.rotate

    local action = cc.RotateTo:create(args.time, args.rotate)

    return transition.execute(target, action, args)

end

-- start --

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

-- 将显示对象移动到指定位置，并返回 Action 动作对象。

-- @function [parent=#transition] moveTo

-- @param cc.Node target 显示对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

将显示对象移动到指定位置，并返回 Action 动作对象。

~~~ lua

-- 移动到屏幕中心

transition.moveTo(sprite, {x = display.cx, y = display.cy, time = 1.5})

-- 移动到屏幕左边，不改变 y

transition.moveTo(sprite, {x = display.left, time = 1.5})

-- 移动到屏幕底部，不改变 x

transition.moveTo(sprite, {y = display.bottom, time = 1.5})

~~~

]]

-- end --

function transition.moveTo(target, args)

    assert(not tolua.isnull(target), "transition.moveTo() - target is not cc.Node")

    local tx, ty = target:getPosition()

    local x = args.x or tx

    local y = args.y or ty

    local action = cc.MoveTo:create(args.time, cc.p(x, y))

    return transition.execute(target, action, args)

end

-- start --

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

-- 将显示对象移动一定距离，并返回 Action 动作对象。

-- @function [parent=#transition] moveBy

-- @param cc.Node target 显示对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

将显示对象移动一定距离，并返回 Action 动作对象。

~~~ lua

-- 向右移动 100 点，向上移动 100 点

transition.moveBy(sprite, {x = 100, y = 100, time = 1.5})

-- 向左移动 100 点，不改变 y

transition.moveBy(sprite, {x = -100, time = 1.5})

-- 向下移动 100 点，不改变 x

transition.moveBy(sprite, {y = -100, time = 1.5})

~~~

]]

-- end --

function transition.moveBy(target, args)

    assert(not tolua.isnull(target), "transition.moveBy() - target is not cc.Node")

    local x = args.x or

    local y = args.y or

    local action = cc.MoveBy:create(args.time, cc.p(x, y))

    return transition.execute(target, action, args)

end

-- start --

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

-- 淡入显示对象，并返回 Action 动作对象。

-- @function [parent=#transition] fadeIn

-- @param cc.Node target 显示对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

淡入显示对象，并返回 Action 动作对象。

fadeIn 操作会首先将对象的透明度设置为 0（0%，完全透明），然后再逐步增加为 255（100%，完全不透明）。

如果不希望改变对象当前的透明度，应该用 fadeTo()。

~~~ lua

action = transition.fadeIn(sprite, {time = 1.5})

~~~

]]

-- end --

function transition.fadeIn(target, args)

    assert(not tolua.isnull(target), "transition.fadeIn() - target is not cc.Node")

    local action = cc.FadeIn:create(args.time)

    return transition.execute(target, action, args)

end

-- start --

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

-- 淡出显示对象，并返回 Action 动作对象。

-- @function [parent=#transition] fadeOut

-- @param cc.Node target 显示对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

淡出显示对象，并返回 Action 动作对象。

fadeOut 操作会首先将对象的透明度设置为 255（100%，完全不透明），然后再逐步减少为 0（0%，完全透明）。

如果不希望改变对象当前的透明度，应该用 fadeTo()。

~~~ lua

action = transition.fadeOut(sprite, {time = 1.5})

~~~

]]

-- end --

function transition.fadeOut(target, args)

    assert(not tolua.isnull(target), "transition.fadeOut() - target is not cc.Node")

    local action = cc.FadeOut:create(args.time)

    return transition.execute(target, action, args)

end

-- start --

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

-- 将显示对象的透明度改变为指定值，并返回 Action 动作对象。

-- @function [parent=#transition] fadeTo

-- @param cc.Node target 显示对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

将显示对象的透明度改变为指定值，并返回 Action 动作对象。

~~~ lua

-- 不管显示对象当前的透明度是多少，最终设置为 128

transition.fadeTo(sprite, {opacity = 128, time = 1.5})

~~~

]]

-- end --

function transition.fadeTo(target, args)

    assert(not tolua.isnull(target), "transition.fadeTo() - target is not cc.Node")

    local opacity = checkint(args.opacity)

    if opacity <  then

        opacity =

    elseif opacity >  then

        opacity =

    end

    local action = cc.FadeTo:create(args.time, opacity)

    return transition.execute(target, action, args)

end

-- start --

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

-- 将显示对象缩放到指定比例，并返回 Action 动作对象。

-- @function [parent=#transition] scaleTo

-- @param cc.Node target 显示对象

-- @param table args 参数表格对象

-- @return mixed#mixed ret (return value: mixed)  结果

--[[--

将显示对象缩放到指定比例，并返回 Action 动作对象。

~~~ lua

-- 整体缩放为 50%

transition.scaleTo(sprite, {scale = 0.5, time = 1.5})

-- 单独水平缩放

transition.scaleTo(sprite, {scaleX = 0.5, time = 1.5})

-- 单独垂直缩放

transition.scaleTo(sprite, {scaleY = 0.5, time = 1.5})

~~~

]]

-- end --

function transition.scaleTo(target, args)

    assert(not tolua.isnull(target), "transition.scaleTo() - target is not cc.Node")

    local action

    if args.scale then

        action = cc.ScaleTo:create(checknumber(args.time), checknumber(args.scale))

    elseif args.scaleX or args.scaleY then

        local scaleX, scaleY

        if args.scaleX then

            scaleX = checknumber(args.scaleX)

        else

            scaleX = target:getScaleX()

        end

        if args.scaleY then

            scaleY = checknumber(args.scaleY)

        else

            scaleY = target:getScaleY()

        end

        action = cc.ScaleTo:create(checknumber(args.time), scaleX, scaleY)

    end

    return transition.execute(target, action, args)

end

-- start --

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

-- 创建一个动作序列对象。

-- @function [parent=#transition] sequence

-- @param table args 动作的表格对象

-- @return Sequence#Sequence ret (return value: cc.Sequence)  动作序列对象

--[[--

创建一个动作序列对象。

~~~ lua

local sequence = transition.sequence({

    cc.MoveTo:create(0.5, cc.p(display.cx, display.cy)),

    cc.FadeOut:create(0.2),

    cc.DelayTime:create(0.5),

    cc.FadeIn:create(0.3),

})

sprite:runAction(sequence)

~~~

]]

-- end --

function transition.sequence(actions)

    if #actions <  then return end

    if #actions <  then return actions[] end

    local prev = actions[]

    for i = , #actions do

        prev = cc.Sequence:create(prev, actions[i])

    end

    return prev

end

-- start --

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

-- 在显示对象上播放一次动画，并返回 Action 动作对象。

-- @function [parent=#transition] playAnimationOnce

-- @param cc.Node target 显示对象

-- @param cc.Node animation 动作对象

-- @param boolean removeWhenFinished 播放完成后删除显示对象

-- @param function onComplete 播放完成后要执行的函数

-- @param number delay 播放前等待的时间

-- @return table#table ret (return value: table)  动作表格对象

--[[--

在显示对象上播放一次动画，并返回 Action 动作对象。

~~~ lua

local frames = display.newFrames("Walk%04d.png", 1, 20)

local animation = display.newAnimation(frames, 0.5 / 20) -- 0.5s play 20 frames

transition.playAnimationOnce(sprite, animation)

~~~

还可以用 Sprite 对象的 playAnimationOnce() 方法来直接播放动画：

~~~ lua

local frames = display.newFrames("Walk%04d.png", 1, 20)

local animation = display.newAnimation(frames, 0.5 / 20) -- 0.5s play 20 frames

sprite:playAnimationOnce(animation)

~~~

playAnimationOnce() 提供了丰富的功能，例如在动画播放完成后就删除用于播放动画的 Sprite 对象。例如一个爆炸效果：

~~~ lua

local frames = display.newFrames("Boom%04d.png", 1, 8)

local boom = display.newSprite(frames[1])

-- playAnimationOnce() 第二个参数为 true 表示动画播放完后删除 boom 这个 Sprite 对象

-- 这样爆炸动画播放完毕，就自动清理了不需要的显示对象

boom:playAnimationOnce(display.newAnimation(frames, 0.3/ 8), true)

~~~

此外，playAnimationOnce() 还允许在动画播放完成后执行一个指定的函数，以及播放动画前等待一段时间。合理运用这些功能，可以大大简化我们的游戏代码。

]]

-- end --

function transition.playAnimationOnce(target, animation, removeWhenFinished, onComplete, delay)

    local actions = {}

    if type(delay) == "number" and delay >  then

        target:setVisible(false)

        actions[#actions + ] = cc.DelayTime:create(delay)

        actions[#actions + ] = cc.Show:create()

    end

    actions[#actions + ] = cc.Animate:create(animation)

    if removeWhenFinished then

        actions[#actions + ] = cc.RemoveSelf:create()

    end

    if onComplete then

        actions[#actions + ] = cc.CallFunc:create(onComplete)

    end

    local action

    if #actions >  then

        action = transition.sequence(actions)

    else

        action = actions[]

    end

    target:runAction(action)

    return action

end

-- start --

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

-- 在显示对象上循环播放动画，并返回 Action 动作对象。

-- @function [parent=#transition] playAnimationForever

-- @param cc.Node target 显示对象

-- @param cc.Node animation 动作对象

-- @param number delay 播放前等待的时间

-- @return table#table ret (return value: table)  动作表格对象

--[[--

在显示对象上循环播放动画，并返回 Action 动作对象。

~~~ lua

local frames = display.newFrames("Walk%04d.png", 1, 20)

local animation = display.newAnimation(frames, 0.5 / 20) -- 0.5s play 20 frames

sprite:playAnimationForever(animation)

~~~

]]

-- end --

function transition.playAnimationForever(target, animation, delay)

    local animate = cc.Animate:create(animation)

    local action

    if type(delay) == "number" and delay >  then

        target:setVisible(false)

        local sequence = transition.sequence({

            cc.DelayTime:create(delay),

            cc.Show:create(),

            animate,

        })

        action = cc.RepeatForever:create(sequence)

    else

        action = cc.RepeatForever:create(animate)

    end

    target:runAction(action)

    return action

end

-- start --

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

-- 停止一个正在执行的动作

-- @function [parent=#transition] removeAction

-- @param mixed target

--[[--

停止一个正在执行的动作

~~~ lua

-- 开始移动

local action = transition.moveTo(sprite, {time = 2.0, x = 100, y = 100})

....

transition.removeAction(action) -- 停止移动

~~~

]]

-- end --

function transition.removeAction(action)

    if not tolua.isnull(action) then

        actionManager:removeAction(action)

    end

end

-- start --

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

-- 停止一个显示对象上所有正在执行的动作

-- @function [parent=#transition] stopTarget

-- @param mixed target

--[[--

停止一个显示对象上所有正在执行的动作

~~~ lua

-- 开始移动

transition.moveTo(sprite, {time = 2.0, x = 100, y = 100})

transition.fadeOut(sprite, {time = 2.0})

....

transition.stopTarget(sprite)

~~~

注意:显示对象的 performWithDelay() 方法是用动作来实现延时回调操作的，所以如果停止显示对象上的所有动作，会清除该对象上的延时回调操作。

]]

-- end --

function transition.stopTarget(target)

    if not tolua.isnull(target) then

        actionManager:removeAllActionsFromTarget(target)

    end

end

-- start --

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

-- 暂停显示对象上所有正在执行的动作

-- @function [parent=#transition] pauseTarget

-- @param mixed target

-- end --

function transition.pauseTarget(target)

    if not tolua.isnull(target) then

        actionManager:pauseTarget(target)

    end

end

-- start --

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

-- 恢复显示对象上所有暂停的动作

-- @function [parent=#transition] resumeTarget

-- @param mixed target

-- end --

function transition.resumeTarget(target)

    if not tolua.isnull(target) then

        actionManager:resumeTarget(target)

    end

end

return transition

quick lua 3.3常用方法和学习技巧之transition.lua的更多相关文章

  1. quick lua 3.3常用方法和学习技巧之functions.lua目录

    1.functions.lua (framework->functions.lua) 提供一组常用函数,以及对 Lua 标准库的扩展 1.printf 2.checknumber checkin ...

  2. 老司机浅谈linux系统学习技巧

    Linux起源于20世纪70年代,是一种优秀的操作系统系统.初次接触到linux这个系统是在大学期间,这样才发现除了windows外的另外一个有趣系统.开始抱着好奇的心态去了解,随着深入学习,笔者被它 ...

  3. uLua学习之读取外部Lua脚本（四）

    前言 上节说到了Lua脚本与unity3d中C#脚本的数据交互,但是我感觉上节中的数理方式不太好,因为我们是把Lua脚本以字符串形式粘贴到C#脚本中的,如果读取配置数据都这样做的话,那就太可怕了.想想 ...

  4. 零基础转行Linux云计算运维工程师获得20万年薪的超级学习技巧

    云计算概念一旦产生便一发不可收拾,成为移动互联网时代最为火热的行业之一.国内各大互联网公司例如阿里.腾讯.百度.网易等纷纷推出自己的云计算产品,3月10日,腾讯云0.01元投标时间更是让云计算在普罗大 ...

  5. Lua学习 2) —— Android与Lua互调

    2014-07-09 一.Android类调用lua并回调 Android调用Lua函数,同一时候把类作为參数传递过去.然后再Lua中回调类的函数 调用lua mLuaState = LuaState ...

  6. Cocos 2d-X Lua 游戏添加苹果内购(二) OC和Lua交互代码详解

    这是第二篇 Cocos 2d-X Lua 游戏添加苹果内购(一) 图文详解准备流程 这是前面的第一篇,详细的说明了怎样添加内购项目以及填写银行信息提交以及沙盒测试员的添加使用以及需要我们注意的东西,结 ...

  7. 跟我学习css3之transition

    HTML5和css3已经是将来的发展趋势,现在有很多移动端还有一些游戏公司已然使用它们开 发了比较成功的产品.我在2011年的时候也跟着技术潮流初浅的学习了html5+css3.毕竟那 时候我没有把学 ...

  8. ubuntu/wireshark --Lua: Error during loading: [string "/usr/share/wireshark/init.lua"]:45问题解决

    错误如下: 解决方案:修改init.lua 直接运行wireshark的话会报错: Lua: Error during loading:[string "/usr/share/wiresha ...

  9. lua学习笔记11：lua中的小技巧

    lua中的小技巧,即基础lua语言本身的特种,进行一个些简化的操作 一. 巧用or x = x or v 等价于: if not x then x = v end 假设x为nil或false,就给他赋 ...

随机推荐

  1. Javascript 编程小技巧总结（部分内容借鉴他人）

    1 – 使用===,而不是＝＝ ==(或!=)操作符在需要的时候会自动执行类型转换.===(或!==)操作不会执行任何转换.它将比较值和类型,而且在速度上也被认为优于==. 2 – 使用闭包实现私有变 ...

  2. iOS 导入第三方文件夹时右侧出现问号

    首先,和版本库有关. a代表add,m代表modify,?代表未能识别,通常如果使用git之类的版本控制器,添加文件后没有进行提交,就会出现? 1.遇到引用文件夹为蓝色的情况,是你以为勾了copy项, ...

  3. 形形色色的下拉菜单 (css3)

    http://www.iteye.com/news/25339

  4. response的Writer输出数据的问题

    package cn.itcast.response; import java.io.IOException; import java.io.OutputStream; import java.io. ...

  5. c3p0数据库连接池死锁问题

    项目进行压力测试的时候,运行大概1小时候,后台抛出以下异常: Nov 9, 2012 1:41:59 AM com.mchange.v2.async.ThreadPoolAsynchronousRun ...

  6. P1941 飞扬的小鸟

    此题很容易写出方程,由以前的知识可以迁移得,本题可以用完全背包的方法进行优化,使用滚动数组即可得到答案. //莫名奇妙60分.不知道什么细节出了错. #include <bits/stdc++. ...

  7. 阅读廖雪峰老师git教程笔记

    1.首先git是目前世界上最先进的分布式版本控制系统之一.所谓版本控制是针对工作中一些普遍的现象的. 比如,你写一份文档,期间,不断的改善,每次修改都会进行备份,久而久之,会有很多版本的同一份文档,但 ...

  8. iOS 两个App之间调起通信

    前言 假设需求是这样的:由一个app1跳转到app2之后,app2完成某项任务之后,怎么把app2的完成信息传到app1(自己的程序是app1),传的是什么类型的数据,怎么进行解析? 逻辑 本文章使用 ...

  9. C语言 ---- 函数 结构体 iOS学习-----细碎知识点总结

    函数的定义     返回值类型 函数名(形式参数列表) {        函数的实现     } 函数不允许嵌套定义 如果函数的定义在主调函数之后,那么要进行提前声明才能使用. // 匿名结构体,结构 ...

  10. IBM服务器诊断面板

    IBM服务器一般会有一个服务器操作员信息面板(诊断面板),服务器一般的硬件故障都会在诊断面板上提示,但这些提示可能只是一个大概的诊断故障,有助于系统管理员更好的维护. 一.IBM X3650 M3诊断 ...