Random dunno

GameState.py

@@ -3,7 +3,7 @@ import logging
 class GameState:
     def __init__(self, players, highscore, currentPlayerID = 0):
         self.players = players
-        self.currentPlayerID = currentPlayerID
+        self.gameStateID = currentPlayerID
         self.highscore = highscore
 
     @property
@@ -22,4 +22,4 @@ class GameState:
         self.players.remove(savedPlayer)
         self.players.append(savedPlayer)
 
-        self.currentPlayer.activate()
+        self.gameState.activate()

events/BankEvent.py

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

events/BonusEvent.py

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

events/BonusTimeEvent.py

@@ -2,10 +2,10 @@ from Event import Event
 
 
 class BonusTimeEvent(Event):
-    def __init__(self, playerState):
+    def __init__(self, gameState):
-        self.playerState = playerState
+        self.gameState = gameState
         super().__init__("Bonus Time Event")
 
     def trigger(self, target):
         super().trigger(target)
-        self.playerState.addBonusTimeSecond()
+        self.gameState.playerState.addBonusTimeSecond()

events/BottomLeftBankEvent.py

@@ -3,11 +3,11 @@ from solenoids.BottomLeftBankSolenoid import BottomLeftBankSolenoid
 
 
 class BottomLeftBankEvent(BankEvent):
-  def __init__(self, playerState):
+  def __init__(self, gameState):
-    super().__init__(BottomLeftBankSolenoid(), "Bottom Left Bank Event", playerState)
+    super().__init__(BottomLeftBankSolenoid(), "Bottom Left Bank Event", gameState)
 
   def trigger(self, target):
     super().trigger(target)
-    playerState = self.playerState
+    playerState = self.gameState.playerState
     playerState.advanceLeftOrangeSpecial()
     playerState.advanceUpperPlayfieldTime()

events/BottomRightBankEvent.py

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

events/EndBallEvent.py

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

events/EnterUpperPlayfieldEvent.py

@@ -3,12 +3,12 @@ from solenoids.TopFlipper import TopFlipper
 
 
 class EnterUpperPlayfieldEvent(Event):
-    def __init__(self, playerState):
+    def __init__(self, gameState):
-        self.playerState = playerState
+        self.gameState = gameState
         self.flipper = TopFlipper()
         super().__init__("Enter Upper Playfield Event")
 
     def trigger(self, target):
         super().trigger(target)
         self.flipper.activate()
-        self.playerState.startUpperPlayfieldTimer()
+        self.gameState.playerState.startUpperPlayfieldTimer()

events/FixedTargetEvent.py

@@ -2,10 +2,10 @@ from Event import Event
 
 
 class FixedTargetEvent(Event):
-    def __init__(self, playerState):
+    def __init__(self, gameState):
         super().__init__("Fixed Target Event")
-        self.playerState = playerState
+        self.gameState = gameState
 
     def trigger(self, target):
         super().trigger(target)
-        self.playerState.advanceTunnel()
+        self.gameState.playerState.advanceTunnel()

events/LeaveUpperPlayfieldEvent.py

@@ -3,8 +3,8 @@ from solenoids.TopFlipper import TopFlipper
 
 
 class LeaveUpperPlayfieldEvent(Event):
-    def __init__(self, playerState):
+    def __init__(self, gameState):
-        self.playerState = playerState
+        self.gameState = gameState
         self.flipper = TopFlipper()
         super().__init__("Leave Upper Playfield Event")
 

events/OrangeSpecialEvent.py

@@ -4,13 +4,13 @@ import config
 
 
 class OrangeSpecialEvent(SpecialEvent):
-    def __init__(self, playerState):
+    def __init__(self, gameState):
-        super().__init__("Orange Special Event", playerState)
+        super().__init__("Orange Special Event", gameState)
         self.points = 200000
 
     def trigger(self, target):
         super().trigger(target)
-        if self.playerState.orangeSpecialLit:
+        if self.gameState.playerState.orangeSpecialLit:
             config.ORANGE_SPECIAL(self)
