Some lamps

PlayerState.py

@@ -8,20 +8,33 @@ import config
 from lamps.Lamp import Lamp
 from lamps.LampGroup import CHAMP_LAMPS
 from lamps.LampGroup import UPPER_PLAYFIELD_TIME_LAMPS
+from lamps.LampGroup import TUNNEL_NUMBER_LAMPS
+from lamps.LampGroup import TUNNEL_LAMPS
+from lamps.LampGroup import TUNNEL_SCORE_LAMPS
 from lamps.LampGroup import BONUS_MULTIPLIER_LAMPS
 from lamps.LampGroup import BONUS_LAMPS
 
 from events.LeaveUpperPlayfieldEvent import LeaveUpperPlayfieldEvent
 
+TUNNEL_SCORES = [20000, 30000, 50000]
+BONUS_MULTIPLIER = [1, 10, 20, 50]
+UPPER_PLAYFIELD_TIME = [5, 10, 20, 30]
+
+
 class PlayerState:
     display = None
     specialDisplay = None
     id = 0
     points = 0
     bonus = 0
+    bonusMultiplierIter = iter(BONUS_MULTIPLIER)
     bonusMultiplier = 1
+    tunnelScoreIter = iter(TUNNEL_SCORES)
+    tunnelScore = 0
+    tunnelLit = 0
     ballsLeft = 0
     replayBall = False
+    hasBallScored = False
 
     redSpecial = 0
     redSpecialLit = False
@@ -36,6 +49,7 @@ class PlayerState:
     timeAdvanceRightTimer = None
 
     upperPlayfieldTimer = None
+    upperPlayfieldTimeIter = iter(UPPER_PLAYFIELD_TIME)
     upperPlayfieldTime = 0
 
     def __init__(self, display, specialDisplay, id, ballsToPlay):
@@ -103,15 +117,18 @@ class PlayerState:
 
     def reset(self):
         self.upperPlayfieldTimer = None
+        self.upperPlayfieldTimeIter = iter(UPPER_PLAYFIELD_TIME)
+        self.upperPlayfieldTime = next(self.upperPlayfieldTimeIter)
         self.replayBall = False
-        self.upperPlayfieldTime = config.BEGINNING_UPPER_PLAYFIELD_TIME
+        self.hasBallScored = False
 
         self.resetBonus()
         self.resetTargets()
 
     def resetBonus(self):
         self.bonus = 0
-        self.bonusMultiplier = 1
+        self.bonusMultiplierIter = iter(BONUS_MULTIPLIER)
+        self.bonusMultiplier = next(self.bonusMultiplierIter)
         BONUS_LAMPS.deactivate()
         BONUS_MULTIPLIER_LAMPS.deactivate()
 
@@ -133,7 +150,12 @@ class PlayerState:
         Lamp("Special Orange").deactivate()
 
     def resetTunnel(self):
+        self.tunnelScoreIter = iter(TUNNEL_SCORES)
+        self.tunnelScore = next(self.tunnelScoreIter)
         self.tunnelLit = 0
+        TUNNEL_SCORE_LAMPS.deactivate()
+        TUNNEL_SCORE_LAMPS.activateNext()
+        TUNNEL_LAMPS.deactivate()
 
     def advanceRightOrangeSpecial(self):
         self.orangeSpecialRight = True
@@ -152,18 +174,33 @@ class PlayerState:
         if self.orangeSpecialLit:
             Lamp("Special Orange").activate()
 
-
     def advanceRedSpecial(self):
         self.redSpecial += 1
         CHAMP_LAMPS.activateNext()
 
-        if(self.redSpecial == config.RED_SPECIAL_TIMES):
+        if self.redSpecial == config.RED_SPECIAL_TIMES:
             self.redSpecialLit = True
             Lamp("Special Red").activate()
 
+    def advanceTunnelScore(self):
+        try:
+            self.tunnelScore = next(self.tunnelScoreIter)
+            TUNNEL_SCORE_LAMPS.deactivateCurrent()
+            TUNNEL_SCORE_LAMPS.currentLamp += 1 # dirty
+            TUNNEL_SCORE_LAMPS.activateNext()
+        except StopIteration:
+            pass
+
     def advanceTunnel(self):
-        if self.tunnelLit <= 5:
-            self.tunnelLit += 1
+        if self.tunnelLit == 5:
+            self.advanceTunnelScore()
+            TUNNEL_LAMPS.deactivate()
+            TUNNEL_NUMBER_LAMPS.deactivate()
+            return
+
+        self.tunnelLit += 1
+        TUNNEL_LAMPS.activateNext()
+        TUNNEL_NUMBER_LAMPS.activateNext()
 
     def advanceBonus(self):
         if self.bonus >= 20:
@@ -173,22 +210,20 @@ class PlayerState:
         BONUS_LAMPS.activateNext()
 
     def advanceBonusMultiplier(self):
-        if self.bonusMultiplier >= 15:
-            return
+        try:
+            self.bonusMultiplier = next(self.bonusMultiplierIter)
+            BONUS_MULTIPLIER_LAMPS.activateNext()
+        except StopIteration:
+            pass
 
-        if self.bonusMultiplier == 1:
-            self.bonusMultiplier = 10
-        elif self.bonusMultiplier == 10:
-            self.bonusMultiplier = 20
-        elif self.bonusMultiplier == 20:
-            self.bonusMultiplier == 50
-
-        BONUS_MULTIPLIER_LAMPS.activateNext()
 
     def setReplayBall(self):
         self.replayBall = True
 
     def addPoints(self, points):
