Very much done

.gitignore

@@ -2,3 +2,4 @@
 __pycache__
 venv
 .pyc
+env

Event.py

@@ -5,5 +5,5 @@ class Event:
     self.name = name
     logging.info("Created " + self.name)
 
-  def trigger(self):
+  def trigger(self, target):
     logging.info('Event ' + self.name + ' triggered!')

PlayerState.py

@@ -1,5 +1,6 @@
 from threading import Timer
 import time
+import config
 
 class PlayerState:
     def __init__(self, display, specialDisplay, id, ballsToPlay, upperPlayfieldTime = 5, bonusTime = 0):
@@ -8,10 +9,68 @@ class PlayerState:
         self.id = id
         self.points = 0
         self.ballsLeft = ballsToPlay
-        self.upperPlayfieldTime = upperPlayfieldTime
+
-        self.bonusTime = bonusTime
+        self.bonusTime = config.BEGINNING_BONUS_TIME
+
+        self.reset()
+
+    def reset(self):
+        self.bonus = 0
+        self.bonusMultiplier = 1
         self.timer = None
         self.timerStartTime = None
+        self.replayBall = False
+        self.upperPlayfieldTime = config.BEGINNING_UPPER_PLAYFIELD_TIME
+
+        self.resetTargets()
+
+    def resetTargets(self):
+        self.resetRedSpecial()
+        self.resetOrangeSpecial()
+        self.tunnelLit = 0
+
+    def resetRedSpecial(self):
+        self.redSpecial = 0
+        self.redSpecialLit = False
+
+    def resetOrangeSpecial(self):
+        self.orangeSpecialLeft = False
+        self.orangeSpecialRight = False
+        self.orangeSpecialLit = False
+
+    def advanceRightOrangeSpecial(self):
+        self.orangeSpecialRight = True
+        self.setOrangeSpecialLit()
+
+    def advanceLeftOrangeSpecial(self):
+        self.orangeSpecialLeft = True
+        self.setOrangeSpecialLit()
+
+    def setOrangeSpecialLit(self):
+        if config.ORANGE_SPECIAL_BANK_OPTIONS == config.ORANGE_SPECIAL_BANK_OPTIONS.ONE:
+            self.orangeSpecialLit = self.orangeSpecialRight or self.orangeSpecialLeft
+        elif config.ORANGE_SPECIAL_BANK == config.ORANGE_SPECIAL_BANK_OPTIONS.BOTH:
+            self.orangeSpecialLit = self.orangeSpecialRight and self.orangeSpecialLeft
+
+
+    def advanceRedSpecial(self):
+        self.redSpecial += 1
+
+        if(self.redSpecial == config.RED_SPECIAL_TIMES):
+            self.redSpecialLit = True
+
+    def advanceBonusMultiplier(self):
+        if self.bonusMultiplier >= 15:
+            return
+
+        if self.bonusMultiplier == 1:
+            self.bonusMultiplier = 5
+            return
+
+        self.bonusMultiplier *= 2
+
+    def setReplayBall(self):
+        self.replayBall = True
 
     def addPoints(self, points):
         self.points += points

config.py

@@ -1,4 +1,8 @@
 import os
+from events.SpecialEvent import SpecialEvent
+from enum import Enum
+
+ORANGE_SPECIAL_BANK_OPTIONS = Enum("BOTH", "ONE")
 
 # Game Config
 ## Network Config
@@ -9,3 +13,8 @@ OUTPUT_SOCKET_NAME = "/S.flippR_driver.out"
 BALLS_PER_GAME = 3
 BEGINNING_UPPER_PLAYFIELD_TIME = 5
 BEGINNING_BONUS_TIME = 0
+## Special config
+RED_SPECIAL = SpecialEvent.replay
+RED_SPECIAL_TIMES = 1
+ORANGE_SPECIAL = SpecialEvent.points
+ORANGE_SPECIAL_BANK = ORANGE_SPECIAL_BANK_OPTIONS.BOTH

events/BankEvent.py

