← Back to branch summary

~libavg-team/mttroff/master

« back to all changes in this revision

Viewing changes to mttroff/troff.py

  • Committer: uzadow
  • Date: 2013-07-07 18:08:04 UTC
  • Revision ID: git-v1:14a04c24c35e86b3219c5f4877e188e581c54438
troff: Updated to current svn.

svn path=/trunk/avg_media/mtc/troff/; revision=9193

Show diffs side-by-side

added added

removed removed

Lines of Context:
mttroff/troff.py
18
18
# You should have received a copy of the GNU General Public License
19
19
# along with TROff. If not, see <http://www.gnu.org/licenses/>.
20
20
 
21
 
from libavg import avg, gameapp, Point2D
 
21
from libavg import avg, gameapp, Point2D, player
22
22
from libavg.utils import getMediaDir
23
23
from math import floor, ceil, pi
24
24
from random import choice, randint
30
30
IDLE_TIMEOUT = 10000
31
31
PLAYER_COLORS = ['00FF00', 'FF00FF', '00FFFF', 'FFFF00']
32
32
 
33
 
g_player = avg.Player.get()
34
33
g_gridSize = 4
35
34
 
36
35
 
37
 
#def logMsg(msg):
38
 
#    print '[%s] %s' %(g_player.getFrameTime(), msg)
39
 
 
40
 
 
41
36
class Button(object):
42
37
    def __init__(self, parent, color, icon, callback):
43
38
        w, h = parent.size
44
39
        if icon == '^': # 'clear player wins' button
45
40
            self.__node = avg.PolygonNode(pos=[(w, h), (0, h), (0, 0)])
46
41
        elif icon == '<': # 'turn left' button
47
 
            self.__node = avg.PolygonNode(pos=[(g_gridSize, 0), (w, 0), (w, h - g_gridSize)])
 
42
            self.__node = avg.PolygonNode(pos=[(g_gridSize, 0), (w, 0), 
 
43
                    (w, h - g_gridSize)])
48
44
        elif icon == '>': # 'turn right' button
49
 
            self.__node = avg.PolygonNode(pos=[(w - g_gridSize, h), (0, h), (0, g_gridSize)])
 
45
            self.__node = avg.PolygonNode(pos=[(w - g_gridSize, h), (0, h), 
 
46
                    (0, g_gridSize)])
50
47
        elif icon == '#': # 'clear all player wins' button
51
48
            # WinCounter size + some offset
52
49
            size = Point2D(g_gridSize * 44, g_gridSize * 44)
72
69
 
73
70
        self.__cursorID = None
74
71
        self.__callback = callback
75
 
        self.__node.setEventHandler(avg.CURSORDOWN, avg.MOUSE | avg.TOUCH, self.__onDown)
76
 
        self.__node.setEventHandler(avg.CURSORUP, avg.MOUSE | avg.TOUCH, self.__onUp)
 
72
        self.__node.subscribe(avg.Node.CURSOR_DOWN, self.__onDown)
 
73
        self.__node.subscribe(avg.Node.CURSOR_UP, self.__onUp)
77
74
 
78
75
    def activate(self):
79
76
        self.__node.fillopacity = 0.2 # needs libavg-r4503 bugfix to avoid crash
182
179
        triangle((s12, s12), (s34, s34), (s12, s1))
183
180
        triangle((s12, s1), (s34, s34), (s1, s1))
184
181
 
185
 
        resetButton = Button(self, color, '^', lambda: self.reset(True)).activate()
 
182
        self.__resetButton = Button(self, color, '^', lambda: self.reset(True))
 
183
        self.__resetButton.activate()
186
184
        self.__clearSound = avg.SoundNode(parent=self, href='clear.wav')
187
185
 
188
186
    @property
386
384
            super(IdlePlayer, self)._setDead(restart)
387
385
            self.__isRunning = False
388
386
        elif not self.__respawnTimoutID is None:
389
 
            g_player.clearInterval(self.__respawnTimoutID)
 
387
            player.clearInterval(self.__respawnTimoutID)
