def startTimedAnim():
self.anim = avg.ParallelAnim([
avg.LinearAnim(self.nodes[0], "x", 200, 0, 60),
avg.LinearAnim(self.nodes[1], "x", 400, 0, 120),
], None, animStopped, 200)
self.__endCalled = False
self.anim.start()
def testNonExistentAttributeAnim(self):
self.initScene()
self.assertRaises(
Exception,
lambda: avg.LinearAnim(self.__node, "foo", 0, 0, 0, False))
self.assertRaises(Exception,
lambda: avg.LinearAnim(None, "x", 0, 0, 0, False))
def makeAnims():
avg.ParallelAnim([
avg.LinearAnim(self.__node, "x", 200, 0, 60),
avg.LinearAnim(self.__node, "y", 200, 0, 120)
]).start()
avg.LinearAnim(self.__node, "x", 300, 0, 100, False, None).start()
def startAnim():
self.anim = avg.ParallelAnim([
avg.LinearAnim(self.nodes[0], "x", 200, 0, 60),
avg.LinearAnim(self.nodes[1], "x", 400, 0, 120),
avg.EaseInOutAnim(self.nodes[2], "x", 400, 0, 120, 100, 100)
], None, animStopped)
self.__endCalled = False
self.anim.start()
def isFound(self, event):
# wenn die Fehler-Stelle im Bild angetippt wird, wird ein roter Kreis an dieser Stelle eingeblendet
avg.fadeIn(event.node, 500)
avg.LinearAnim(event.node, "pos", 500, (event.node.pos.x +event.node.size.x/2, event.node.pos.y+event.node.size.y/2), (event.node.pos.x,event.node.pos.y) ).start()
avg.LinearAnim(event.node, "size", 500, (0,0), (event.node.size.x,event.node.size.y) ).start()
self.level.mistakecounter = self.level.mistakecounter +1 # Fehlercounter wird um 1 erhoeht
#self.level.mistakefound.text = str(self.level.mistakecounter)
self.level.mistakedisplay.text = "Fehler "+ str(self.level.mistakecounter) + "/"+ str(self.level.mistakesum)
self.found = True # found feld wird auf true gesetzt (spaeter wichitg fuer Abrage ob alle Fehler gefunden sind)
self.sensitive = False # Fehler wird "deaktiviert" damit der Counter nicht durch eine Stelle immer wieder erhoeht werden kann
def _onUp(self, event):
def gone(self):
BaseTouchVisualization._onUp(self, event)
self.unlink(True)
del self
avg.fadeIn(self.__circle, 100, 1)
avg.LinearAnim(self.__circle, "size", 100, self.__circle.size, (4,4)).start()
avg.LinearAnim(self.__circle, "pos", 100, self.__circle.pos, (-2,-2)).start()
player.setTimeout(100, lambda: gone(self))
def makeAnim():
self.anim = avg.StateAnim([
avg.AnimState(
"STATE1",
avg.LinearAnim(self.__node, "x", 200, 0, 100, False, None,
state1StopCallback), "STATE2"),
avg.AnimState(
"STATE2",
avg.LinearAnim(self.__node, "x", 200, 100, 50, False,
state2StartCallback), "STATE3"),
avg.AnimState("STATE3", avg.WaitAnim())
])
def testNonNodeAttrAnim(self):
class GenericClass(object):
def __init__(self):
self.numberValue = 0
self.pointValue = avg.Point2D(0.0, 0.0)
def on1Stop():
self.__onStopCalled = True
def on2Start():
self.__onStopBeforeOnStart = self.__onStopCalled
self.loadEmptyScene()
player.setFakeFPS(10)
genericObject1 = GenericClass()
genericObject2 = genericObject1
genericObject3 = GenericClass()
anim1 = avg.LinearAnim(genericObject1, "numberValue", 1000, 0, 100,
False, None, on1Stop)
anim2 = avg.LinearAnim(genericObject2, "numberValue", 1200, 0, 200,
False, on2Start)
anim3 = avg.LinearAnim(genericObject1, "pointValue", 800, (0, 0),
(100, 200))
anim4 = avg.LinearAnim(genericObject3, "numberValue", 400, 0, 42)
self.__onStopCalled = False
self.__onStopBeforeOnStart = False
self.start(
False,
(lambda: anim1.start(), lambda: self.assert_(anim1.isRunning()),
lambda: self.assert_(not (self.__onStopCalled)),
lambda: anim2.start(),
lambda: self.assert_(self.__onStopBeforeOnStart),
lambda: self.assert_(not (anim1.isRunning())),
lambda: self.assert_(anim2.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 1),
lambda: anim3.start(), lambda: self.assert_(anim2.isRunning()),
lambda: self.assert_(anim3.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 2),
lambda: anim4.start(), lambda: self.assert_(anim4.isRunning()),
lambda: self.assertEqual(avg.getNumRunningAnims(), 3),
lambda: self.delay(200),
lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
lambda: self.assert_(genericObject1.numberValue == 200),
lambda: self.assert_(genericObject2.pointValue == (100, 200)),
lambda: self.assert_(genericObject3.numberValue == 42)))
anim1 = None
anim2 = None
anim3 = None
anim4 = None
genericObject1 = None
genericObject2 = None
genericObject3 = None
def testIntAnim(self):
self.initScene()
self.__doubleAnim = avg.LinearAnim(self.__node, "x", 300, 0, 100, True)
self.__pointAnim = avg.LinearAnim(self.__node, "pos", 200,
avg.Point2D(0, 0),
avg.Point2D(100, 40), True)
self.start(False, (
self.__doubleAnim.start,
lambda: self.delay(100),
lambda: self.compareImage("testIntAnim1"),
self.__doubleAnim.abort,
self.__pointAnim.start,
lambda: self.delay(100),
lambda: self.compareImage("testIntAnim2"),
))
def testContinuousAnim(self):
def startAnim():
self.__animStarted = True
def stopAnim():
self.__animStopped = True
def reset():
self.__animStarted = False
self.__animStopped = False
self.initScene()
self.__anim = avg.ContinuousAnim(self.__node, "angle", 0, 2 * math.pi,
False, startAnim, stopAnim)
self.__linearAnim = avg.LinearAnim(self.__node, "angle", 1000, math.pi,
math.pi)
self.__animStarted = False
self.__animStopped = False
self.start(False, (
self.__anim.start,
lambda: self.assert_(self.__animStarted),
lambda: self.compareImage("testContinuousAnim1"),
self.__anim.abort,
lambda: self.assert_(self.__animStopped),
reset,
self.__anim.start,
self.__linearAnim.start,
lambda: self.assert_(self.__animStopped),
lambda: self.compareImage("testContinuousAnim2"),
self.__linearAnim.abort,
))
def __updateImages(self):
s = self.__score
for img in self.__images:
y = s % 10 * -34
if img.y != y:
avg.LinearAnim(img, 'y', 250, img.y, y).start()
s /= 10
def __init__(self, event, **kwargs):
BaseTouchVisualization.__init__(self, event, **kwargs)
self.positions = [event.pos]
if event.source == avg.Event.TOUCH:
color = 'e5d8d8'
elif event.source == avg.Event.TANGIBLE:
color = 'ffe0e0'
else:
color = 'd8e5e5'
self.opacity = 0.5
self.__transparentCircle = avg.CircleNode(r=self._radius + 20,
fillcolor=color,
fillopacity=0.2,
opacity=0.0,
strokewidth=1,
sensitive=False,
parent=self)
self.__pulsecircle = avg.CircleNode(r=self._radius,
fillcolor=color,
color=color,
fillopacity=0.5,
opacity=0.5,
strokewidth=1,
sensitive=False,
parent=self)
if event.source in [avg.Event.TOUCH, avg.Event.TRACK]:
self.__majorAxis = avg.LineNode(pos1=(0, 0),
pos2=event.majoraxis,
color='FFFFFF',
sensitive=False,
parent=self)
self.__minorAxis = avg.LineNode(pos1=(0, 0),
pos2=event.minoraxis,
color='FFFFFF',
sensitive=False,
parent=self)
if event.source == avg.Event.TOUCH:
self.__handAxis = avg.LineNode(pos1=(0, 0),
pos2=self.__getHandVector(event),
opacity=0.5,
color='A0FFA0',
sensitive=False,
parent=self)
fontPos = avg.Point2D(self.__pulsecircle.r, 0)
self.__textNode = avg.WordsNode(pos=fontPos, fontsize=9, parent=self)
self.motionPath = avg.PolyLineNode(pos=self.positions,
opacity=0.7,
color=color,
parent=kwargs['parent'])
self.motionVector = avg.LineNode(pos1=(0, 0),
pos2=-event.contact.motionvec,
opacity=0.4,
parent=self)
pulseCircleAnim = avg.LinearAnim(self.__pulsecircle, 'r', 200, 50,
self._radius)
pulseCircleAnim.start()
def show(self):
s = self.getMediaSize()
assert s.x and s.y
# initial size and position (scaled to screen size and centered)
self.size = scaleMax(s, self.parent.size)
self.pos = (self.parent.size - self.size) * 0.5
# random final size and position (center moved by (dx, dy) and scaled up accordingly)
dx = float(randint(-ANIM_MAX_MOVE, ANIM_MAX_MOVE))
dy = float(randint(-ANIM_MAX_MOVE, ANIM_MAX_MOVE))
size = scaleMin(s, self.size + avg.Point2D(abs(dx), abs(dy)) * 2.0)
pos = self.pos + avg.Point2D(dx, dy) + (self.size - size) * 0.5
# start in-transition
avg.Anim.fadeIn(self, TRANS_INTERVAL)
# start move/scale animation
avg.ParallelAnim([
avg.LinearAnim(self, 'size', ANIM_INTERVAL, self.size, size),
avg.LinearAnim(self, 'pos', ANIM_INTERVAL, self.pos, pos)]).start()
def __unflash(self):
anim = avg.LinearAnim(
node=self.__node,
attrName="fillopacity",
duration=200,
startValue=1.0,
endValue=0.0,
)
anim.start()
def flash(self):
# print "flash"
self.__node.fillcolor = 'bfd571'
anim = avg.LinearAnim(node=self.__node,
attrName="fillopacity",
duration=200,
startValue=0.0,
endValue=1.0,
stopCallback=self.__unflash)
anim.start()
def __init__(self, event, **kwargs):
BaseTouchVisualization.__init__(self, event, **kwargs)
if event.source in self.sources:
self.__circle = avg.ImageNode(parent=self)
self.__circle.setBitmap(self.bmp)
self.__setRadius(self._radius)
avg.LinearAnim(self.__circle, "opacity", 200, 0.7, 0.4).start()
else:
self.unlink(True)
self._abort()
def testAnimRegistry(self):
def on1Stop():
self.__onStopCalled = True
def on2Start():
self.__onStopBeforeOnStart = self.__onStopCalled
self.initScene()
sameNode = player.getElementByID("test")
anim1 = avg.LinearAnim(self.__node, "x", 500, 0, 100, False, None,
on1Stop)
anim2 = avg.LinearAnim(sameNode, "x", 300, 0, 100, False, on2Start)
self.__onStopCalled = False
self.__onStopBeforeOnStart = False
self.start(False,
(lambda: anim1.start(),
lambda: self.assert_(not (self.__onStopCalled)),
lambda: anim2.start(),
lambda: self.assert_(self.__onStopBeforeOnStart),
lambda: self.assertEqual(avg.getNumRunningAnims(), 1)))
anim1 = None
anim2 = None
def testLinearAnimZeroDuration(self):
def onStop():
self.__onStopCalled = True
def startAnim():
self.__onStopCalled = False
self.__anim.start()
self.initScene()
self.__anim = avg.LinearAnim(self.__node, "x", 0, 0, 100, False, None,
onStop)
self.__onStopCalled = False
self.start(False,
(startAnim,
lambda: self.compareImage("testLinearAnimZeroDurationC1"),
lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
lambda: self.assert_(self.__onStopCalled),
lambda: self.assert_(not (self.__anim.isRunning()))))
self.__anim = None
def testPointAnim(self):
def startAnim():
self.__anim.start()
def startKeepAttr():
self.__node.pos = (50, 20)
self.__anim.start(True)
self.initScene()
self.__anim = avg.LinearAnim(self.__node, "pos",
200, avg.Point2D(0, 0),
avg.Point2D(100, 40), False)
self.start(False, (
startAnim,
lambda: self.compareImage("testPointAnim1"),
lambda: self.compareImage("testPointAnim2"),
None,
lambda: self.assert_(not (self.__anim.isRunning())),
startKeepAttr,
lambda: self.compareImage("testPointAnim3"),
))
def _testPointAnim(self, startPos, endPos, keepAttrPos, startPosImgSrc,
endPosImgSrc, keepAttrPosImgSrc):
def startAnim():
self.__anim.start()
def startKeepAttr():
self.__node.pos = keepAttrPos
self.__anim.start(True)
self.initScene()
self.__anim = avg.LinearAnim(self.__node, "pos", 200,
avg.Point2D(startPos),
avg.Point2D(endPos), False)
self.start(False, (
startAnim,
lambda: self.compareImage(startPosImgSrc),
lambda: self.compareImage(endPosImgSrc),
None,
lambda: self.assert_(not (self.__anim.isRunning())),
startKeepAttr,
lambda: self.compareImage(keepAttrPosImgSrc),
))
def back():
anim = avg.LinearAnim(self.__node, 'pos', 100, (100, 100),
(50, 100), False, None, forth)
anim.start()
def testLinearAnim(self):
self.initScene()
curAnim = avg.LinearAnim(self.__node, "x", 300, 0, 100)
self.testAnimType(curAnim, "testLinearAnimC")
def reset(self):
self.__score = 0
for img in self.__images:
if img.y != 0:
avg.LinearAnim(img, 'y', 250, img.y, 0).start()
def startFireForgetAnim():
avg.ParallelAnim([
avg.LinearAnim(self.nodes[0], "x", 200, 0, 60),
avg.LinearAnim(self.nodes[1], "x", 200, 0, 120)
]).start()
