Added existing files

Main.puml

@@ -0,0 +1,70 @@
+@startuml
+class Observable {
+    trigger(string event)
+    on(string event, function fun)
+}
+
+class FlippR
+
+class Game
+
+Game --* Cabinet : isAchievementStrategy ?
+Game --* State : observes >
+Game "1" --* "*" TargetStrategy
+
+class TargetStrategy
+Target "1" o-- "1" TargetStrategy : observe <
+State o-- TargetStrategy : changes <
+
+class State {
+    int ballsLeft
+    int currentBall
+}
+
+State --* BallState
+
+class BallState {
+    int score
+    int globalMultiplier
+    addScore(int points)
+}
+
+class UpperPlayFieldTimer {
+    int timeLeft = 0
+    start()
+    stop()
+}
+
+BallState --* UpperPlayFieldTimer
+class Cabinet {
+}
+
+Observable <|-- Cabinet
+Cabinet "1" --* "*" Target
+
+Observable <|-- Target
+abstract class Target {
+    int points
+    string name
+    hit()
+}
+
+class AchievementTarget {
+}
+
+Target "1..*" *-- "1" AchievementTarget : observe <
+Target <|-- AchievementTarget
+
+class BankTarget {
+    bool isHit
+    hit()
+    reset()
+}
+Target <|-- BankTarget
+
+class Bank
+
+Target <|-- Bank
+Bank "1" --* "1..*" BankTarget : observe >
+
+@enduml

Target_Strategy_Sequence.puml

@@ -0,0 +1,7 @@
+@startuml
+Cabinet -> TargetStrategy : Event
+Game -> TargetStrategy : defines
+
+
+
+@enduml

src/Bank.py

@@ -0,0 +1,21 @@
+class Bank(Target):
+    def __init__(self, targets):
+        self.targets = targets
+        self.__register_targets__()
+
+    def __target_hit__(self, target):
+        if all(target.is_hit for target in self.targets):
+            self.__all_targets_hit__()
+
+    def __all_targets_hit__(self):
+        self.__reset_all_targets__()
+        super.hit()
+        pass
+
+    def __reset_all_targets__(self):
+        for target in self.targets:
+            target.reset()
+
+    def __register_targets__(self):
+        for target in self.targets:
+            target.on(target.hit_key, self.__target_hit__)

src/BankTarget.py

@@ -0,0 +1,15 @@
+from Target import Target
+
+
+class BankTarget(Target):
+    def __init__(self, points):
+        super(points)
+        self.is_hit = False
+
+    def hit(self):
+        self.is_hit = True
+        super.hit()
+        #notify Bank
+
+    def reset(self):
+        self.is_hit = False

src/Target.py

@@ -0,0 +1,10 @@
+class Target(Observable):
+    def __init__(self, points, name):
+        self.points = points
+        self.name = name
+        self.hit_key = "hit"
+
+    def hit(self):
+        #notify Observers
+        #notify Gamestate
+        self.trigger(self.hit_key, self)

src/game.py

@@ -0,0 +1,46 @@
+output_server_address = ''
+input_server_address = ''
+
+#network = Networking(output_server_address, input_server_address)
+network = ''
+
+class EventHandler():
+    def __init__(self, network):
+        # brace yourselves, python incoming
+        self.subclasses = {subcls.__name__: subcls for subcls in self.__class__.__subclasses__()}
+        self.network = network
+
+    def handle(self, name):
+        self.subclasses[name](network)
+
+class LeftFlapEventHandler(EventHandler):
+    def __init__(self, network):
+        print('Left Flap Event gets handled')
+        self.handle()
+
+    def handle(self):
+        # do stuff...
+        pass
+
+class GameState:
+    def __init__(self, targets):
+        self.score = 0
+        self.targets = targets
+        for target in self.targets:
+            target.on(target.hit_key, self.__target_hit__)
+    
+    def __target_hit__(self, target):
+        pass
+
+def snake_to_camel(word):
+    return ''.join(x.capitalize() or '' for x in word.split('_'))
+
+handler = EventHandler(network)
+handler.handle(snake_to_camel('left_flap') + 'EventHandler')
+
+# while True:
+#     event_name = snake_to_camel(network.getInputEvent())
+#     handler.handle(event_name + 'EventHandler')
+
+
+

src/networking/FlippR_Networking.py

@@ -0,0 +1,55 @@
+import requests_unixsocket as req
+import socket
+
+class Networking:
+    def __init__(self, output_server_address, input_socket_address):
+        self.server_address = ""
+        self.input_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.output_session = req.Session()
+        self.server_address = "http+unix://" + output_server_address.replace("/", "%2F")
+        self.input_socket.connect(input_socket_address)
+        print("Connected to " + input_socket_address + " and started server " + self.server_address)
+
+    def get(self, path):
+        response = self.output_session.get(self.server_address + path)
+        assert response.status_code == 200
+        return response
+
+    def getSolenoids(self):
+        return self.get("/solenoids").json()
+    
+    def getSounds(self):
+        return self.get("/sounds").json()
+    
+    def getLamps(self):
+        return self.get("/lamps").json()
+    
+    def getDisplays(self):
+        return self.get("/displays").json()
+
+    def triggerSolenoid(self, solenoid):
+        self.get("/solenoids/" + solenoid + "/trigger")
+
+    def playSound(self, sound):
+        self.get("/sounds/" + sound + "/play")
+
+    def activateLamp(self, lamp):
+        self.get("/lamps/" + lamp + "/activate")
+        
+    def deactivateLamp(self, lamp):
+        self.get("/lamps/" + lamp + "/deactivate")
+        
+    def lampStatus(self, lamp):
+        return self.get("/lamps/" + lamp + "/status").json()
+
+    def writeDisplayScore(self, display, score):
+        self.get("/displays/" + display + "/write_score/" + str(score))
+
+    def getInputEvent(self):
+        header = list()
+        while b'\x02' not in header:
+            byte = self.input_socket.recv(1)
+            header.append(byte)
+        header = [x.decode('utf8') for x in header[:-1]]
+
+        return str().join(header)