@@ -2,10 +2,11 @@ from Event import Event
 
 
 class BankEvent(Event):
-    def __init__(self, bankSolenoid, name):
+    def __init__(self, bankSolenoid, name, playerState):
         self.bankSolenoid = bankSolenoid
         super().__init__(name)
+        self.playerState = playerState
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.bankSolenoid.trigger()

events/BonusTimeEvent.py

@@ -6,6 +6,6 @@ class BonusTimeEvent(Event):
         self.playerState = playerState
         super().__init__("Bonus Time Event")
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.playerState().addBonusTimeSecond()

events/BottomLeftBankEvent.py

@@ -3,6 +3,12 @@ from solenoids.BottomLeftBankSolenoid import BottomLeftBankSolenoid
 
 
 class BottomLeftBankEvent(BankEvent):
-  def __init__(self):
+  def __init__(self, playerState):
-    super().__init__(BottomLeftBankSolenoid(), "Bottom Left Bank Event")
+    super().__init__(BottomLeftBankSolenoid(), "Bottom Left Bank Event", playerState)
 
+  def trigger(self, target):
+    super().trigger(target)
+    playerState = self.playerState()
+    playerState.advanceLeftOrangeSpecial()
+    if playerState.upperPlayfieldTime < 30:
+      playerState.addUpperPlayfieldTime(5)

events/BottomRightBankEvent.py

@@ -3,6 +3,12 @@ from solenoids.BottomRightBankSolenoid import BottomRightBankSolenoid
 
 
 class BottomRightBankEvent(BankEvent):
-  def __init__(self):
+  def __init__(self, playerState):
-    super().__init__(BottomRightBankSolenoid(), "Bottom Right Bank Event")
+    super().__init__(BottomRightBankSolenoid(), "Bottom Right Bank Event", playerState)
 
+  def trigger(self, target):
+    super().trigger(target)
+    playerState = self.playerState()
+    playerState.advanceRightOrangeSpecial()
+    if playerState.upperPlayfieldTime < 30:
+      playerState.addUpperPlayfieldTime(5)

events/EndBallEvent.py

@@ -0,0 +1,28 @@
+from Event import Event
+
+from events.EndGameEvent import EndGameEvent
+from events.StartBallEvent import StartBallEvent
+
+
+class EndBallEvent(Event):
+    def __init__(self, playerState):
+        self.playerState = playerState
+        super().__init__("End Of Ball Event")
+
+    def trigger(self, target):
+        super().trigger(target)
+        if self.playerState.replayBall:
+            StartBallEvent().trigger(None)
+            return
+
+        self.playerState().removeBall()
+
+        self.scorePoints()
+        self.playerState().reset()
+
+        if self.playerState().ballsLeft == 0:
+            EndGameEvent().trigger(None)
+
+    def scorePoints(self):
+        bonus = self.playerState().bonus * self.playerState().bonusMultiplier * 1000
+        self.playerState().addPoints(bonus)

events/EndGameEvent.py

@@ -9,7 +9,7 @@ class EndGameEvent(Event):
     def __init__(self):
         super().__init__("End Game Event")
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.flipper.deactivate()
         sys.exit(0)

events/EndOfBallEvent.py

@@ -1,15 +0,0 @@
-from Event import Event
-
-from events.EndGameEvent import EndGameEvent
-
-class EndOfBallEvent(Event):
-    def __init__(self, playerState):
-        self.playerState = playerState
-        super().__init__("End Of Ball Event")
-
-    def trigger(self, _):
-        super().trigger()
-        self.playerState().removeBall()
-
-        if self.playerState().ballsLeft == 0:
-            EndGameEvent().trigger()

events/EnterUpperPlayfieldEvent.py

@@ -8,7 +8,7 @@ class EnterUpperPlayfieldEvent(Event):
         self.flipper = TopFlipper()
         super().__init__("Enter Upper Playfield Event")
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.flipper.activate()
         self.playerState().startUpperPlayfieldTimer()

events/FlapEvent.py