-            self.playerState.resetOrangeSpecial()
+            self.gameState.playerState.resetOrangeSpecial()
 

events/PointEvent.py

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

events/RedSpecialEvent.py

@@ -8,8 +8,8 @@ class RedSpecialEvent(SpecialEvent):
 
     def trigger(self, target):
         super().trigger(target)
-        if self.playerState.redSpecialLit:
+        if self.gameState.redSpecialLit:
             config.RED_SPECIAL(self)
-            self.playerState.resetRedSpecial()
+            self.gameState.resetRedSpecial()
 
 

events/SpecialEvent.py

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

events/SpinnerEvent.py

@@ -3,9 +3,9 @@ from time import time
 
 
 class SpinnerEvent(Event):
-    def __init__(self, playerState):
+    def __init__(self, gameState):
         super().__init__("Spinner Event")
-        self.playerState = playerState
+        self.gameState = gameState
         self.activationTime = time()
 
     def trigger(self, target):
@@ -17,7 +17,7 @@ class SpinnerEvent(Event):
         self.scorePoints()
 
     def scorePoints(self):
-        playerState = self.playerState
+        playerState = self.gameState.playerState
         timePassed = time() - self.activationTime
         if 1 <= timePassed < 1.5:
             playerState.addPoints(100000)

events/StartGameEvent.py

@@ -5,7 +5,7 @@ from solenoids.MainFlipper import MainFlipper
 
 class StartGameEvent(Event):
     def __init__(self, playerState):
-        self.playerState = playerState
+        self.gameState = playerState
         self.flipper = MainFlipper()
         self.outHoleSolenoid = OutHoleSolenoid()
         super().__init__("Start Game Event")
@@ -13,5 +13,5 @@ class StartGameEvent(Event):
     def trigger(self, target):
         super().trigger(target)
         self.flipper.activate()
-        self.playerState.activate()
+        self.gameState.activate()
         self.outHoleSolenoid.trigger()

events/TopCentralBankEvent.py

@@ -8,6 +8,6 @@ class TopCentralBankEvent(BankEvent):
 
 
   def trigger(self, target):
-    self.playerState.advanceRedSpecial()
+    self.gameState.advanceRedSpecial()
 
 

events/TunnelEvent.py

@@ -3,7 +3,7 @@ from Event import Event
 class TunnelEvent(Event):
     def __init__(self, playerState):
         super().__init__("Tunnel Event")
-        self.playerState = playerState
+        self.gameState = playerState
 
     def trigger(self, target):
         super().trigger(target)
@@ -11,10 +11,10 @@ class TunnelEvent(Event):
         self.scoreBonusTunnelPoints()
 
     def advanceBonusMultiplier(self):
-        self.playerState.advanceBonusMultiplier()
+        self.gameState.advanceBonusMultiplier()
 
     def scoreBonusTunnelPoints(self):
-        playerState = self.playerState
+        playerState = self.gameState
         if playerState.tunnelLit == 2:
             playerState.addPoints(10000)
         elif playerState.tunnelLit == 3:

events/UpperPlayfieldTimeEvent.py

@@ -3,9 +3,9 @@ from Event import Event
 
 class UpperPlayfieldTimeEvent(Event):
     def __init__(self, playerState):
-        self.playerState = playerState
+        self.gameState = playerState
         super().__init__("Upper Playfield Time Event")
 
     def trigger(self, target):
         super().trigger(target)
-        self.playerState.addUpperPlayfieldTime(1)
+        self.gameState.addUpperPlayfieldTime(1)

factories/EventFactory.py

@@ -44,9 +44,9 @@ BONUS_EVENT_TARGETS = [
 ]
 
 class EventFactory:
-    def __init__(self, targets, currentPlayer):
+    def __init__(self, targets, gameState):
         self.targets = targets
-        self.currentPlayer = currentPlayer
+        self.gameState = gameState
 
     def allEvents(self):
         methods = inspect.getmembers(self, predicate=inspect.ismethod)