390
388
        if restart:
391
 
            self.__respawnTimoutID = g_player.setTimeout(randint(600, 1200), self.setReady)
 
389
            self.__respawnTimoutID = player.setTimeout(randint(600, 1200), self.setReady)
392
390
 
393
391
    def step(self):
394
392
        if not self.__isRunning:
461
459
        self.appendChild(self.__node)
462
460
 
463
461
        self.__cursorID = None
464
 
        self.setEventHandler(avg.CURSORDOWN, avg.MOUSE | avg.TOUCH, self._onDown)
465
 
        self.setEventHandler(avg.CURSORUP, avg.MOUSE | avg.TOUCH, self.__onUp)
466
 
        self.setEventHandler(avg.CURSORMOTION, avg.MOUSE | avg.TOUCH, self.__onMotion)
 
462
        self.subscribe(avg.Node.CURSOR_DOWN, self._onDown)
 
463
        self.subscribe(avg.Node.CURSOR_UP, self.__onUp)
 
464
        self.subscribe(avg.Node.CURSOR_MOTION, self.__onMotion)
467
465
 
468
466
    def activate(self):
469
467
        self.__active = True
568
566
        if self.__heading.x == 0:
569
567
            self.__heading.y = choice([-1, 1])
570
568
        self.__headingCountdown = randint(60, 120)
571
 
        self.__onFrameHandlerID = None
572
569
 
573
570
    def start(self):
574
 
        assert self.__onFrameHandlerID is None
575
 
        self.__onFrameHandlerID = g_player.setOnFrameHandler(self.__onFrame)
 
571
        player.subscribe(player.ON_FRAME, self.__onFrame)
576
572
 
577
573
    def stop(self):
578
 
        assert self.__onFrameHandlerID is not None
579
 
        g_player.clearInterval(self.__onFrameHandlerID)
580
 
        self.__onFrameHandlerID = None
 
574
        player.unsubscribe(player.ON_FRAME, self.__onFrame)
581
575
 
582
576
    def __onFrame(self):
583
577
        if self.__headingCountdown == 0:
601
595
class TROff(gameapp.GameApp):
602
596
    def init(self):
603
597
        global g_gridSize
604
 
        screenSize = g_player.getRootNode().size
 
598
        screenSize = player.getRootNode().size
605
599
        g_gridSize = int(min(floor(screenSize.x / BASE_GRIDSIZE.x),
606
600
                floor(screenSize.y / BASE_GRIDSIZE.y)))
607
601
        borderWidth = g_gridSize * BASE_BORDERWIDTH
671
665
                pos=self.__ctrlDiv.size / 2, r=self.__ctrlDiv.size.y / 4,
672
666
                opacity=0, sensitive=False)
673
667
 
674
 
        exitCallback = self.quit
675
 
        Button(self.__winsDiv, 'FF0000', 'xl', exitCallback).activate()
676
 
        Button(self.__winsDiv, 'FF0000', 'xr', exitCallback).activate()
 
668
        self.__leftQuitButton = Button(self.__winsDiv, 'FF0000', 'xl', self.quit)
 
669
        self.__leftQuitButton.activate()
 
670
        self.__rightQuitButton = Button(self.__winsDiv, 'FF0000', 'xr', self.quit)
 
671
        self.__rightQuitButton.activate()
677
672
 
678
673
        self.__redSound = avg.SoundNode(parent=battleground, href='red.wav')
679
674
        self.__yellowSound = avg.SoundNode(parent=battleground, href='yellow.wav')
680
675
        self.__greenSound = avg.SoundNode(parent=battleground, href='green.wav')
681
676
        self.__startSound = avg.SoundNode(parent=battleground, href='start.wav')
682
677
 
 
678
        self.__downHandlerID = None
683
679
        self.__preStart()
684
680
 
685
681
    def joinPlayer(self, player):
720
716
            avg.LinearAnim(self.__countdownNode, 'fillopacity', 1000, 1, 0).start()
721
717
            for c in self.__controllers:
722
718
                c.start()