@@ -6,6 +6,6 @@ class FlapEvent(Event):
         self.flapSolenoid = flapSolenoid
         super().__init__(name)
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.flapSolenoid.trigger()

events/LeaveUpperPlayfieldEvent.py

@@ -7,7 +7,7 @@ class LeaveUpperPlayfieldEvent(Event):
         self.flipper = flipper
         super().__init__("Leave Upper Playfield Event")
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.flipper.deactivate()
         self.playerState().stopUpperPlayfieldTimer()

events/OrangeSpecialEvent.py

@@ -0,0 +1,16 @@
+from events.SpecialEvent import SpecialEvent
+
+import config
+
+
+class OrangeSpecialEvent(SpecialEvent):
+    def __init__(self, playerState):
+        super().__init__("Orange Special Event", playerState)
+        self.points = 200000
+
+    def trigger(self, target):
+        super().trigger(target)
+        if self.playerState().orangeSpecialLit:
+            config.ORANGE_SPECIAL(self)
+            self.playerState().resetOrangeSpecial()
+

events/PointEvent.py

@@ -4,8 +4,8 @@ from Event import Event
 class PointEvent(Event):
     def __init__(self, playerState):
         self.playerState = playerState
-        super().__init__("Point Event Event")
+        super().__init__("Point Event")
 
     def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.playerState().addPoints(target.points)

events/PopEvent.py

@@ -6,6 +6,6 @@ class PopEvent(Event):
         self.popSolenoid = popSolenoid
         super().__init__(name)
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.popSolenoid.trigger()

events/RedSpecialEvent.py

@@ -0,0 +1,15 @@
+from events.SpecialEvent import SpecialEvent
+import config
+
+class RedSpecialEvent(SpecialEvent):
+    def __init__(self, playerState):
+        super().__init__("Red Special Event", playerState)
+        self.points = 990000
+
+    def trigger(self, target):
+        super().trigger(target)
+        if self.playerState().redSpecialLit:
+            config.RED_SPECIAL(self)
+            self.playerState().resetRedSpecial()
+
+

events/RightKickerEvent.py

@@ -7,6 +7,6 @@ class RightKickerEvent(Event):
         self.rightKickerSolenoid = RightKickerSolenoid()
         super().__init__("Right Kicker Event")
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.rightKickerSolenoid.trigger()

events/SpecialEvent.py

@@ -0,0 +1,19 @@
+from Event import Event
+
+
+class SpecialEvent(Event):
+    def __init__(self, name, playerState):
+        super().init(name)
+        self.playerState = playerState
+
+    def replay(self):
+        self.playerState.setReplayBall()
+
+    def extra_ball(self):
+        self.playerState.addBall()
+
+    def points(self):
+        self.playerState.addPoints(self.points)
+
+    def super_bonus(self):
+        pass

events/SpinnerEvent.py

@@ -0,0 +1,29 @@
+from Event import Event
+from time import time
+
+
+class SpinnerEvent(Event):
+    def __init__(self, playerState):
+        super().__init__("Spinner Event")
+        self.playerState = playerState
+        self.activationTime = time()
+
+    def trigger(self, target):
+        super().trigger(target)
+        if time() - self.activationTime > 10:
+            self.activationTime = time()
+            return
+
+        self.scorePoints()
+
+    def scorePoints(self):
+        playerState = self.playerState()
+        timePassed = time() - self.activationTime
+        if 1 <= timePassed < 1.5:
+            playerState.addPoints(100000)
+        elif 1.5 <= timePassed < 2:
+            playerState.addPoints(150000)
+        elif 2 <= timePassed < 5:
+            playerState.addPoints(200000)
+        elif timePassed >= 5:
+            playerState.addPoints(500000)

events/StartBallEvent.py