+        if not self.hasBallScored:
+            self.hasBallScored = True
+
         self.points += points
         self.display.printScore(self.points)
 
@@ -204,16 +239,11 @@ class PlayerState:
         self.specialDisplay.printBallsToPlay(self.ballsLeft)
 
     def advanceUpperPlayfieldTime(self):
-        if self.upperPlayfieldTime == 0:
-            self.upperPlayfieldTime = 5
-        elif self.upperPlayfieldTime == 5:
-            self.upperPlayfieldTime = 10
-        elif self.upperPlayfieldTime == 10:
-            self.upperPlayfieldTime = 20
-        elif self.upperPlayfieldTime == 20:
-            self.upperPlayfieldTime = 30
-
-        UPPER_PLAYFIELD_TIME_LAMPS.activateNext()
+        try:
+            self.upperPlayfieldTime = next(self.upperPlayfieldTimeIter)
+            UPPER_PLAYFIELD_TIME_LAMPS.activateNext()
+        except StopIteration:
+            pass
 
     def startUpperPlayfieldTimer(self):
         self.upperPlayfieldTimer = Timer(1, self.updatePlayfieldTime)
@@ -221,7 +251,7 @@ class PlayerState:
     def updatePlayfieldTime(self):
         if self.upperPlayfieldTime == 0:
             self.upperPlayfieldTimer = None
-            LeaveUpperPlayfieldEvent(self, )
+            LeaveUpperPlayfieldEvent(self)
             return
 
         if self.upperPlayfieldTime in [0, 5, 10, 20]:

events/BankEvent.py

@@ -10,7 +10,3 @@ class BankEvent(Event):
     def trigger(self, target):
         super().trigger(target)
         self.bankSolenoid.trigger()
-        self.advanceBonus()
-
-    def advanceBonus(self):
-        self.playerState().advanceBonus()

events/BonusEvent.py

@@ -0,0 +1,11 @@
+from Event import Event
+
+
+class BonusEvent(Event):
+    def __init__(self, playerState):
+        self.playerState = playerState
+        super().__init__("Bonus Event")
+
+    def trigger(self, target):
+        super().trigger(target)
+        self.playerState.advanceBonus()

events/EndBallEvent.py

@@ -11,7 +11,7 @@ class EndBallEvent(Event):
 
     def trigger(self, target):
         super().trigger(target)
-        if self.playerState.replayBall:
+        if self.playerState.replayBall or not self.playerState.hasBallScored:
             StartBallEvent().trigger(None)
             return
 

factories/EventFactory.py

@@ -18,7 +18,30 @@ from events.RedSpecialEvent import RedSpecialEvent
 from events.OrangeSpecialEvent import OrangeSpecialEvent
 from events.SpinnerEvent import SpinnerEvent
 from events.FixedTargetEvent import FixedTargetEvent
+from events.BonusEvent import BonusEvent
 
+BONUS_EVENT_TARGETS = [
+    "Left Inlane",
+    "Right Inlane",
+    "Right Outlane Kicker",
+    "Canal Button Bottom",
+    "Canal Button Middle Bottom",
+    "Canal Button Middle Top",
+    "Canal Button Top",
+    "Fixed Target 1",
+    "Fixed Target 2",
+    "Fixed Target 3",
+    "Fixed Target 4",
+    "Fixed Target 5",
+    "Left Bank Left",
+    "Left Bank Middle Left",
+    "Left Bank Middle Right",
+    "Left Bank Right",
+    "Right Bank Left",
+    "Right Bank Middle",
+    "Right Bank Right",
+
+]
 class EventFactory:
     def __init__(self, targets, currentPlayer):
         self.targets = targets
@@ -123,5 +146,13 @@ class EventFactory:
         self.__registerEventToTarget(event, self.targets["Fixed Target 5"])
         return event
 
+    def createBonusEvent(self):
+        event = BonusEvent(self.currentPlayer)
+        self.__registerEventToTargets(event, BONUS_EVENT_TARGETS)
+
+    def __registerEventToTargets(self, event, targetNames):
+        for targetName in targetNames:
+            self.__registerEventToTarget(event, self.targets[targetName])
+
     def __registerEventToTarget(self, event, target):
         target.on(target.hit_key, event.trigger)

lamps/LampGroup.py

@@ -12,6 +12,8 @@ class LampGroup:
             lamp.activate()
 
     def deactivate(self):
+        self.currentLamp = 0
+
         for lamp in self.lamps:
             lamp.deactivate()
 
@@ -46,6 +48,27 @@ UPPER_PLAYFIELD_TIME_LAMPS = LampGroup([
     Lamp("Lamp 30 Sec")
 ])
 
+TUNNEL_NUMBER_LAMPS = LampGroup([
+    Lamp("Lamp 1"),
+    Lamp("Lamp 2"),
+    Lamp("Lamp 3"),
+    Lamp("Lamp 4"),
+    Lamp("Lamp 5"),
+])
+TUNNEL_LAMPS = LampGroup([
+    Lamp("1st Button"),
+    Lamp("2nd Button"),
+    Lamp("3rd Button"),
+    Lamp("4th Button"),
+    Lamp("5th Button")
+])
+
+TUNNEL_SCORE_LAMPS = LampGroup([
+    Lamp("Tunnel Lamp 20000 Points"),
+    Lamp("Tunnel Lamp 30000 Points"),
+    Lamp("Tunnel Lamp 50000 Points")
+])
+
 BONUS_MULTIPLIER_LAMPS = LampGroup([
     Lamp("Bonus Multiplier x10"),
     Lamp("Bonus Multiplier x20"),