@@ -58,13 +58,13 @@ class EventFactory:
         return result
 
     def createPointEvent(self):
-        event = PointEvent(self.currentPlayer)
+        event = PointEvent(self.gameState)
         for target in self.targets.values():
             self.__registerEventToTarget(event, target)
         return event
 
     def createEndOfBallEvent(self):
-        event = EndBallEvent(self.currentPlayer)
+        event = EndBallEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets['Outhole'])
         return event
 
@@ -84,27 +84,27 @@ class EventFactory:
         return event
 
     def createEnterUpperPlayfieldEvent(self):
-        event = EnterUpperPlayfieldEvent(self.currentPlayer)
+        event = EnterUpperPlayfieldEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets['Rising ball'])
         return event
 
     def createStartGameEvent(self):
-        event = StartGameEvent(self.currentPlayer)
+        event = StartGameEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets['Credit'])
         return event
 
     def createBottomLeftBankEvent(self):
-        event = BottomLeftBankEvent(self.currentPlayer)
+        event = BottomLeftBankEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Left Bank"])
         return event
 
     def createBottomRightBankEvent(self):
-        event = BottomRightBankEvent(self.currentPlayer)
+        event = BottomRightBankEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Right Bank"])
         return event
 
     def createTopCentralBankEvent(self):
-        event = TopCentralBankEvent(self.currentPlayer)
+        event = TopCentralBankEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Top Bank"])
         return event
 
@@ -119,27 +119,27 @@ class EventFactory:
         return event
 
     def createTunnelEvent(self):
-        event = TunnelEvent(self.currentPlayer)
+        event = TunnelEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Canal Button Bottom"])
         return event
 
     def createRedSpecialEvent(self):
-        event = RedSpecialEvent(self.currentPlayer)
+        event = RedSpecialEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Special Red"])
         return event
 
     def createOrangeSpecialEvent(self):
-        event = OrangeSpecialEvent(self.currentPlayer)
+        event = OrangeSpecialEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Special Orange"])
         return event
 
     def createSpinnerEvent(self):
-        event = SpinnerEvent(self.currentPlayer)
+        event = SpinnerEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Spinner"])
         return event
 
     def createFixedTargetEvent(self):
-        event = FixedTargetEvent(self.currentPlayer)
+        event = FixedTargetEvent(self.gameState)
         self.__registerEventToTarget(event, self.targets["Fixed Target 1"])
         self.__registerEventToTarget(event, self.targets["Fixed Target 2"])
         self.__registerEventToTarget(event, self.targets["Fixed Target 3"])
@@ -148,7 +148,7 @@ class EventFactory:
         return event
 
     def createBonusEvent(self):
-        event = BonusEvent(self.currentPlayer)
+        event = BonusEvent(self.gameState)
         self.__registerEventToTargets(event, BONUS_EVENT_TARGETS)
 
     def createTiltEvent(self):

factories/GameFactory.py

@@ -19,7 +19,7 @@ class GameFactory:
 
         self.playerCount = len(displayNames) - 1
 
-        self.playerStateFactory = PlayerStateFactory(specialDisplay)
+        self.gameStateFactory = PlayerStateFactory(specialDisplay)
 
 
     def createGame(self):
@@ -31,7 +31,7 @@ class GameFactory:
 
         gameState = GameState(players, self.getHighScore(), players[0].id)
 
-        eventFactory = EventFactory(targets, gameState.currentPlayer.fset)
+        eventFactory = EventFactory(targets, gameState)
         events = eventFactory.allEvents()
 
         return Game(inputHandler, gameState, events)
@@ -40,7 +40,7 @@ class GameFactory:
         players = []
         for id in range(1, self.playerCount):
             display = self.displayFactory.createPlayerDisplay(id)
-            player = self.playerStateFactory.createPlayerState(display, id, banks)
+            player = self.gameStateFactory.createPlayerState(display, id, banks)
             players.append(player)
         return players