Add player choosing

GameState.py

@@ -1,24 +1,42 @@
 import logging
+
+import config
 from lamps.LampGroup import PLAYER_LAMPS
 from lamps.Lamp import CREDIT
 from itertools import cycle
 
 class GameState:
-    def __init__(self, players, highscore, specialDisplay, dummyPlayer, currentPlayerID = 0):
+    players = None
+    credits = config.BALLS_PER_GAME
+    isPlaying = False
+
+    def __init__(self, playerStateFactory, highscore, specialDisplay, currentPlayerID = 0):
         CREDIT.activate()
-        self.players = cycle(players)
+        self.playerStateFactory = playerStateFactory
-        self.dummyPlayer = dummyPlayer
+        #self.players = cycle(players)
+        self.dummyPlayer = playerStateFactory.createDummyPlayerState()
         self._currentPlayer = dummyPlayer
         self.gameStateID = currentPlayerID
         self.highscore = highscore
-        self.credits = 3
         self.specialDisplay = specialDisplay
         self.specialDisplay.printCredits(self.credits)
-        self.isPlaying = False
 
     def nextPlayer(self):
         self.currentPlayer = next(self.players)
+
+    def startGame(self, playerCount):
         self.isPlaying = True
+        self.createPlayers(playerCount)
+        self.nextPlayer()
+
+
+    def createPlayers(self, playerCount):
+        players = []
+        for i in range(playerCount):
+            player = self.playerStateFactory.createPlayerState(i)
+            players.append(player)
+
+        self.players = cycle(players)
 
     @property
     def currentPlayer(self):

config.py

@@ -6,6 +6,7 @@ ORANGE_SPECIAL_BANK_OPTIONS = Enum("ORANGE_SPECIAL_BANK_OPTIONS", ["BOTH", "ONE"
 BONUS_TIME_ALGORITHM_OPTIONS = Enum("BONUS_TIME_ALGORITHM_OPTIONS", ["ALWAYS", "RANDOM"])
 
 # Game Config
+MAX_PLAYERS = 4
 ## Network Config
 SOCKET_PATH = '/tmp' #os.environ["XDG_RUNTIME_DIR"] if os.environ["XDG_RUNTIME_DIR"] else '/tmp'
 INPUT_SOCKET_NAME = "/S.flippR_driver.in"
@@ -30,3 +31,4 @@ MAX_NETWORK_RETRIES = 10
 NETWORK_SLEEP_TIME_SECONDS = 0.1
 BANK_SLEEP_TIME = 0.1
 BONUS_SLEEP_TIME = 0.1
+PLAYER_CHOOSE_INTERVAL = 3

events/StartGameEvent.py

@@ -1,10 +1,20 @@
 from Event import Event
+from events.StartBallEvent import StartBallEvent
 from solenoids.OutHoleSolenoid import OutHoleSolenoid
 from solenoids.MainFlipper import MainFlipper
 
+from threading import Timer
+import config
+
+from lamps.LampGroup import PLAYER_LAMPS
 
 class StartGameEvent(Event):
-    def __init__(self, gameState):
+    isPlayerChoosing = True
+    playerCount = 1
+    timer = None
+
+    def __init__(self, gameState, startBallEvent):
+        self.startBallEvent = startBallEvent
         self.gameState = gameState
         self.flipper = MainFlipper()
         self.outHoleSolenoid = OutHoleSolenoid()
@@ -15,8 +25,23 @@ class StartGameEvent(Event):
             return
 
         super().trigger(target)
-        self.flipper.activate()
 
-        self.gameState.nextPlayer()
+        if not self.isPlayerChoosing:
+            self.timer = Timer(interval=config.PLAYER_CHOOSE_INTERVAL, function=self.player_choose_ended)
+            self.timer.start()
+            return
 
-        self.outHoleSolenoid.trigger()
+        if self.playerCount == config.MAX_PLAYERS:
+            PLAYER_LAMPS.deactivate()
+            PLAYER_LAMPS.activateNext()
+            self.playerCount = 1
+            return
+
+        PLAYER_LAMPS.activate_one(self.playerCount)
+        self.playerCount += 1
+
+    def player_choose_ended(self):
+        self.timer = None
+        PLAYER_LAMPS.deactivate()
+        self.gameState.startGame(self.playerCount)
+        StartBallEvent().trigger(None)

factories/GameFactory.py

@@ -19,32 +19,21 @@ class GameFactory:
 
         self.playerCount = len(displayNames)
 
-        self.gameStateFactory = PlayerStateFactory(self.specialDisplay)
+        self.targets = TargetFactory.createAllTargets()
+        banks = [self.targets['Left Bank'], self.targets['Right Bank'], self.targets['Top Bank']]
+
+        self.playerStateFactory = PlayerStateFactory(self.specialDisplay, banks, self.displayFactory)
 
 
     def createGame(self):
-        targets = TargetFactory.createAllTargets()
+        inputHandler = InputHandler(self.targets)
-        inputHandler = InputHandler(targets)
 
-        banks = [targets['Left Bank'], targets['Right Bank'], targets['Top Bank']]
+        gameState = GameState(self.playerStateFactory, self.getHighScore(), self.specialDisplay, players[0].id)
-        players = self.createPlayers(banks)
-        dummyPlayer = self.gameStateFactory.createDummyPlayerState()
 
-        gameState = GameState(players, self.getHighScore(), self.specialDisplay, dummyPlayer, players[0].id)
+        eventFactory = EventFactory(self.targets, gameState)
-
-        eventFactory = EventFactory(targets, gameState)
         events = eventFactory.allEvents()
 
         return Game(inputHandler, gameState, events)
 
-    def createPlayers(self, banks):
-        players = []
-        for id in range(1, self.playerCount):
-            display = self.displayFactory.createPlayerDisplay(id)
-            player = self.gameStateFactory.createPlayerState(display, id, banks)
-            players.append(player)
-        return players
-
     def getHighScore(self): # todo
         return 0
-

factories/PlayerStateFactory.py

@@ -3,11 +3,14 @@ from PlayerState import PlayerState
 from displays.DummyDisplay import DummyDisplay
 
 class PlayerStateFactory:
-    def __init__(self, specialDisplay):
+    def __init__(self, specialDisplay, banks, displayFactory):
         self.specialDisplay = specialDisplay
+        self.banks = banks
+        self.displayFactory = displayFactory
 
-    def createPlayerState(self, display, id, banks):
+    def createPlayerState(self, id):
-        return PlayerState(display, self.specialDisplay, id, BALLS_PER_GAME, banks)
+        display = self.displayFactory.createPlayerDisplay(id)
+        return PlayerState(display, self.specialDisplay, id, BALLS_PER_GAME, self.banks)
 
     def createDummyPlayerState(self):
         display = DummyDisplay()

lamps/LampGroup.py

@@ -19,6 +19,9 @@ class LampGroup:
         for lamp in self.lamps:
             lamp.deactivate()
 
+    def activate_one(self, id):
+        self.lamps[id].activate()
+
     def activateNext(self):
         self.lamps[self.currentLampPtr].activate()