723
 
            self.__onFrameHandlerID = g_player.setOnFrameHandler(self.__onGameFrame)
 
719
            player.subscribe(player.ON_FRAME, self.__onGameFrame)
724
720
        def goYellow():
725
721
            self.__yellowSound.play()
726
722
            self.__countdownNode.fillcolor = 'FFFF00'
752
748
            else:
753
749
                self.__preStart()
754
750
 
755
 
        g_player.clearInterval(self.__onFrameHandlerID)
 
751
        player.unsubscribe(player.ON_FRAME, self.__onGameFrame)
756
752
        self.__shield.deactivate()
757
753
        self.__blocker.deactivate()
758
 
        g_player.setTimeout(2000, restart)
 
754
        player.setTimeout(2000, restart)
759
755
 
760
756
    def __clearWins(self):
761
757
        self.__startSound.play()
811
807
 
812
808
    def __activateIdleTimer(self):
813
809
        assert self.__idleTimeoutID is None
814
 
        self.__idleTimeoutID = g_player.setTimeout(IDLE_TIMEOUT, self.__startIdleDemo)
815
 
        self.__ctrlDiv.setEventHandler(avg.CURSORDOWN, avg.MOUSE | avg.TOUCH,
 
810
        self.__idleTimeoutID = player.setTimeout(IDLE_TIMEOUT, self.__startIdleDemo)
 
811
        self.__downHandlerID = self.__ctrlDiv.subscribe(avg.Node.CURSOR_DOWN,
816
812
                lambda e:self.__restartIdleTimer())
817
813
 
818
814
    def __deactivateIdleTimer(self):
819
815
        assert self.__idleTimeoutID is not None
820
 
        g_player.clearInterval(self.__idleTimeoutID)
 
816
        player.clearInterval(self.__idleTimeoutID)
821
817
        self.__idleTimeoutID = None
822
 
        self.__ctrlDiv.setEventHandler(avg.CURSORDOWN, avg.MOUSE | avg.TOUCH, None)
 
818
        if self.__downHandlerID is not None:
 
819
            self.__ctrlDiv.unsubscribe(self.__downHandlerID)
823
820
 
824
821
    def __restartIdleTimer(self):
825
822
        if not self.__idleTimeoutID is None:
826
 
            g_player.clearInterval(self.__idleTimeoutID)
827
 
        self.__idleTimeoutID = g_player.setTimeout(IDLE_TIMEOUT, self.__startIdleDemo)
 
823
            player.clearInterval(self.__idleTimeoutID)
 
824
        self.__idleTimeoutID = player.setTimeout(IDLE_TIMEOUT, self.__startIdleDemo)
828
825
 
829
826
    def __startIdleDemo(self):
830
827
        self.__idleTimeoutID = None
832
829
        self.__ctrlDiv.sensitive = False
833
830
        for p in self.__idlePlayers:
834
831
            p.setReady()
835
 
        self.__gameDiv.setEventHandler(avg.CURSORDOWN, avg.MOUSE | avg.TOUCH,
 
832
        self.__demoDownHandlerID = self.__gameDiv.subscribe(avg.Node.CURSOR_DOWN,
836
833
                lambda e:self.__stopIdleDemo())
837
 
        self.__onFrameHandlerID = g_player.setOnFrameHandler(self.__onIdleFrame)
 
834
        player.subscribe(player.ON_FRAME, self.__onIdleFrame)
838
835
 
839
836
    def __stopIdleDemo(self):
840
 
        self.__gameDiv.setEventHandler(avg.CURSORDOWN, avg.MOUSE | avg.TOUCH, None)
841
 
        g_player.clearInterval(self.__onFrameHandlerID)
 
837
        self.__gameDiv.unsubscribe(self.__demoDownHandlerID)
 
838
        player.unsubscribe(player.ON_FRAME, self.__onIdleFrame)
842
839
        avg.fadeIn(self.__gameDiv, 200)
843
840
        self.__ctrlDiv.sensitive = True
844
841
        for p in self.__idlePlayers: