def __filteredRelContactPos(self, contact):
rawPos = self.__relContactPos(contact)
if self.__isFiltered():
f = self.__filters[contact]
return avg.Point2D(f[0].apply(rawPos.x, player.getFrameTime()),
f[1].apply(rawPos.y, player.getFrameTime()))
else:
return rawPos
def __filteredRelContactPos(self, contact):
rawPos = self.__relContactPos(contact)
if self.__isFiltered():
f = self.__filters[contact]
return avg.Point2D(f[0].apply(rawPos.x, player.getFrameTime()),
f[1].apply(rawPos.y, player.getFrameTime()))
else:
return rawPos
def __moveContact(self):
time = player.getFrameTime()
rawPos = self.__contact.events[-1].pos
self.__rawContactCircle.pos = rawPos
filteredPos = avg.Point2D(self.__filters[0].apply(rawPos.x, time),
self.__filters[1].apply(rawPos.y, time))
self.__filteredContactCircle.pos = filteredPos
def __moveContact(self):
time = player.getFrameTime()
rawPos = self.__contact.events[-1].pos
self.__rawContactCircle.pos = rawPos
filteredPos = avg.Point2D(self.__filters[0].apply(rawPos.x, time),
self.__filters[1].apply(rawPos.y, time))
self.__filteredContactCircle.pos = filteredPos
def __on_cursor_down(self, event):
"""
:type event: avg.CursorEvent
"""
if event.cursorid in self.__down_events:
return
self.__down_events[event.cursorid] = player.getFrameTime()
def __on_cursor_up(self, event):
"""
:type event: avg.CursorEvent
"""
if event.cursorid not in self.__down_events:
return
start_time = self.__down_events.pop(event.cursorid)
if player.getFrameTime() - start_time <= CommonRecognizerDefaults.TAP_MAX_TIME:
if event.contact.distancefromstart <= CommonRecognizerDefaults.TAP_MAX_DIST:
self.dispatch(self.__CLICKED, sender=self, event=event)
def __on_swipe_up(self):
"""
Called when a swipe to the right was recognized.
"""
if self.__hold_active or self.__double_tap_hold_active:
return
event_time = player.getFrameTime() - self.__event_time
if event_time > self.__device_pointer_config.swipe_max_time:
return
StudyLog.get_instance().write_device_canvas_event(
self.__device, "SWIPE UP")
self.dispatch(self.__SWIPE, sender=self, direction=SwipeRecognizer.UP)
def __on_cursor_down(self, event):
"""
Called when a cursor down was recognized on this view.
:type event: CursorEvent
"""
StudyLog.get_instance().write_device_canvas_touch(
self.__device, "CURSOR DOWN", event)
self.dispatch(self.__CURSOR_DOWN, sender=self, event=event)
if self.__event:
return
self.__event = event
self.__event_id = event.cursorid
if player.getFrameTime(
) - self.__last_tap_time < self.__device_pointer_config.double_tap_hold_max_time:
self.__double_tap_hold_active = True
StudyLog.get_instance().write_device_canvas_event(
self.__device, "DOUBLE TAP HOLD")
self.dispatch(self.__DOUBLE_TAP_HOLD, sender=self, event=event)
else:
self.__event_time = player.getFrameTime()
self.__event_movement_dist = 0
def _handleUp(self, event):
if self.__stateMachine.state == "DOWN1":
self.__startTime = player.getFrameTime()
self.__stateMachine.changeState("UP1")
elif self.__stateMachine.state == "DOWN2":
if ((event.pos - self.__startPos).getNorm() >
self.__maxDist*player.getPixelsPerMM()):
self._setFail(event)
else:
self._setDetected(event)
self.__stateMachine.changeState("IDLE")
elif self.__stateMachine.state == "IDLE":
pass
else:
assert(False), self.__stateMachine.state
def __init__(self, pos, icon, waitTime):
if (self.__class__ in self.spawnTimestamp and
player.getFrameTime() - self.spawnTimestamp[self.__class__] < waitTime):
return
else:
self.spawnTimestamp[self.__class__] = player.getFrameTime()
self._state = self.STATE_BUSY
self._tmr = player.setInterval(100, self.__tick)
self._remainingTicks = consts.BONUS_AVAILABILITY_TICKS
self._node = widgets.RIImage(href=icon, pos=pos, parent=self.layer)
diman = avg.LinearAnim(self._node, 'size', self.TRANSITION_TIME,
self._node.getMediaSize() * self.TRANSITION_ZOOM,
self._node.getMediaSize())
opaan = avg.LinearAnim(self._node, 'opacity',
self.TRANSITION_TIME, 0, self.OPACITY)
offsan = avg.LinearAnim(self._node, 'pos', self.TRANSITION_TIME,
Point2D(pos) - self._node.getMediaSize() * self.TRANSITION_ZOOM / 2, pos)
self._anim = avg.ParallelAnim((diman, opaan, offsan), None, self.__ready)
self._anim.start()
self.__cursorid = None
engine.SoundManager.play('bonus_alert.ogg')
def _handleUp(self, event):
if self.__stateMachine.state == "DOWN1":
self.__startTime = player.getFrameTime()
self.__stateMachine.changeState("UP1")
elif self.__stateMachine.state == "DOWN2":
if ((event.pos - self.__startPos).getNorm() >
self.__maxDist*player.getPixelsPerMM()):
self._setFail(event)
else:
self._setDetected(event)
self.__stateMachine.changeState("IDLE")
elif self.__stateMachine.state == "IDLE":
pass
else:
assert(False), self.__stateMachine.state
def _handleDown(self, event):
self.__startTime = player.getFrameTime()
if self.__stateMachine.state == "IDLE":
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame)
self.__stateMachine.changeState("DOWN1")
self.__startPos = event.pos
self._setPossible(event)
elif self.__stateMachine.state == "UP1":
if ((event.pos - self.__startPos).getNorm() >
self.__maxDist*player.getPixelsPerMM()):
self.__stateMachine.changeState("IDLE")
self._setFail(event)
else:
self.__stateMachine.changeState("DOWN2")
else:
assert(False), self.__stateMachine.state
def _handleDown(self, event):
self.__startTime = player.getFrameTime()
if self.__stateMachine.state == "IDLE":
self.__frameHandlerID = player.subscribe(player.ON_FRAME, self.__onFrame)
self.__stateMachine.changeState("DOWN1")
self.__startPos = event.pos
self._setPossible(event)
elif self.__stateMachine.state == "UP1":
if ((event.pos - self.__startPos).getNorm() >
self.__maxDist*player.getPixelsPerMM()):
self.__stateMachine.changeState("IDLE")
self._setFail(event)
else:
self.__stateMachine.changeState("DOWN2")
else:
assert(False), self.__stateMachine.state
def on_frame(self):
"""
Needed to be called every frame.
"""
if not self.__event:
return
if self.__double_tap_hold_active or self.__hold_active:
return
now = player.getFrameTime()
down_time = now - self.__event_time
if down_time <= self.__device_pointer_config.hold_delay:
return
if self.__event_movement_dist > self.__device_pointer_config.hold_max_dist * player.getPixelsPerMM(
):
return
else:
self.__hold_active = True
StudyLog.get_instance().write_device_canvas_event(
self.__device, "HOLD")
self.dispatch(self.__HOLD, sender=self, event=self.__event)
def nextWave(self):
Missile.speedMul = 1 + (app.instance.mainDiv.difficultyLevel - 1) * consts.SPEEDMUL_OFFSET_LEVEL
self.nukeFired = False
self.__wave += 1
nenemies = int(self.__wave * consts.ENEMIES_WAVE_MULT * \
(1 + app.instance.mainDiv.difficultyLevel * 0.2))
self.__createSpawnTimeline(nenemies)
self.__enemiesGone = 0
self.gameData['initialEnemies'] = nenemies
slots = [Point2D(x * engine.norm.x(consts.SLOT_WIDTH), engine.norm.size.y - \
engine.norm.y(60))
for x in xrange(1,
int(engine.norm.size.x/engine.norm.x(consts.SLOT_WIDTH) + 1))]
random.shuffle(slots)
self.gameData['initialAmmo'] = int(nenemies * consts.AMMO_ENEMIES_MULT)
self.gameData['initialCities'] = consts.CITIES
for i in xrange(0, consts.TURRETS_AMOUNT):
Turret(slots.pop(), float(self.gameData['initialAmmo']) /
consts.TURRETS_AMOUNT)
for c in xrange(0, self.gameData['initialCities']):
City(slots.pop())
self.__ammoGauge.setColor(consts.COLOR_BLUE)
self.__ammoGauge.setFVal(1)
self.__enemiesGauge.setFVal(1)
self.playTeaser('Wave %d' % self.__wave)
self.__waveTimer = player.getFrameTime()
self.__changeGameState(self.GAMESTATE_PLAYING)
logger.info('Entering wave %d: %s' % (self.__wave, str(self.gameData)))
def _onFrame(self):
downTime = player.getFrameTime() - self.__startTime
if self.getState() == "POSSIBLE":
if self.__maxTime and downTime > self.__maxTime:
self._setFail(None)
super(TapRecognizer, self)._onFrame()
def checkTime():
self.assertEqual(player.getFrameTime(), 50)
self.assertEqual(player.getFrameDuration(), 50)
self.assertEqual(player.getEffectiveFramerate(), 20)
def checkTime():
self.assertEqual(player.getFrameTime(), 50)
self.assertEqual(player.getFrameDuration(), 50)
self.assertEqual(player.getEffectiveFramerate(), 20)
def onFrame(self):
self._text.text = '%06d' % player.getFrameTime()
self._rect.angle += player.getFrameDuration() * 0.001
def onFrame(self):
self.warpedImage.angle = math.sin(player.getFrameTime() / 1000.)
def _onFrame(self):
downTime = player.getFrameTime() - self.__startTime
if self.getState() == "POSSIBLE":
if downTime > self.__delay:
self._setDetected(self.__lastEvent)
super(HoldRecognizer, self)._onFrame()
def __onFrame(self):
downTime = player.getFrameTime() - self.__startTime
if downTime > self.__maxTime:
self._setFail(None)
self.__stateMachine.changeState("IDLE")
def _handleDown(self, event):
self.__lastEvent = event
self._setPossible(event)
self.__startTime = player.getFrameTime()
def __onFrame(self):
downTime = player.getFrameTime() - self.__startTime
if downTime > self.__maxTime:
self._setFail(None)
self.__stateMachine.changeState("IDLE")
def _onFrame(self):
downTime = player.getFrameTime() - self.__startTime
if self.getState() == "POSSIBLE":
if self.__maxTime and downTime > self.__maxTime:
self._setFail(None)
super(TapRecognizer, self)._onFrame()
def onFrame(self):
self.warpedImage.angle = math.sin(player.getFrameTime()/1000.)
def _handleDown(self, event):
self.__lastEvent = event
self._setPossible(event)
self.__startTime = player.getFrameTime()
def _debug(cls, msg):
print '%6d [%s] %s' % (player.getFrameTime(), cls.__name__, msg)
def __on_tap(self):
"""
Called when a tap event has occurred.
"""
self.__last_tap_time = player.getFrameTime()
StudyLog.get_instance().write_device_canvas_event(self.__device, "TAP")
def _debug(cls, msg):
print '%6d [%s] %s' %(player.getFrameTime(), cls.__name__, msg)
def _onFrame(self):
downTime = player.getFrameTime() - self.__startTime
if self.getState() == "POSSIBLE":
if downTime > self.__delay:
self._setDetected(self.__lastEvent)
super(HoldRecognizer, self)._onFrame()
def __onFrame(self):
if self.__currentState:
dt = player.getFrameTime() - self.__elapsedTime
self.__currentState.update(dt)
self.__elapsedTime = player.getFrameTime()
def __getWaveTime(self):
return player.getFrameTime() - self.__waveTimer
def onFrame(self):
dt = player.getFrameTime() - self.__elapsedTime
self.sequencer.update(dt)
self.__elapsedTime = player.getFrameTime()