@@ -0,0 +1,15 @@
+from Event import Event
+from solenoids.OutHoleSolenoid import OutHoleSolenoid
+from solenoids.MainFlipper import MainFlipper
+
+
+class StartBallEvent(Event):
+    def __init__(self):
+        self.flipper = MainFlipper()
+        self.outHoleSolenoid = OutHoleSolenoid()
+        super().__init__("Start Ball Event")
+
+    def trigger(self, target):
+        super().trigger(target)
+        self.flipper.activate()
+        self.outHoleSolenoid.trigger()

events/StartGameEvent.py

@@ -9,7 +9,7 @@ class StartGameEvent(Event):
         self.outHoleSolenoid = OutHoleSolenoid()
         super().__init__("Start Game Event")
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.flipper.activate()
         self.outHoleSolenoid.trigger()

events/TopCentralBankEvent.py

@@ -3,6 +3,11 @@ from solenoids.TopCentralBankSolenoid import TopCentralBankSolenoid
 
 
 class TopCentralBankEvent(BankEvent):
-  def __init__(self):
+  def __init__(self, playerState):
-    super().__init__(TopCentralBankSolenoid(), "Top Central Bank Event")
+    super().__init__(TopCentralBankSolenoid(), "Top Central Bank Event", playerState)
+
+
+  def trigger(self, target):
+    self.playerState().advanceRedSpecial()
+
 

events/TunnelEvent.py

@@ -0,0 +1,25 @@
+from Event import Event
+
+class TunnelEvent(Event):
+    def __init__(self, playerState):
+        super().__init__("Tunnel Event")
+        self.playerState = playerState
+
+    def trigger(self, target):
+        super().trigger(target)
+        self.advanceBonusMultiplier()
+        self.scoreBonusTunnelPoints()
+
+    def advanceBonusMultiplier(self):
+        self.playerState().advanceBonusMultiplier()
+
+    def scoreBonusTunnelPoints(self):
+        playerState = self.playerState()
+        if playerState.tunnelLit == 2:
+            playerState.addPoints(10000)
+        elif playerState.tunnelLit == 3:
+            playerState.addPoints(20000)
+        elif playerState.tunnelLit == 4:
+            playerState.addPoints(40000)
+        elif playerState.tunnelLit == 5:
+            playerState.addPoints(190000)

events/UpperPlayfieldTimeEvent.py

@@ -6,6 +6,6 @@ class UpperPlayfieldTimeEvent(Event):
         self.playerState = playerState
         super().__init__("Upper Playfield Time Event")
 
-    def trigger(self, _):
+    def trigger(self, target):
-        super().trigger()
+        super().trigger(target)
         self.playerState().addUpperPlayfieldTime(1)

factories/EventFactory.py

@@ -1,7 +1,7 @@
 import inspect
 
 from events.PointEvent import PointEvent
-from events.EndOfBallEvent import EndOfBallEvent
+from events.EndBallEvent import EndBallEvent
 from events.RightFlapEvent import RightFlapEvent
 from events.LeftFlapEvent import LeftFlapEvent
 from events.RightKickerEvent import RightKickerEvent
@@ -13,7 +13,10 @@ from events.BottomLeftBankEvent import BottomLeftBankEvent
 from events.TopCentralBankEvent import TopCentralBankEvent
 from events.BottomRightPopEvent import BottomRightPopEvent
 from events.TopLeftPopEvent import TopLeftPopEvent
-
+from events.TunnelEvent import TunnelEvent
+from events.RedSpecialEvent import RedSpecialEvent
+from events.OrangeSpecialEvent import OrangeSpecialEvent
+from events.SpinnerEvent import SpinnerEvent
 
 class EventFactory:
     def __init__(self, targets, currentPlayer):
@@ -36,7 +39,7 @@ class EventFactory:
         return event
 
     def createEndOfBallEvent(self):
-        event = EndOfBallEvent(self.currentPlayer)
+        event = EndBallEvent(self.currentPlayer)
         self.__registerEventToTarget(event, self.targets['Outhole'])
         return event
 
@@ -66,24 +69,49 @@ class EventFactory:
         return event
 
     def createBottomLeftBankEvent(self):
-        event = BottomLeftBankEvent()
+        event = BottomLeftBankEvent(self.currentPlayer)
         self.__registerEventToTarget(event, self.targets["Left Bank"])
+        return event
 
     def createBottomRightBankEvent(self):
-        event = BottomRightBankEvent()
+        event = BottomRightBankEvent(self.currentPlayer)
         self.__registerEventToTarget(event, self.targets["Right Bank"])
+        return event
 
     def createTopCentralBankEvent(self):
-        event = TopCentralBankEvent()
+        event = TopCentralBankEvent(self.currentPlayer)
         self.__registerEventToTarget(event, self.targets["Top Bank"])
+        return event
 
     def createTopLeftPopEvent(self):
         event = TopLeftPopEvent()
         self.__registerEventToTarget(event, self.targets["Left Pop"])
+        return event
 
     def createBottomRightPopEvent(self):
         event = BottomRightPopEvent()
         self.__registerEventToTarget(event, self.targets["Right Pop"])
+        return event
+
+    def createTunnelEvent(self):
+        event = TunnelEvent(self.currentPlayer)
+        self.__registerEventToTarget(event, self.targets["Canal Button Bottom"])
+        return event
+
+    def createRedSpecialEvent(self):
+        event = RedSpecialEvent(self.currentPlayer)
+        self.__registerEventToTarget(event, self.targets["Special Red"])
+        return event
+
+    def createOrangeSpecialEvent(self):
+        event = OrangeSpecialEvent(self.currentPlayer)
+        self.__registerEventToTarget(event, self.targets["Special Orange"])
+        return event
+
+    def createSpinnerEvent(self):
+        event = SpinnerEvent(self.currentPlayer)
+        self.__registerEventToTarget(event, self.targets["Spinner"])
+        return event
 
     def __registerEventToTarget(self, event, target):
         target.on(target.hit_key, event.trigger)

targets/bottom_lanes/LeftInlaneTarget.py

@@ -2,7 +2,7 @@ from Target import Target
 
 class LeftInlaneTarget(Target):
     def __init__(self):
-        super().__init__(100, 'Left Inlane')
+        super().__init__(3000, 'Left Inlane')
 
     def hit(self):
         super().hit()

targets/bottom_lanes/LeftOutlaneTarget.py

@@ -2,7 +2,7 @@ from Target import Target
 
 class LeftOutlaneTarget(Target):
     def __init__(self):
-        super().__init__(100, 'Left Outlane')
+        super().__init__(100000, 'Left Outlane')
 
     def hit(self):
         super().hit()

targets/bottom_lanes/RightInlaneTarget.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class RightInlaneTarget(Target):
     def __init__(self):
-        super().__init__(100, 'Right Inlane')
+        super().__init__(30000, 'Right Inlane')
 
     def hit(self):
         super().hit()

targets/fixed_targets/FixedTarget1.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class FixedTarget1(Target):
     def __init__(self):
-        super().__init__(0, "Fixed Target 1")
+        super().__init__(30000, "Fixed Target 1")
 
     def hit(self):
         super().hit()

targets/fixed_targets/FixedTarget2.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class FixedTarget2(Target):
     def __init__(self):
-        super().__init__(0, "Fixed Target 2")
+        super().__init__(30000, "Fixed Target 2")
 
     def hit(self):
         super().hit()

targets/fixed_targets/FixedTarget3.py

@@ -2,7 +2,7 @@ from Target import Target
 
 class FixedTarget3(Target):
     def __init__(self):
-        super().__init__(100, 'Fixed Target 3')
+        super().__init__(30000, 'Fixed Target 3')
 
     def hit(self):
         super().hit()

targets/fixed_targets/FixedTarget4.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class FixedTarget4(Target):
     def __init__(self):
-        super().__init__(100, 'Fixed Target 4')
+        super().__init__(30000, 'Fixed Target 4')
 
     def hit(self):
         super().hit()

targets/fixed_targets/FixedTarget5.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class FixedTarget5(Target):
     def __init__(self):
