thiiiiings

factories/DisplayFactory.py

@@ -0,0 +1,14 @@
+from displays.PlayerDisplay import PlayerDisplay
+from displays.SpecialDisplay import SpecialDisplay
+
+class DisplayFactory:
+    def __init__(self, displayNames):
+        self.displayNames = displayNames
+
+    def createSpecialDisplay(self):
+        name = filter(lambda displayName: "Special" in displayName, self.displayNames)
+        return SpecialDisplay(name)
+
+    def createPlayerDisplay(self, id):
+        name = filter(lambda displayName: "Player" in displayName and str(id) in displayName, self.displayNames)
+        return PlayerDisplay(name)

factories/EventFactory.py

@@ -0,0 +1,53 @@
+from events.PointEvent import PointEvent
+from events.EndOfBallEvent import EndOfBallEvent
+from events.RightFlapEvent import RightFlapEvent
+from events.LeftFlapEvent import LeftFlapEvent
+from events.RightKickerEvent import RightKickerEvent
+from events.EnterUpperPlayfieldEvent import EnterUpperPlayfieldEvent
+from events.StartGameEvent import StartGameEvent
+
+class EventFactory:
+    def __init__(self, targets, currentPlayer, upperPlayfieldFlippers, flipper):
+        self.targets = targets
+        self.currentPlayer = currentPlayer
+        self.upperPlayfieldFlippers = upperPlayfieldFlippers
+        self.flipper = flipper
+        
+    def createPointEvent(self):
+        event = PointEvent(self.currentPlayer)
+        for target in self.targets:
+            self.__registerEventToTarget(event, target)
+        return event
+
+    def createEndOfBallEvent(self):
+        event = EndOfBallEvent(self.currentPlayer)
+        self.__registerEventToTarget(event, self.targets['OutholeTarget'])
+        return event
+
+    def createRightFlapEvent(self):
+        event = RightFlapEvent()
+        self.__registerEventToTarget(event, self.targets['RightSlingshotTarget'])
+        return event
+
+    def createLeftFlapEvent(self):
+        event = LeftFlapEvent()
+        self.__registerEventToTarget(event, self.targets['LeftSlingshotTarget'])
+        return event
+
+    def createRightKickerEvent(self):
+        event = RightKickerEvent()
+        self.__registerEventToTarget(event, self.targets['RightOutlaneKickerTarget'])
+        return event
+
+    def createEnterUpperPlayfieldEvent(self):
+        event = EnterUpperPlayfieldEvent(self.currentPlayer, self.upperPlayfieldFlippers)
+        self.__registerEventToTarget(event, self.targets['UpperPlayfieldRollUnderTarget'])
+        return event
+
+    def createStartGameEvent(self):
+        event = StartGameEvent(self.flipper)
+        self.__registerEventToTarget(event, self.targets['CreditTarget'])
+        return event
+
+    def __registerEventToTarget(self, event, target):
+        target.on(target.hit_key, event.trigger)

factories/GameFactory.py

@@ -0,0 +1,47 @@
+from config import *
+from networking.Networking import Networking
+
+from factories.PlayerStateFactory import PlayerStateFactory
+from factories.DisplayFactory import DisplayFactory
+from factories.TargetFactory import TargetFactory
+from factories.EventFactory import EventFactory
+
+from InputHandler import InputHandler
+
+from GameState import GameState
+
+
+class GameFactory:
+    def __init__(self):
+        displayNames = Networking().getDisplays()
+        self.displayFactory = DisplayFactory(displayNames)
+        specialDisplay = self.displayFactory.createSpecialDisplay()
+
+        self.playerCount = len(displayNames) - 1
+
+        self.playerStateFactory = PlayerStateFactory(specialDisplay)
+
+
+    def createGame(self):
+        targets = TargetFactory.createAllTargets()
+        inputHandler = InputHandler(targets)
+
+        players = self.createPlayers()
+
+        gameState = GameState(players, self.getHighScore(), players[0].id)
+
+        eventFactory = EventFactory(targets, gameState.currentPlayer)
+        pointEvent = eventFactory.createPointEvent()
+
+
+    def createPlayers(self):
+        players = []
+        for id in range(self.playerCount):
+            display = self.displayFactory.createPlayerDisplay(id)
+            player = self.playerStateFactory.createPlayerState(display, id)
+            players.append(player)
+        return players
+
+    def getHighScore(self): # todo
+        return 0
+

factories/NetworkFactory.py

@@ -0,0 +1,7 @@
+from networking.Networking import Networking
+
+
+class NetworkFactory:
+    @staticmethod
+    def createNetwork(output_server_address, input_server_address):
+        Networking(output_server_address, input_server_address)

factories/PlayerStateFactory.py

@@ -0,0 +1,9 @@
+from config import *
+from PlayerState import PlayerState
+
+class PlayerStateFactory:
+    def __init__(self, specialDisplay):
+        self.specialDisplay = specialDisplay
+
+    def createPlayerState(self, display, id):
+        return PlayerState(display, self.specialDisplay, id, BALLS_PER_GAME, BEGINNING_UPPER_PLAYFIELD_TIME, BEGINNING_BONUS_TIME)

factories/TargetFactory.py

@@ -0,0 +1,31 @@
+from targets import *
+from targets.BankTarget import BankTarget
+
+class TargetFactory:
+    def createAllTargets(self):
+        result = dict()
+        glo = globals()  # Save globals so the dict does not change during execution of the script
+
+        for key in glo:
+            if(type(target) != 'class'):
+                continue
+
+            target = glo[key]
+            if 'Target' in key:
+                result[key] = target()
+            elif 'Bank' in key and 'Target' not in key:
+                targets = self.createBankTarget(target, key)
+                result = {**result, **targets}
+        # todo check with driver?
+        return result
+
+    def createBankTarget(self, target, key):
+        bankTarget = target()
+        targets = dict()
+        targets[key] = bankTarget
+
+        for target in bankTarget.targets:
+            name = type(target).__name__
+            targets[name] = target
+
+        return targets