mirror of https://github.com/axmolengine/axmol.git
1295 lines
37 KiB
Lua
1295 lines
37 KiB
Lua
local size = CCDirector:getInstance():getWinSize()
|
|
|
|
local function initWithLayer(layer)
|
|
grossini = CCSprite:create(s_pPathGrossini)
|
|
tamara = CCSprite:create(s_pPathSister1)
|
|
kathia = CCSprite:create(s_pPathSister2)
|
|
|
|
layer:addChild(grossini, 1)
|
|
layer:addChild(tamara, 2)
|
|
layer:addChild(kathia, 3)
|
|
|
|
grossini:setPosition(CCPoint(size.width / 2, size.height / 3))
|
|
tamara:setPosition(CCPoint(size.width / 2, 2 * size.height / 3))
|
|
kathia:setPosition(CCPoint(size.width / 2, size.height / 2))
|
|
|
|
Helper.initWithLayer(layer)
|
|
end
|
|
|
|
|
|
local function centerSprites(numberOfSprites)
|
|
if numberOfSprites == 0 then
|
|
tamara:setVisible(false)
|
|
kathia:setVisible(false)
|
|
grossini:setVisible(false)
|
|
elseif numberOfSprites == 1 then
|
|
tamara:setVisible(false)
|
|
kathia:setVisible(false)
|
|
grossini:setPosition(CCPoint(size.width / 2, size.height / 2))
|
|
elseif numberOfSprites == 2 then
|
|
kathia:setPosition(CCPoint(size.width / 3, size.height / 2))
|
|
tamara:setPosition(CCPoint(2 * size.width / 3, size.height / 2))
|
|
grossini:setVisible(false)
|
|
elseif numberOfSprites == 3 then
|
|
grossini:setPosition(CCPoint(size.width / 2, size.height / 2))
|
|
tamara:setPosition(CCPoint(size.width / 4, size.height / 2))
|
|
kathia:setPosition(CCPoint(3 * size.width / 4, size.height / 2))
|
|
end
|
|
end
|
|
|
|
local function alignSpritesLeft(numberOfSprites)
|
|
if numberOfSprites == 1 then
|
|
tamara:setVisible(false)
|
|
kathia:setVisible(false)
|
|
grossini:setPosition(CCPoint(60, size.height / 2))
|
|
elseif numberOfSprites == 2 then
|
|
kathia:setPosition(CCPoint(60, size.height / 3))
|
|
tamara:setPosition(CCPoint(60, 2 * size.height / 3))
|
|
grossini:setVisible(false)
|
|
elseif numberOfSprites == 3 then
|
|
grossini:setPosition(CCPoint(60, size.height / 2))
|
|
tamara:setPosition(CCPoint(60, 2 * size.height / 3))
|
|
kathia:setPosition(CCPoint(60, size.height / 3))
|
|
end
|
|
end
|
|
|
|
|
|
--------------------------------------
|
|
-- ActionManual
|
|
--------------------------------------
|
|
local function ActionManual()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
tamara:setScaleX(2.5)
|
|
tamara:setScaleY(-1.0)
|
|
tamara:setPosition(CCPoint(100, 70))
|
|
tamara:setOpacity(128)
|
|
|
|
grossini:setRotation(120)
|
|
grossini:setPosition(CCPoint(size.width / 2, size.height / 2))
|
|
grossini:setColor(Color3B(255, 0, 0))
|
|
|
|
kathia:setPosition(CCPoint(size.width - 100, size.height / 2))
|
|
kathia:setColor(Color3B(0, 0, 255))
|
|
|
|
Helper.subtitleLabel:setString("Manual Transformation")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionMove
|
|
--------------------------------------
|
|
local function ActionMove()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
local actionBy = CCMoveBy:create(2, CCPoint(80, 80))
|
|
local actionByBack = actionBy:reverse()
|
|
|
|
tamara:runAction(CCMoveTo:create(2, CCPoint(size.width - 40, size.height - 40)))
|
|
grossini:runAction(CCSequence:createWithTwoActions(actionBy, actionByBack))
|
|
kathia:runAction(CCMoveTo:create(1, CCPoint(40, 40)))
|
|
|
|
Helper.subtitleLabel:setString("MoveTo / MoveBy")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionScale
|
|
--------------------------------------
|
|
local function ActionScale()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
|
|
local actionTo = CCScaleTo:create(2.0, 0.5)
|
|
local actionBy = CCScaleBy:create(2.0, 1.0, 10.0)
|
|
local actionBy2 = CCScaleBy:create(2.0, 5.0, 1.0)
|
|
|
|
grossini:runAction(actionTo)
|
|
tamara:runAction(CCSequence:createWithTwoActions(actionBy, actionBy:reverse()))
|
|
kathia:runAction(CCSequence:createWithTwoActions(actionBy2, actionBy2:reverse()))
|
|
|
|
Helper.subtitleLabel:setString("ScaleTo / ScaleBy")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionRotate
|
|
--------------------------------------
|
|
local function ActionRotate()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
|
|
local actionTo = CCRotateTo:create( 2, 45)
|
|
local actionTo2 = CCRotateTo:create( 2, -45)
|
|
local actionTo0 = CCRotateTo:create(2 , 0)
|
|
tamara:runAction(CCSequence:createWithTwoActions(actionTo, actionTo0))
|
|
|
|
local actionBy = CCRotateBy:create(2 , 360)
|
|
local actionByBack = actionBy:reverse()
|
|
grossini:runAction(CCSequence:createWithTwoActions(actionBy, actionByBack))
|
|
|
|
local action0Retain = CCRotateTo:create(2 , 0)
|
|
|
|
kathia:runAction(CCSequence:createWithTwoActions(actionTo2, action0Retain))
|
|
|
|
Helper.subtitleLabel:setString("RotateTo / RotateBy")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionSkew
|
|
--------------------------------------
|
|
local function ActionSkew()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
|
|
local actionTo = CCSkewTo:create(2, 37.2, -37.2)
|
|
local actionToBack = CCSkewTo:create(2, 0, 0)
|
|
local actionBy = CCSkewBy:create(2, 0.0, -90.0)
|
|
local actionBy2 = CCSkewBy:create(2, 45.0, 45.0)
|
|
local actionByBack = actionBy:reverse()
|
|
|
|
tamara:runAction(CCSequence:createWithTwoActions(actionTo, actionToBack))
|
|
grossini:runAction(CCSequence:createWithTwoActions(actionBy, actionByBack))
|
|
kathia:runAction(CCSequence:createWithTwoActions(actionBy2, actionBy2:reverse()))
|
|
|
|
Helper.subtitleLabel:setString("SkewTo / SkewBy")
|
|
return layer
|
|
end
|
|
|
|
--ActionRotationalSkewVSStandardSkew
|
|
local function ActionRotationalSkewVSStandardSkew()
|
|
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
tamara:removeFromParentAndCleanup(true);
|
|
grossini:removeFromParentAndCleanup(true);
|
|
kathia:removeFromParentAndCleanup(true);
|
|
|
|
local s = CCDirector:getInstance():getWinSize();
|
|
local boxSize = CCSize(100.0, 100.0);
|
|
local box = CCLayerColor:create(Color4B(255,255,0,255));
|
|
box:setAnchorPoint(CCPoint(0.5,0.5));
|
|
box:setContentSize( boxSize );
|
|
box:ignoreAnchorPointForPosition(false);
|
|
box:setPosition(CCPoint(s.width/2, s.height - 100 - box:getContentSize().height/2));
|
|
layer:addChild(box);
|
|
local label = CCLabelTTF:create("Standard cocos2d Skew", "Marker Felt", 16);
|
|
label:setPosition(CCPoint(s.width/2, s.height - 100 + label:getContentSize().height));
|
|
layer:addChild(label);
|
|
local actionTo = CCSkewBy:create(2, 360, 0);
|
|
local actionToBack = CCSkewBy:create(2, -360, 0);
|
|
local seq = CCSequence:createWithTwoActions(actionTo, actionToBack)
|
|
|
|
box:runAction(seq);
|
|
|
|
box = CCLayerColor:create(Color4B(255,255,0,255));
|
|
box:setAnchorPoint(CCPoint(0.5,0.5));
|
|
box:setContentSize(boxSize);
|
|
box:ignoreAnchorPointForPosition(false);
|
|
box:setPosition(CCPoint(s.width/2, s.height - 250 - box:getContentSize().height/2));
|
|
layer:addChild(box);
|
|
label = CCLabelTTF:create("Rotational Skew", "Marker Felt", 16);
|
|
label:setPosition(CCPoint(s.width/2, s.height - 250 + label:getContentSize().height/2));
|
|
layer:addChild(label);
|
|
local actionTo2 = CCRotateBy:create(2, 360);
|
|
local actionToBack2 = CCRotateBy:create(2, -360);
|
|
seq = CCSequence:createWithTwoActions(actionTo2, actionToBack2)
|
|
box:runAction(seq);
|
|
|
|
Helper.subtitleLabel:setString("Skew Comparison")
|
|
return layer;
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionSkewRotate
|
|
--------------------------------------
|
|
local function ActionSkewRotate()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
tamara:removeFromParentAndCleanup(true)
|
|
grossini:removeFromParentAndCleanup(true)
|
|
kathia:removeFromParentAndCleanup(true)
|
|
|
|
local boxSize = CCSize(100.0, 100.0)
|
|
|
|
local box = CCLayerColor:create(Color4B(255, 255, 0, 255))
|
|
box:setAnchorPoint(CCPoint(0, 0))
|
|
box:setPosition(190, 110)
|
|
box:setContentSize(boxSize)
|
|
|
|
local markrside = 10.0
|
|
local uL = CCLayerColor:create(Color4B(255, 0, 0, 255))
|
|
box:addChild(uL)
|
|
uL:setContentSize(CCSize(markrside, markrside))
|
|
uL:setPosition(0, boxSize.height - markrside)
|
|
uL:setAnchorPoint(CCPoint(0, 0))
|
|
|
|
local uR = CCLayerColor:create(Color4B(0, 0, 255, 255))
|
|
box:addChild(uR)
|
|
uR:setContentSize(CCSize(markrside, markrside))
|
|
uR:setPosition(boxSize.width - markrside, boxSize.height - markrside)
|
|
uR:setAnchorPoint(CCPoint(0, 0))
|
|
layer:addChild(box)
|
|
|
|
local actionTo = CCSkewTo:create(2, 0, 2)
|
|
local rotateTo = CCRotateTo:create(2, 61.0)
|
|
local actionScaleTo = CCScaleTo:create(2, -0.44, 0.47)
|
|
|
|
local actionScaleToBack = CCScaleTo:create(2, 1.0, 1.0)
|
|
local rotateToBack = CCRotateTo:create(2, 0)
|
|
local actionToBack = CCSkewTo:create(2, 0, 0)
|
|
|
|
box:runAction(CCSequence:createWithTwoActions(actionTo, actionToBack))
|
|
box:runAction(CCSequence:createWithTwoActions(rotateTo, rotateToBack))
|
|
box:runAction(CCSequence:createWithTwoActions(actionScaleTo, actionScaleToBack))
|
|
|
|
Helper.subtitleLabel:setString("Skew + Rotate + Scale")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionJump
|
|
--------------------------------------
|
|
local function ActionJump()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
|
|
local actionTo = CCJumpTo:create(2, CCPoint(300,300), 50, 4)
|
|
local actionBy = CCJumpBy:create(2, CCPoint(300,0), 50, 4)
|
|
local actionUp = CCJumpBy:create(2, CCPoint(0,0), 80, 4)
|
|
local actionByBack = actionBy:reverse()
|
|
|
|
tamara:runAction(actionTo)
|
|
grossini:runAction(CCSequence:createWithTwoActions(actionBy, actionByBack))
|
|
kathia:runAction(CCRepeatForever:create(actionUp))
|
|
|
|
Helper.subtitleLabel:setString("JumpTo / JumpBy")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionCardinalSpline
|
|
--------------------------------------
|
|
local function drawCardinalSpline(array)
|
|
kmGLPushMatrix()
|
|
kmGLTranslatef(50, 50, 0)
|
|
CCDrawPrimitives.ccDrawCardinalSpline(array, 0, 100)
|
|
kmGLPopMatrix()
|
|
|
|
kmGLPushMatrix()
|
|
kmGLTranslatef(size.width / 2, 50, 0)
|
|
CCDrawPrimitives.ccDrawCardinalSpline(array, 1, 100)
|
|
kmGLPopMatrix()
|
|
end
|
|
|
|
local function ActionCardinalSpline()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
local array = CCPointArray:create(20)
|
|
array:addControlPoint(CCPoint(0, 0))
|
|
array:addControlPoint(CCPoint(size.width / 2 - 30, 0))
|
|
array:addControlPoint(CCPoint(size.width / 2 - 30, size.height - 80))
|
|
array:addControlPoint(CCPoint(0, size.height - 80))
|
|
array:addControlPoint(CCPoint(0, 0))
|
|
|
|
local action = CCCardinalSplineBy:create(3, array, 0)
|
|
local reverse = action:reverse()
|
|
local seq = CCSequence:createWithTwoActions(action, reverse)
|
|
|
|
tamara:setPosition(CCPoint(50, 50))
|
|
tamara:runAction(seq)
|
|
|
|
local action2 = CCCardinalSplineBy:create(3, array, 1)
|
|
local reverse2 = action2:reverse()
|
|
local seq2 = CCSequence:createWithTwoActions(action2, reverse2)
|
|
|
|
kathia:setPosition(CCPoint(size.width / 2, 50))
|
|
kathia:runAction(seq2)
|
|
|
|
drawCardinalSpline(array)
|
|
|
|
Helper.titleLabel:setString("CardinalSplineBy / CardinalSplineAt")
|
|
Helper.subtitleLabel:setString("Cardinal Spline paths.\nTesting different tensions for one array")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionCatmullRom
|
|
--------------------------------------
|
|
local function drawCatmullRom(array1, array2)
|
|
kmGLPushMatrix()
|
|
kmGLTranslatef(50, 50, 0)
|
|
CCDrawPrimitives.ccDrawCatmullRom(array1, 50)
|
|
kmGLPopMatrix()
|
|
|
|
CCDrawPrimitives.ccDrawCatmullRom(array2,50)
|
|
end
|
|
|
|
local function ActionCatmullRom()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
tamara:setPosition(CCPoint(50, 50))
|
|
|
|
local array = CCPointArray:create(20)
|
|
array:addControlPoint(CCPoint(0, 0))
|
|
array:addControlPoint(CCPoint(80, 80))
|
|
array:addControlPoint(CCPoint(size.width - 80, 80))
|
|
array:addControlPoint(CCPoint(size.width - 80, size.height - 80))
|
|
array:addControlPoint(CCPoint(80, size.height - 80))
|
|
array:addControlPoint(CCPoint(80, 80))
|
|
array:addControlPoint(CCPoint(size.width / 2, size.height / 2))
|
|
|
|
local action = CCCatmullRomBy:create(3, array)
|
|
local reverse = action:reverse()
|
|
local seq = CCSequence:createWithTwoActions(action, reverse)
|
|
tamara:runAction(seq)
|
|
|
|
local array2 = CCPointArray:create(20)
|
|
array2:addControlPoint(CCPoint(size.width / 2, 30))
|
|
array2:addControlPoint(CCPoint(size.width -80, 30))
|
|
array2:addControlPoint(CCPoint(size.width - 80, size.height - 80))
|
|
array2:addControlPoint(CCPoint(size.width / 2, size.height - 80))
|
|
array2:addControlPoint(CCPoint(size.width / 2, 30))
|
|
|
|
local action2 = CCCatmullRomTo:create(3, array2)
|
|
local reverse2 = action2:reverse()
|
|
local seq2 = CCSequence:createWithTwoActions(action2, reverse2)
|
|
kathia:runAction(seq2)
|
|
|
|
drawCatmullRom(array, array2)
|
|
|
|
Helper.titleLabel:setString("CatmullRomBy / CatmullRomTo")
|
|
Helper.subtitleLabel:setString("Catmull Rom spline paths. Testing reverse too")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionBezier
|
|
--------------------------------------
|
|
local function ActionBezier()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
|
|
-- sprite 1
|
|
local bezier = ccBezierConfig()
|
|
bezier.controlPoint_1 = CCPoint(0, size.height / 2)
|
|
bezier.controlPoint_2 = CCPoint(300, - size.height / 2)
|
|
bezier.endPosition = CCPoint(300, 100)
|
|
|
|
local bezierForward = CCBezierBy:create(3, bezier)
|
|
local bezierBack = bezierForward:reverse()
|
|
local rep = CCRepeatForever:create(CCSequence:createWithTwoActions(bezierForward, bezierBack))
|
|
|
|
-- sprite 2
|
|
tamara:setPosition(CCPoint(80,160))
|
|
local bezier2 = ccBezierConfig()
|
|
bezier2.controlPoint_1 = CCPoint(100, size.height / 2)
|
|
bezier2.controlPoint_2 = CCPoint(200, - size.height / 2)
|
|
bezier2.endPosition = CCPoint(240, 160)
|
|
|
|
local bezierTo1 = CCBezierTo:create(2, bezier2)
|
|
|
|
-- sprite 3
|
|
kathia:setPosition(CCPoint(400,160))
|
|
local bezierTo2 = CCBezierTo:create(2, bezier2)
|
|
|
|
grossini:runAction(rep)
|
|
tamara:runAction(bezierTo1)
|
|
kathia:runAction(bezierTo2)
|
|
|
|
Helper.subtitleLabel:setString("BezierTo / BezierBy")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionBlink
|
|
--------------------------------------
|
|
local function ActionBlink()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
local action1 = CCBlink:create(2, 10)
|
|
local action2 = CCBlink:create(2, 5)
|
|
|
|
tamara:runAction(action1)
|
|
kathia:runAction(action2)
|
|
|
|
Helper.subtitleLabel:setString("Blink")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionFade
|
|
--------------------------------------
|
|
local function ActionFade()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
tamara:setOpacity(0)
|
|
local action1 = CCFadeIn:create(1)
|
|
local action1Back = action1:reverse()
|
|
|
|
local action2 = CCFadeOut:create(1)
|
|
local action2Back = action2:reverse()
|
|
|
|
tamara:runAction(CCSequence:createWithTwoActions( action1, action1Back))
|
|
kathia:runAction(CCSequence:createWithTwoActions( action2, action2Back))
|
|
|
|
Helper.subtitleLabel:setString("FadeIn / FadeOut")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionTint
|
|
--------------------------------------
|
|
local function ActionTint()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
local action1 = CCTintTo:create(2, 255, 0, 255)
|
|
local action2 = CCTintBy:create(2, -127, -255, -127)
|
|
local action2Back = action2:reverse()
|
|
|
|
tamara:runAction(action1)
|
|
kathia:runAction(CCSequence:createWithTwoActions(action2, action2Back))
|
|
|
|
Helper.subtitleLabel:setString("TintTo / TintBy")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionAnimate
|
|
--------------------------------------
|
|
local function ActionAnimate()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
|
|
local animation = CCAnimation:create()
|
|
local number, name
|
|
for i = 1, 14 do
|
|
if i < 10 then
|
|
number = "0"..i
|
|
else
|
|
number = i
|
|
end
|
|
name = "Images/grossini_dance_"..number..".png"
|
|
animation:addSpriteFrameWithFileName(name)
|
|
end
|
|
-- should last 2.8 seconds. And there are 14 frames.
|
|
animation:setDelayPerUnit(2.8 / 14.0)
|
|
animation:setRestoreOriginalFrame(true)
|
|
|
|
local action = CCAnimate:create(animation)
|
|
grossini:runAction(CCSequence:createWithTwoActions(action, action:reverse()))
|
|
|
|
local cache = CCAnimationCache:getInstance()
|
|
cache:addAnimationsWithFile("animations/animations-2.plist")
|
|
local animation2 = cache:animationByName("dance_1")
|
|
|
|
local action2 = CCAnimate:create(animation2)
|
|
tamara:runAction(CCSequence:createWithTwoActions(action2, action2:reverse()))
|
|
|
|
local animation3 = animation2:clone()
|
|
-- problem
|
|
tolua.cast(animation3,"CCAnimation"):setLoops(4)
|
|
|
|
local action3 = CCAnimate:create(animation3)
|
|
kathia:runAction(action3)
|
|
|
|
Helper.titleLabel:setString("Animation")
|
|
Helper.subtitleLabel:setString("Center: Manual animation. Border: using file format animation")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionSequence
|
|
--------------------------------------
|
|
local function ActionSequence()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
alignSpritesLeft(1)
|
|
|
|
local action = CCSequence:createWithTwoActions(
|
|
CCMoveBy:create(2, CCPoint(240,0)),
|
|
CCRotateBy:create(2, 540))
|
|
|
|
grossini:runAction(action)
|
|
|
|
Helper.subtitleLabel:setString("Sequence: Move + Rotate")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionSequence2
|
|
--------------------------------------
|
|
local actionSequenceLayer = nil
|
|
|
|
local function ActionSequenceCallback1()
|
|
local label = CCLabelTTF:create("callback 1 called", "Marker Felt", 16)
|
|
label:setPosition(size.width / 4, size.height / 2)
|
|
|
|
actionSequenceLayer:addChild(label)
|
|
end
|
|
|
|
local function ActionSequenceCallback2(sender)
|
|
local label = CCLabelTTF:create("callback 2 called", "Marker Felt", 16)
|
|
label:setPosition(CCPoint(size.width / 4 * 2, size.height / 2))
|
|
|
|
actionSequenceLayer:addChild(label)
|
|
end
|
|
|
|
local function ActionSequenceCallback3(sender)
|
|
local label = CCLabelTTF:create("callback 3 called", "Marker Felt", 16)
|
|
label:setPosition(CCPoint(size.width / 4 * 3, size.height / 2))
|
|
|
|
actionSequenceLayer:addChild(label)
|
|
end
|
|
|
|
local function ActionSequence2()
|
|
actionSequenceLayer = CCLayer:create()
|
|
initWithLayer(actionSequenceLayer)
|
|
|
|
alignSpritesLeft(1)
|
|
|
|
grossini:setVisible(false)
|
|
local array = CCArray:create()
|
|
array:addObject(CCPlace:create(CCPoint(200,200)))
|
|
array:addObject(CCShow:create())
|
|
array:addObject(CCMoveBy:create(1, CCPoint(100,0)))
|
|
array:addObject(CCCallFunc:create(ActionSequenceCallback1))
|
|
array:addObject(CCCallFunc:create(ActionSequenceCallback2))
|
|
array:addObject(CCCallFunc:create(ActionSequenceCallback3))
|
|
|
|
local action = CCSequence:create(array)
|
|
|
|
grossini:runAction(action)
|
|
|
|
Helper.subtitleLabel:setString("Sequence of InstantActions")
|
|
return actionSequenceLayer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionSpawn
|
|
--------------------------------------
|
|
local function ActionSpawn()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
alignSpritesLeft(1)
|
|
|
|
local action = CCSpawn:createWithTwoActions(
|
|
CCJumpBy:create(2, CCPoint(300,0), 50, 4),
|
|
CCRotateBy:create( 2, 720))
|
|
|
|
grossini:runAction(action)
|
|
|
|
Helper.subtitleLabel:setString("Spawn: Jump + Rotate")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionReverse
|
|
--------------------------------------
|
|
local function ActionReverse()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
alignSpritesLeft(1)
|
|
|
|
local jump = CCJumpBy:create(2, CCPoint(300,0), 50, 4)
|
|
local action = CCSequence:createWithTwoActions(jump, jump:reverse())
|
|
|
|
grossini:runAction(action)
|
|
|
|
Helper.subtitleLabel:setString("Reverse an action")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionDelaytime
|
|
--------------------------------------
|
|
local function ActionDelaytime()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
alignSpritesLeft(1)
|
|
|
|
local move = CCMoveBy:create(1, CCPoint(150,0))
|
|
local array = CCArray:create()
|
|
array:addObject(move)
|
|
array:addObject(CCDelayTime:create(2))
|
|
array:addObject(move)
|
|
local action = CCSequence:create(array)
|
|
|
|
grossini:runAction(action)
|
|
|
|
Helper.subtitleLabel:setString("DelayTime: m + delay + m")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionRepeat
|
|
--------------------------------------
|
|
local function ActionRepeat()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
alignSpritesLeft(2)
|
|
|
|
local a1 = CCMoveBy:create(1, CCPoint(150,0))
|
|
local action1 = CCRepeat:create(CCSequence:createWithTwoActions(CCPlace:create(CCPoint(60,60)), a1), 3)
|
|
|
|
local a2 = CCMoveBy:create(1, CCPoint(150,0))
|
|
local action2 = CCRepeatForever:create(CCSequence:createWithTwoActions(a2, a1:reverse()))
|
|
|
|
kathia:runAction(action1)
|
|
tamara:runAction(action2)
|
|
|
|
Helper.subtitleLabel:setString("Repeat / RepeatForever actions")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionRepeatForever
|
|
--------------------------------------
|
|
local function repeatForever(sender)
|
|
local repeatAction = CCRepeatForever:create(CCRotateBy:create(1.0, 360))
|
|
|
|
sender:runAction(repeatAction)
|
|
end
|
|
|
|
local function ActionRepeatForever()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(1)
|
|
|
|
local action = CCSequence:createWithTwoActions(
|
|
CCDelayTime:create(1),
|
|
CCCallFunc:create(repeatForever) )
|
|
|
|
grossini:runAction(action)
|
|
|
|
Helper.subtitleLabel:setString("CallFuncN + RepeatForever")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionRotateToRepeat
|
|
--------------------------------------
|
|
local function ActionRotateToRepeat()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
local act1 = CCRotateTo:create(1, 90)
|
|
local act2 = CCRotateTo:create(1, 0)
|
|
local seq = CCSequence:createWithTwoActions(act1, act2)
|
|
local rep1 = CCRepeatForever:create(seq)
|
|
local rep2 = CCRepeat:create(tolua.cast(seq:clone(), "CCSequence"), 10)
|
|
|
|
tamara:runAction(rep1)
|
|
kathia:runAction(rep2)
|
|
|
|
Helper.subtitleLabel:setString("Repeat/RepeatForever + RotateTo")
|
|
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionRotateJerk
|
|
--------------------------------------
|
|
local function ActionRotateJerk()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
local seq = CCSequence:createWithTwoActions(
|
|
CCRotateTo:create(0.5, -20),
|
|
CCRotateTo:create(0.5, 20))
|
|
|
|
local rep1 = CCRepeat:create(seq, 10)
|
|
|
|
local seq2 = CCSequence:createWithTwoActions(
|
|
CCRotateTo:create(0.5, -20),
|
|
CCRotateTo:create(0.5, 20))
|
|
|
|
local rep2 = CCRepeatForever:create(seq2)
|
|
|
|
tamara:runAction(rep1)
|
|
kathia:runAction(rep2)
|
|
|
|
Helper.subtitleLabel:setString("RepeatForever / Repeat + Rotate")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionCallFunc
|
|
--------------------------------------
|
|
local callFuncLayer = nil
|
|
|
|
local function CallFucnCallback1()
|
|
local label = CCLabelTTF:create("callback 1 called", "Marker Felt", 16)
|
|
label:setPosition(size.width / 4, size.height / 2)
|
|
|
|
callFuncLayer:addChild(label)
|
|
end
|
|
|
|
local function CallFucnCallback2(sender)
|
|
local label = CCLabelTTF:create("callback 2 called", "Marker Felt", 16)
|
|
label:setPosition(size.width / 4 * 2, size.height / 2)
|
|
|
|
callFuncLayer:addChild(label)
|
|
end
|
|
|
|
local function CallFucnCallback3(sender)
|
|
local label = CCLabelTTF:create("callback 3 called", "Marker Felt", 16)
|
|
label:setPosition(size.width / 4 * 3, size.height / 2)
|
|
|
|
callFuncLayer:addChild(label)
|
|
end
|
|
|
|
local function ActionCallFunc()
|
|
callFuncLayer = CCLayer:create()
|
|
initWithLayer(callFuncLayer)
|
|
|
|
centerSprites(3)
|
|
|
|
local action = CCSequence:createWithTwoActions(
|
|
CCMoveBy:create(2, CCPoint(200,0)),
|
|
CCCallFunc:create(CallFucnCallback1) )
|
|
|
|
local array = CCArray:create()
|
|
array:addObject(CCScaleBy:create(2, 2))
|
|
array:addObject(CCFadeOut:create(2))
|
|
array:addObject(CCCallFunc:create(CallFucnCallback2))
|
|
local action2 = CCSequence:create(array)
|
|
|
|
local array2 = CCArray:create()
|
|
array2:addObject(CCRotateBy:create(3 , 360))
|
|
array2:addObject(CCFadeOut:create(2))
|
|
array2:addObject(CCCallFunc:create(CallFucnCallback3))
|
|
local action3 = CCSequence:create(array2)
|
|
|
|
grossini:runAction(action)
|
|
tamara:runAction(action2)
|
|
kathia:runAction(action3)
|
|
|
|
Helper.subtitleLabel:setString("Callbacks: CallFunc and friends")
|
|
return callFuncLayer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionCallFuncND *
|
|
-- problem: the current luaEngine doesn't support
|
|
-- passing more than one param to lua script
|
|
--------------------------------------
|
|
local function ActionCallFuncND()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(1)
|
|
|
|
|
|
Helper.titleLabel:setString("CallFuncND + auto remove")
|
|
Helper.subtitleLabel:setString("CallFuncND + removeFromParentAndCleanup. Grossini dissapears in 2s")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionReverseSequence
|
|
--------------------------------------
|
|
local function ActionReverseSequence()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
alignSpritesLeft(1)
|
|
|
|
local move1 = CCMoveBy:create(1, CCPoint(250,0))
|
|
local move2 = CCMoveBy:create(1, CCPoint(0,50))
|
|
local array = CCArray:create()
|
|
array:addObject(move1)
|
|
array:addObject(move2)
|
|
array:addObject(move1:reverse())
|
|
local seq = CCSequence:create(array)
|
|
local action = CCSequence:createWithTwoActions(seq, seq:reverse())
|
|
|
|
grossini:runAction(action)
|
|
|
|
Helper.subtitleLabel:setString("Reverse a sequence")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionReverseSequence2
|
|
--------------------------------------
|
|
local function ActionReverseSequence2()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
alignSpritesLeft(2)
|
|
|
|
-- Test:
|
|
-- Sequence should work both with IntervalAction and InstantActions
|
|
local move1 = CCMoveBy:create(1, CCPoint(250,0))
|
|
local move2 = CCMoveBy:create(1, CCPoint(0,50))
|
|
local tog1 = CCToggleVisibility:create()
|
|
local tog2 = CCToggleVisibility:create()
|
|
local array = CCArray:createWithCapacity(10)
|
|
array:addObject(move1)
|
|
array:addObject(tog1)
|
|
array:addObject(move2)
|
|
array:addObject(tog2)
|
|
array:addObject(move1:reverse())
|
|
local seq = CCSequence:create(array)
|
|
local action = CCRepeat:create(CCSequence:createWithTwoActions(seq, seq:reverse()), 3)
|
|
|
|
-- Test:
|
|
-- Also test that the reverse of Hide is Show, and vice-versa
|
|
kathia:runAction(action)
|
|
|
|
local move_tamara = CCMoveBy:create(1, CCPoint(100,0))
|
|
local move_tamara2 = CCMoveBy:create(1, CCPoint(50,0))
|
|
local hide = CCHide:create()
|
|
local array2 = CCArray:createWithCapacity(10)
|
|
array2:addObject(move_tamara)
|
|
array2:addObject(hide)
|
|
array2:addObject(move_tamara2)
|
|
local seq_tamara = CCSequence:create(array2)
|
|
local seq_back = seq_tamara:reverse()
|
|
tamara:runAction(CCSequence:createWithTwoActions(seq_tamara, seq_back))
|
|
|
|
Helper.subtitleLabel:setString("Reverse a sequence2")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionOrbit
|
|
--------------------------------------
|
|
local function ActionOrbit()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(3)
|
|
|
|
local orbit1 = CCOrbitCamera:create(2,1, 0, 0, 180, 0, 0)
|
|
local action1 = CCSequence:createWithTwoActions(orbit1, orbit1:reverse())
|
|
|
|
local orbit2 = CCOrbitCamera:create(2,1, 0, 0, 180, -45, 0)
|
|
local action2 = CCSequence:createWithTwoActions(orbit2, orbit2:reverse())
|
|
|
|
local orbit3 = CCOrbitCamera:create(2,1, 0, 0, 180, 90, 0)
|
|
local action3 = CCSequence:createWithTwoActions(orbit3, orbit3:reverse())
|
|
|
|
kathia:runAction(CCRepeatForever:create(action1))
|
|
tamara:runAction(CCRepeatForever:create(action2))
|
|
grossini:runAction(CCRepeatForever:create(action3))
|
|
|
|
local move = CCMoveBy:create(3, CCPoint(100,-100))
|
|
local move_back = move:reverse()
|
|
local seq = CCSequence:createWithTwoActions(move, move_back)
|
|
local rfe = CCRepeatForever:create(seq)
|
|
kathia:runAction(rfe)
|
|
tamara:runAction(tolua.cast(rfe:clone(), "CCActionInterval"))
|
|
grossini:runAction(tolua.cast(rfe:clone(), "CCActionInterval"))
|
|
|
|
|
|
Helper.subtitleLabel:setString("OrbitCamera action")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionFollow
|
|
--------------------------------------
|
|
local function ActionFollow()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(1)
|
|
|
|
grossini:setPosition(CCPoint(-200, size.height / 2))
|
|
local move = CCMoveBy:create(2, CCPoint(size.width * 3, 0))
|
|
local move_back = move:reverse()
|
|
local seq = CCSequence:createWithTwoActions(move, move_back)
|
|
local rep = CCRepeatForever:create(seq)
|
|
|
|
grossini:runAction(rep)
|
|
|
|
layer:runAction(CCFollow:create(grossini, CCRect(0, 0, size.width * 2 - 100, size.height)))
|
|
|
|
Helper.subtitleLabel:setString("Follow action")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionTargeted
|
|
--------------------------------------
|
|
local function ActionTargeted()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
local jump1 = CCJumpBy:create(2, CCPoint(0, 0), 100, 3)
|
|
local jump2 = CCJumpBy:create(2, CCPoint(0, 0), 100, 3)
|
|
local rot1 = CCRotateBy:create(1, 360)
|
|
local rot2 = CCRotateBy:create(1, 360)
|
|
|
|
local t1 = CCTargetedAction:create(kathia, jump2)
|
|
local t2 = CCTargetedAction:create(kathia, rot2)
|
|
|
|
local array = CCArray:createWithCapacity(10)
|
|
array:addObject(jump1)
|
|
array:addObject(t1)
|
|
array:addObject(rot1)
|
|
array:addObject(t2)
|
|
local seq = CCSequence:create(array)
|
|
local always = CCRepeatForever:create(seq)
|
|
|
|
tamara:runAction(always)
|
|
|
|
Helper.titleLabel:setString("ActionTargeted")
|
|
Helper.subtitleLabel:setString("Action that runs on another target. Useful for sequences")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- PauseResumeActions *
|
|
-- problem: schedule feature is constructing
|
|
--------------------------------------
|
|
local pausedTargets = nil
|
|
local PauseResumeActions_pauseEntry = nil
|
|
local PauseResumeActions_resumeEntry = nil
|
|
|
|
local function ActionPause(dt)
|
|
cclog("Pausing")
|
|
|
|
local scheduler = CCDirector:getInstance():getScheduler()
|
|
scheduler:unscheduleScriptEntry(PauseResumeActions_pauseEntry)
|
|
|
|
local director = CCDirector:getInstance()
|
|
pausedTargets = director:getActionManager():pauseAllRunningActions()
|
|
pausedTargets:retain()
|
|
end
|
|
|
|
local function ActionResume(dt)
|
|
cclog("Resuming")
|
|
|
|
local scheduler = CCDirector:getInstance():getScheduler()
|
|
scheduler:unscheduleScriptEntry(PauseResumeActions_resumeEntry)
|
|
|
|
local director = CCDirector:getInstance()
|
|
if pausedTargets ~= nil then
|
|
-- problem: will crash here. Try fixing me!
|
|
director:getActionManager():resumeTargets(pausedTargets)
|
|
pausedTargets:release()
|
|
end
|
|
end
|
|
|
|
local function PauseResumeActions_onEnterOrExit(tag)
|
|
local scheduler = CCDirector:getInstance():getScheduler()
|
|
if tag == "enter" then
|
|
PauseResumeActions_pauseEntry = scheduler:scheduleScriptFunc(ActionPause, 3, false)
|
|
PauseResumeActions_resumeEntry = scheduler:scheduleScriptFunc(ActionResume, 5, false)
|
|
elseif tag == "exit" then
|
|
scheduler:unscheduleScriptEntry(PauseResumeActions_pauseEntry)
|
|
scheduler:unscheduleScriptEntry(PauseResumeActions_resumeEntry)
|
|
end
|
|
end
|
|
|
|
local function PauseResumeActions()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(2)
|
|
|
|
tamara:runAction(CCRepeatForever:create(CCRotateBy:create(3, 360)))
|
|
kathia:runAction(CCRepeatForever:create(CCRotateBy:create(3, 360)))
|
|
|
|
layer:registerScriptHandler(PauseResumeActions_onEnterOrExit)
|
|
|
|
Helper.titleLabel:setString("PauseResumeActions")
|
|
Helper.subtitleLabel:setString("All actions pause at 3s and resume at 5s")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionIssue1305
|
|
--------------------------------------
|
|
local spriteTmp = nil
|
|
local Issue1305_entry = nil
|
|
local Issue1305_layer = nil
|
|
|
|
local function Issue1305_log(sender)
|
|
cclog("This message SHALL ONLY appear when the sprite is added to the scene, NOT BEFORE")
|
|
end
|
|
|
|
local function addSprite(dt)
|
|
local scheduler = CCDirector:getInstance():getScheduler()
|
|
scheduler:unscheduleScriptEntry(Issue1305_entry)
|
|
|
|
spriteTmp:setPosition(CCPoint(250, 250))
|
|
Issue1305_layer:addChild(spriteTmp)
|
|
end
|
|
|
|
local function Issue1305_onEnterOrExit(tag)
|
|
local scheduler = CCDirector:getInstance():getScheduler()
|
|
if tag == "enter" then
|
|
Issue1305_entry = scheduler:scheduleScriptFunc(addSprite, 2, false)
|
|
elseif tag == "exit" then
|
|
scheduler:unscheduleScriptEntry(Issue1305_entry)
|
|
end
|
|
end
|
|
|
|
local function ActionIssue1305()
|
|
Issue1305_layer = CCLayer:create()
|
|
initWithLayer(Issue1305_layer)
|
|
|
|
centerSprites(0)
|
|
|
|
spriteTmp = CCSprite:create("Images/grossini.png")
|
|
spriteTmp:runAction(CCCallFunc:create(Issue1305_log))
|
|
|
|
Issue1305_layer:registerScriptHandler(Issue1305_onEnterOrExit)
|
|
|
|
Helper.titleLabel:setString("Issue 1305")
|
|
Helper.subtitleLabel:setString("In two seconds you should see a message on the console. NOT BEFORE.")
|
|
return Issue1305_layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionIssue1305_2
|
|
--------------------------------------
|
|
local function Issue1305_2_log1()
|
|
cclog("1st block")
|
|
end
|
|
|
|
local function Issue1305_2_log2()
|
|
cclog("2nd block")
|
|
end
|
|
|
|
local function Issue1305_2_log3()
|
|
cclog("3rd block")
|
|
end
|
|
|
|
local function Issue1305_2_log4()
|
|
cclog("4th block")
|
|
end
|
|
|
|
local function ActionIssue1305_2()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(0)
|
|
|
|
local spr = CCSprite:create("Images/grossini.png")
|
|
spr:setPosition(CCPoint(200,200))
|
|
layer:addChild(spr)
|
|
|
|
local act1 = CCMoveBy:create(2 ,CCPoint(0, 100))
|
|
local act2 = CCCallFunc:create(Issue1305_2_log1)
|
|
local act3 = CCMoveBy:create(2, CCPoint(0, -100))
|
|
local act4 = CCCallFunc:create(Issue1305_2_log2)
|
|
local act5 = CCMoveBy:create(2, CCPoint(100, -100))
|
|
local act6 = CCCallFunc:create(Issue1305_2_log3)
|
|
local act7 = CCMoveBy:create(2, CCPoint(-100, 0))
|
|
local act8 = CCCallFunc:create(Issue1305_2_log4)
|
|
|
|
local array = CCArray:create()
|
|
array:addObject(act1)
|
|
array:addObject(act2)
|
|
array:addObject(act3)
|
|
array:addObject(act4)
|
|
array:addObject(act5)
|
|
array:addObject(act6)
|
|
array:addObject(act7)
|
|
array:addObject(act8)
|
|
local actF = CCSequence:create(array)
|
|
|
|
CCDirector:getInstance():getActionManager():addAction(actF ,spr, false)
|
|
|
|
Helper.titleLabel:setString("Issue 1305 #2")
|
|
Helper.subtitleLabel:setString("See console. You should only see one message for each block")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionIssue1288
|
|
--------------------------------------
|
|
local function ActionIssue1288()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(0)
|
|
|
|
local spr = CCSprite:create("Images/grossini.png")
|
|
spr:setPosition(CCPoint(100, 100))
|
|
layer:addChild(spr)
|
|
|
|
local act1 = CCMoveBy:create(0.5, CCPoint(100, 0))
|
|
local act2 = act1:reverse()
|
|
local act3 = CCSequence:createWithTwoActions(act1, act2)
|
|
local act4 = CCRepeat:create(act3, 2)
|
|
|
|
spr:runAction(act4)
|
|
|
|
Helper.titleLabel:setString("Issue 1288")
|
|
Helper.subtitleLabel:setString("Sprite should end at the position where it started.")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionIssue1288_2
|
|
--------------------------------------
|
|
local function ActionIssue1288_2()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(0)
|
|
|
|
local spr = CCSprite:create("Images/grossini.png")
|
|
spr:setPosition(CCPoint(100, 100))
|
|
layer:addChild(spr)
|
|
|
|
local act1 = CCMoveBy:create(0.5, CCPoint(100, 0))
|
|
spr:runAction(CCRepeat:create(act1, 1))
|
|
|
|
Helper.titleLabel:setString("Issue 1288 #2")
|
|
Helper.subtitleLabel:setString("Sprite should move 100 pixels, and stay there")
|
|
return layer
|
|
end
|
|
|
|
--------------------------------------
|
|
-- ActionIssue1327
|
|
--------------------------------------
|
|
local function logSprRotation(sender)
|
|
cclog(""..sender:getRotation())
|
|
end
|
|
|
|
local function ActionIssue1327()
|
|
local layer = CCLayer:create()
|
|
initWithLayer(layer)
|
|
|
|
centerSprites(0)
|
|
|
|
local spr = CCSprite:create("Images/grossini.png")
|
|
spr:setPosition(CCPoint(100, 100))
|
|
layer:addChild(spr)
|
|
|
|
local act1 = CCCallFunc:create(logSprRotation)
|
|
local act2 = CCRotateBy:create(0.25, 45)
|
|
local act3 = CCCallFunc:create(logSprRotation)
|
|
local act4 = CCRotateBy:create(0.25, 45)
|
|
local act5 = CCCallFunc:create(logSprRotation)
|
|
local act6 = CCRotateBy:create(0.25, 45)
|
|
local act7 = CCCallFunc:create(logSprRotation)
|
|
local act8 = CCRotateBy:create(0.25, 45)
|
|
local act9 = CCCallFunc:create(logSprRotation)
|
|
|
|
local array = CCArray:create()
|
|
array:addObject(act1)
|
|
array:addObject(act2)
|
|
array:addObject(act3)
|
|
array:addObject(act4)
|
|
array:addObject(act5)
|
|
array:addObject(act6)
|
|
array:addObject(act7)
|
|
array:addObject(act8)
|
|
array:addObject(act9)
|
|
spr:runAction(CCSequence:create(array))
|
|
|
|
Helper.titleLabel:setString("Issue 1327")
|
|
Helper.subtitleLabel:setString("See console: You should see: 0, 45, 90, 135, 180")
|
|
return layer
|
|
end
|
|
|
|
function ActionsTest()
|
|
cclog("ActionsTest")
|
|
local scene = CCScene:create()
|
|
|
|
Helper.createFunctionTable = {
|
|
ActionManual,
|
|
ActionMove,
|
|
ActionScale,
|
|
ActionRotate,
|
|
ActionSkew,
|
|
ActionRotationalSkewVSStandardSkew,
|
|
ActionSkewRotate,
|
|
ActionJump,
|
|
ActionCardinalSpline,
|
|
ActionCatmullRom,
|
|
ActionBezier,
|
|
ActionBlink,
|
|
ActionFade,
|
|
ActionTint,
|
|
ActionAnimate,
|
|
ActionSequence,
|
|
ActionSequence2,
|
|
ActionSpawn,
|
|
ActionReverse,
|
|
ActionDelaytime,
|
|
ActionRepeat,
|
|
ActionRepeatForever,
|
|
ActionRotateToRepeat,
|
|
ActionRotateJerk,
|
|
ActionCallFunc,
|
|
ActionCallFuncND,
|
|
ActionReverseSequence,
|
|
ActionReverseSequence2,
|
|
ActionOrbit,
|
|
ActionFollow,
|
|
ActionTargeted,
|
|
PauseResumeActions,
|
|
ActionIssue1305,
|
|
ActionIssue1305_2,
|
|
ActionIssue1288,
|
|
ActionIssue1288_2,
|
|
ActionIssue1327
|
|
}
|
|
|
|
scene:addChild(ActionManual())
|
|
scene:addChild(CreateBackMenuItem())
|
|
|
|
return scene
|
|
end
|