-        super().__init__(100, 'Fixed Target 5')
+        super().__init__(30000, 'Fixed Target 5')
 
     def hit(self):
         super().hit()

targets/left_bank/LeftBankLeftTarget.py

@@ -3,7 +3,7 @@ from BankTarget import BankTarget
 
 class LeftBankLeftTarget(BankTarget):
     def __init__(self):
-        super().__init__(100, 'Left Bank Left')
+        super().__init__(30000, 'Left Bank Left')
 
     def hit(self):
         super().hit()

targets/left_bank/LeftBankMiddleLeftTarget.py

@@ -3,7 +3,7 @@ from BankTarget import BankTarget
 
 class LeftBankMiddleLeftTarget(BankTarget):
     def __init__(self):
-        super().__init__(100, 'Left Bank Middle Left')
+        super().__init__(30000, 'Left Bank Middle Left')
 
     def hit(self):
         super().hit()

targets/left_bank/LeftBankMiddleRightTarget.py

@@ -3,7 +3,7 @@ from BankTarget import BankTarget
 
 class LeftBankMiddleRightTarget(BankTarget):
     def __init__(self):
-        super().__init__(100, 'Left Bank Middle Right')
+        super().__init__(30000, 'Left Bank Middle Right')
 
     def hit(self):
         super().hit()

targets/left_bank/LeftBankRightTarget.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class LeftBankRightTarget(Target):
     def __init__(self):
-        super().__init__(100, 'Left Bank Right')
+        super().__init__(30000, 'Left Bank Right')
 
     def hit(self):
         super().hit()

targets/pop_bumpers/LeftPopTarget.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class LeftPopTarget(Target):
     def __init__(self):
-        super().__init__(0, "Left Pop")
+        super().__init__(5000, "Left Pop")
 
     def hit(self):
         super().hit()

targets/pop_bumpers/RightPopTarget.py

@@ -3,7 +3,7 @@ from Target import Target
 
 class RightPopTarget(Target):
     def __init__(self):
-        super().__init__(100, 'Right Pop')
+        super().__init__(5000, 'Right Pop')
 
     def hit(self):
         super().hit()

targets/right_bank/RightBankLeftTarget.py

@@ -3,7 +3,7 @@ from BankTarget import BankTarget
 
 class RightBankLeftTarget(BankTarget):
     def __init__(self):
-        super().__init__(100, "Right Bank Left")
+        super().__init__(30000, "Right Bank Left")
 
     def hit(self):
         super().hit()

targets/right_bank/RightBankMiddleTarget.py

@@ -3,7 +3,7 @@ from BankTarget import BankTarget
 
 class RightBankMiddleTarget(BankTarget):
     def __init__(self):
-        super().__init__(100, 'Right Bank Middle')
+        super().__init__(30000, 'Right Bank Middle')
 
     def hit(self):
         super().hit()

targets/right_bank/RightBankRightTarget.py

@@ -3,7 +3,7 @@ from BankTarget import BankTarget
 
 class RightBankRightTarget(BankTarget):
     def __init__(self):
-        super().__init__(100, "Right Bank Right")
+        super().__init__(30000, "Right Bank Right")
 
     def hit(self):
         super().hit()

targets/technical/OutholeTarget.py

@@ -2,7 +2,7 @@ from Target import Target
 
 class OutholeTarget(Target):
     def __init__(self):
-        super().__init__(100, 'Outhole')
+        super().__init__(0, 'Outhole')
 
     def hit(self):
         super().hit()

test.py

@@ -1,8 +1,23 @@
-from utils.Singleton import Singleton
+class A:
-class A(metaclass=Singleton):
     def __init__(self, a):
         self.a = a
     def printa(self):
         print(self.a)
+    def test2(self, _):
+        print(34)
 
+    def test3(self):
+        print(5)
 
+class B(A):
+    def test(self, fun):
+        fun(self)
+    def test3(self, a):
+        super().test3()
+        print(a)
+
+class C:
+    def __init__(self):
+        self.foo()
+    def foo(self):
+        self.a = 10