More restructuring. Things still seem to be working.

flexible.py

@@ -0,0 +1,241 @@
+from twisted.internet import reactor
+from twisted.internet import task
+from twisted.internet import defer
+from colorama import Fore, Back, Style
+from twisted.python import log
+
+import pendulum
+
+
+def merge(color_string):
+    """ Given a string of colorama ANSI, merge them if you can. """
+    return color_string.replace("m\x1b[", ";")
+
+
+class PlayerInput(object):
+    def __init__(self, game):
+        # I think game gives us access to everything we need
+        self.game = game
+        self.observer = self.game.observer
+        self.save = None
+        self.deferred = None
+        self.queue_game = game.queue_game
+
+        # default colors, and useful consts
+        self.c = merge(Style.BRIGHT + Fore.WHITE + Back.BLUE)
+        self.r = Style.RESET_ALL
+        self.nl = "\n\r"
+        self.bsb = "\b \b"
+        self.keepalive = None
+
+    def color(self, c):
+        self.c = c
+
+    def alive(self):
+        log.msg("PlayerInput.alive()")
+        self.game.queue_player.put(" ")
+
+    def prompt(self, prompt, limit, default=""):
+        log.msg("PlayerInput({0}, {1}, {2}".format(prompt, limit, default))
+        self.prompt = prompt
+        self.limit = limit
+        self.default = default
+        self.input = ""
+        assert self.save is None
+        assert self.keepalive is None
+
+        # Note: This clears out the server "keep alive"
+        self.save = self.observer.save()
+        self.observer.connect("player", self.get_input)
+
+        self.keepalive = task.LoopingCall(self.alive)
+        self.keepalive.start(30)
+
+        # We need to "hide" the game output.
+        # Otherwise it WITH mess up the user input display.
+        self.to_player = self.game.to_player
+        self.game.to_player = False
+
+        # Display prompt
+        self.queue_game.put(self.r + self.nl + self.c + prompt)
+        # Set "Background of prompt"
+        self.queue_game.put(" " * limit + "\b" * limit)
+
+        assert self.deferred is None
+        d = defer.Deferred()
+        self.deferred = d
+        log.msg("Return deferred ...", self.deferred)
+        return d
+
+    def get_input(self, chunk):
+        """ Data from player (in bytes) """
+        chunk = chunk.decode("utf-8", "ignore")
+
+        for ch in chunk:
+            if ch == "\b":
+                if len(self.input) > 0:
+                    self.queue_game.put(self.bsb)
+                    self.input = self.input[0:-1]
+                else:
+                    self.queue_game.put("\a")
+            if ch == "\r":
+                self.queue_game.put(self.r + self.nl)
+                log.msg("Restore observer dispatch", self.save)
+                assert not self.save is None
+                self.observer.load(self.save)
+                self.save = None
+                log.msg("Disable keepalive")
+                self.keepalive.stop()
+                self.keepalive = None
+                line = self.input
+                self.input = ""
+                assert not self.deferred is None
+
+                # Ok, use deferred.callback, or reactor.callLater?
+                # self.deferred.callback(line)
+                reactor.callLater(0, self.deferred.callback, line)
+                self.deferred = None
+            if ch.isprintable():
+                if len(self.input) + 1 <= self.limit:
+                    self.input += ch
+                    self.queue_game.put(ch)
+                else:
+                    self.queue_game.put("\a")
+
+    def output(self, line):
+        """ A default display of what they just input. """
+        log.msg("PlayerInput.output({0})".format(line))
+        self.game.queue_game.put(self.r + self.nl + "[{0}]".format(line) + self.nl)
+        return line
+
+
+class ProxyMenu(object):
+    def __init__(self, game):
+        self.nl = "\n\r"
+        self.c = merge(Style.BRIGHT + Fore.YELLOW + Back.BLUE)
+        self.r = Style.RESET_ALL
+        self.c1 = merge(Style.BRIGHT + Fore.BLUE)
+        self.c2 = merge(Style.NORMAL + Fore.BLUE)
+
+        self.game = game
+        self.queue_game = game.queue_game
+        self.observer = game.observer
+        # Yes, at this point we would activate
+        self.prompt = game.buffer
+        self.save = self.observer.save()
+        self.observer.connect("player", self.player)
+        # If we want it, it's here.
+        self.defer = None
+
+        self.keepalive = task.LoopingCall(self.awake)
+        self.keepalive.start(30)
+        self.menu()
+
+    def __del__(self):
+        log.msg("ProxyMenu {0} RIP".format(self))
+
+    def whenDone(self):
+        self.defer = defer.Deferred()
+        # Call this to chain something after we exit.
+        return self.defer
+
+    def menu(self):
+        self.queue_game.put(
+            self.nl + self.c + "TradeWars Proxy active." + self.r + self.nl
+        )
+
+        def menu_item(ch, desc):
+            self.queue_game.put(
+                " " + self.c1 + ch + self.c2 + " - " + self.c1 + desc + self.nl
+            )
+
+        self.queue_game.put(
+            " " + self.c1 + "D" + self.c2 + " - " + self.c1 + "Diagnostics" + self.nl
+        )
+        menu_item("Q", "Quest")
+        menu_item("T", "Display current Time")
+
+        self.queue_game.put(
+            " "
+            + self.c1
+            + "P"
+            + self.c2
+            + " - "
+            + self.c1
+            + "Port CIM Report"
+            + self.nl
+        )
+
+        self.queue_game.put(
+            " " + self.c1 + "S" + self.c2 + " - " + self.c1 + "Scripts" + self.nl
+        )
+        self.queue_game.put(
+            " " + self.c1 + "X" + self.c2 + " - " + self.c1 + "eXit" + self.nl
+        )
+        self.queue_game.put("   " + self.c + "-=>" + self.r + " ")
+
+    def awake(self):
+        log.msg("ProxyMenu.awake()")
+        self.game.queue_player.put(" ")
+
+    def player(self, chunk):
+        """ Data from player (in bytes). """
+        chunk = chunk.decode("utf-8", "ignore")
+        key = chunk.upper()
+        log.msg("ProxyMenu.player({0})".format(key))
+
+        # Stop the keepalive if we are activating something else
+        # or leaving...
+        self.keepalive.stop()
+
+        if key == "T":
+            self.queue_game.put(self.c + key + self.r + self.nl)
+            # perform T option
+            now = pendulum.now()
+            self.queue_game.put(
+                self.nl + self.c1 + "Current time " + now.to_datetime_string() + self.nl
+            )
+        elif key == "Q":
+            self.queue_game.put(self.c + key + self.r + self.nl)
+
+            # Ok, keepalive is stop(), and we are leaving this.
+            # So, when the PlayerInput is done, have it call welcome_back,
+            # which reinstates keepalive, and displays the menu.
+
+            ask = PlayerInput(self.game)
+            d = ask.prompt("What is your quest? ", 20)
+
+            # Display the user's input
+            d.addCallback(ask.output)
+            # To "return" to the ProxyMenu, call self.welcome_back
+            d.addCallback(self.welcome_back)
+            return
+
+        elif key == "X":
+            self.queue_game.put(self.c + key + self.r + self.nl)
+            self.observer.load(self.save)
+            self.save = None
+            # It isn't running (NOW), so don't try to stop it.
+            # self.keepalive.stop()
+            self.keepalive = None
+            self.queue_game.put(self.prompt)
+            self.prompt = None
+
+            # Possibly:  Send '\r' to re-display the prompt
+            # instead of displaying the original one.
+
+            # Were we asked to do something when we were done here?
+            if self.defer:
+                reactor.CallLater(0, self.defer.callback)
+                # self.defer.callback()
+                self.defer = None
+            return
+
+        self.keepalive.start(30, True)
+        self.menu()
+
+    def welcome_back(self, *_):
+        log.msg("welcome_back")
+        self.keepalive.start(30, True)
+        self.menu()
+

tcp-proxy.py

@@ -72,214 +72,24 @@ def cleanANSI(line):
     return cleaner.sub("", line)
     # return re.sub(r'\x1b\[([0-9,A-Z]{1,2}(;[0-9]{1,2})?(;[0-9]{3})?)?[m|K]?', '', line)
 
-PORT_CLASSES = { 1: 'BBS', 2: 'BSB', 3: 'SBB', 4:'SSB', 5:'SBS', 6:'BSS', 7:'SSS', 8:'BBB'}
-CLASSES_PORT = { v: k for k,v in PORT_CLASSES.items() }
 
-from observer import Observer
-
-class PlayerInput(object):
-    def __init__(self, game):
-        # I think game gives us access to everything we need
-        self.game = game
-        self.observer = self.game.observer
-        self.save = None
-        self.deferred = None
-        self.queue_game = game.queue_game
-
-        # default colors, and useful consts
-        self.c = merge(Style.BRIGHT + Fore.WHITE + Back.BLUE)
-        self.r = Style.RESET_ALL
-        self.nl = "\n\r"
-        self.bsb = "\b \b"
-        self.keepalive = None
-
-    def color(self, c):
-        self.c = c
-
-    def alive(self):
-        log.msg("PlayerInput.alive()")
-        self.game.queue_player.put(" ")
-
-    def prompt(self, prompt, limit, default=''):
-        log.msg("PlayerInput({0}, {1}, {2}".format(prompt, limit, default))
-        self.prompt = prompt
-        self.limit = limit
-        self.default = default
-        self.input = ''
-        assert(self.save is None)
-        assert(self.keepalive is None)
-
-        # Note: This clears out the server "keep alive"
-        self.save = self.observer.save()
-        self.observer.connect('player', self.get_input)
-
-        self.keepalive = task.LoopingCall(self.alive)
-        self.keepalive.start(30)
-
-        # We need to "hide" the game output.
-        # Otherwise it WITH mess up the user input display.
-        self.to_player = self.game.to_player
-        self.game.to_player = False
-
-        # Display prompt
-        self.queue_game.put(self.r + self.nl + self.c + prompt)
-        # Set "Background of prompt"
-        self.queue_game.put( " " * limit + "\b" * limit)
-
-        assert(self.deferred is None)
-        d = defer.Deferred()
-        self.deferred = d
-        log.msg("Return deferred ...", self.deferred)
-        return d
-
-    def get_input(self, chunk):
-        """ Data from player (in bytes) """
-        chunk = chunk.decode('utf-8', 'ignore')
-
-        for ch in chunk:
-            if ch == "\b":
-                if len(self.input) > 0:
-                    self.queue_game.put(self.bsb)
-                    self.input = self.input[0:-1]
-                else:
-                    self.queue_game.put("\a")
-            if ch == "\r":
-                self.queue_game.put(self.r + self.nl)
-                log.msg("Restore observer dispatch", self.save)
-                assert(not self.save is None)
-                self.observer.load(self.save)
-                self.save = None
-                log.msg("Disable keepalive")
-                self.keepalive.stop()
-                self.keepalive = None
-                line = self.input
-                self.input = ''
-                assert(not self.deferred is None)
-
-                # Ok, use deferred.callback, or reactor.callLater?
-                # self.deferred.callback(line)
-                reactor.callLater(0, self.deferred.callback, line)
-                self.deferred = None
-            if ch.isprintable():
-                if len(self.input) + 1 <= self.limit:
-                    self.input += ch
-                    self.queue_game.put(ch)
-                else:
-                    self.queue_game.put("\a")
-
-    def output(self, line):
-        """ A default display of what they just input. """
-        log.msg("PlayerInput.output({0})".format(line))
-        self.game.queue_game.put(self.r + self.nl + "[{0}]".format(line) + self.nl)
-        return line
-
-class ProxyMenu(object):
-    def __init__(self, game):
-        self.nl = "\n\r"
-        self.c = merge(Style.BRIGHT + Fore.YELLOW + Back.BLUE)
-        self.r = Style.RESET_ALL
-        self.c1 = merge(Style.BRIGHT + Fore.BLUE)
-        self.c2 = merge(Style.NORMAL + Fore.BLUE)
-
-        self.game = game
-        self.queue_game = game.queue_game
-        self.observer = game.observer
-        # Yes, at this point we would activate
-        self.prompt = game.buffer
-        self.save = self.observer.save()
-        self.observer.connect("player", self.player)
-        # If we want it, it's here.
-        self.defer = None
-
-        self.keepalive = task.LoopingCall(self.awake)
-        self.keepalive.start(30)
-        self.menu()
-
-    def __del__(self):
-        log.msg("ProxyMenu {0} RIP".format(self))
-
-    def whenDone(self):
-        self.defer = defer.Deferred()
-        # Call this to chain something after we exit.
-        return self.defer
-
-    def menu(self):
-        self.queue_game.put(self.nl + self.c + "TradeWars Proxy active." + self.r + self.nl)
-        def menu_item(ch, desc):
-            self.queue_game.put(" " + self.c1 + ch + self.c2 + " - " + self.c1 + desc + self.nl)
-
-        self.queue_game.put(" " + self.c1 + "D" + self.c2 + " - " + self.c1 + "Diagnostics" + self.nl)        
-        menu_item("Q", "Quest")
-        menu_item("T", "Display current Time")
-
-        self.queue_game.put(" " + self.c1 + "P" + self.c2 + " - " + self.c1 + "Port CIM Report" + self.nl)
-        
-        self.queue_game.put(" " + self.c1 + "S" + self.c2 + " - " + self.c1 + "Scripts" + self.nl)
-        self.queue_game.put(" " + self.c1 + "X" + self.c2 + " - " + self.c1 + "eXit" + self.nl)
-        self.queue_game.put("   " + self.c + "-=>" + self.r + " ")
-
-    def awake(self):
-        log.msg("ProxyMenu.awake()")
-        self.game.queue_player.put(" ")
-
-    def player(self, chunk):
-        """ Data from player (in bytes). """
-        chunk = chunk.decode("utf-8", 'ignore')
-        key = chunk.upper()
-        log.msg("ProxyMenu.player({0})".format(key))
-
-        # Stop the keepalive if we are activating something else
-        # or leaving...
-        self.keepalive.stop()
-
-        if key == "T":
-            self.queue_game.put(self.c + key + self.r + self.nl)
-            # perform T option
-            now = pendulum.now()
-            self.queue_game.put(self.nl + self.c1 + "Current time " + now.to_datetime_string() + self.nl)
-        elif key == 'Q':
-            self.queue_game.put(self.c + key + self.r + self.nl)
-
-            # Ok, keepalive is stop(), and we are leaving this.
-            # So, when the PlayerInput is done, have it call welcome_back,
-            # which reinstates keepalive, and displays the menu.
-
-            ask = PlayerInput(self.game)
-            d = ask.prompt("What is your quest? ", 20)
-
-            # Display the user's input
-            d.addCallback(ask.output)
-            # To "return" to the ProxyMenu, call self.welcome_back
-            d.addCallback(self.welcome_back)
-            return
-
-        elif key == 'X':
-            self.queue_game.put(self.c + key + self.r + self.nl)
-            self.observer.load(self.save)
-            self.save = None
-            # It isn't running (NOW), so don't try to stop it.
-            # self.keepalive.stop()
-            self.keepalive = None
-            self.queue_game.put(self.prompt)
-            self.prompt = None
-
-            # Were we asked to do something when we were done here?
-            if self.defer:
-                reactor.CallLater(0, self.defer.callback)
-                # self.defer.callback()
-                self.defer = None
-            return
+PORT_CLASSES = {
+    1: "BBS",
+    2: "BSB",
+    3: "SBB",
+    4: "SSB",
+    5: "SBS",
+    6: "BSS",
+    7: "SSS",
+    8: "BBB",
+}
+CLASSES_PORT = {v: k for k, v in PORT_CLASSES.items()}
 
-        self.keepalive.start(30, True)
-        self.menu()
-
-    def welcome_back(self, _):
-        log.msg("welcome_back")
-        self.keepalive.start(30, True)
-        self.menu()
-        
+from observer import Observer
 
 from mcp import MCP
+from flexible import PlayerInput, ProxyMenu
+
 
 class Game(protocol.Protocol):
     def __init__(self):
@@ -328,14 +138,14 @@ class Game(protocol.Protocol):
             log.msg(">> [{0}]".format(line))
 
         # if "TWGS v2.20b" in line and "www.eisonline.com" in line:
-            # I would still love to "inject" this into the stream
-            # so it is consistent.
+        # I would still love to "inject" this into the stream
+        # so it is consistent.
 
-            # self.queue_game.put(
-            #     "TWGS Proxy build "
-            #     + version
-            #     + " is active. \x1b[1;34m~\x1b[0m to activate.\n\r\n\r",
-            # )
+        # self.queue_game.put(
+        #     "TWGS Proxy build "
+        #     + version
+        #     + " is active. \x1b[1;34m~\x1b[0m to activate.\n\r\n\r",
+        # )
 
         if "TradeWars Game Server" in line and "Copyright (C) EIS" in line:
             # We are not in a game
@@ -374,16 +184,22 @@ class Game(protocol.Protocol):
         # Store the text into the buffer before we inject into it.
 
         self.buffer += chunk.decode("utf-8", "ignore")
-        # log.msg("data: [{0}]".format(repr(chunk))) 
+        # log.msg("data: [{0}]".format(repr(chunk)))
 
-        if b'TWGS v2.20b' in chunk and b'www.eisonline.com' in chunk:
+        if b"TWGS v2.20b" in chunk and b"www.eisonline.com" in chunk:
             # Ok, we have a possible target.
-            target = b'www.eisonline.com\n\r'
+            target = b"www.eisonline.com\n\r"
             pos = chunk.find(target)
             if pos != -1:
                 # Found it!  Inject!
-                message = "TWGS Proxy build " + version + ".  ~ to activate in game.\n\r"
-                chunk = chunk[0:pos + len(target)] + message.encode() + chunk[pos + len(target):]
+                message = (
+                    "TWGS Proxy build " + version + ".  ~ to activate in game.\n\r"
+                )
+                chunk = (
+                    chunk[0 : pos + len(target)]
+                    + message.encode()
+                    + chunk[pos + len(target) :]
+                )
 
         # Sequence error:
         # If I don't put the chunk(I received) to the player.
@@ -421,7 +237,7 @@ class Game(protocol.Protocol):
 
     def connectionLost(self, why):
         log.msg("Game connectionLost because: %s" % why)
-        self.observer.emit('close', why)
+        self.observer.emit("close", why)
         self.queue_game.put(False)
         self.transport.loseConnection()
 
@@ -527,7 +343,7 @@ class Player(protocol.Protocol):
         if not self.observer.emit("player", chunk):
             # Was not dispatched.  Send to game.
             self.queue_player.put(chunk)
-        
+
         else:
             # There's an observer.  Don't continue.
             return
@@ -554,11 +370,9 @@ class Player(protocol.Protocol):
             # if re.match(r"Command \[TL=.* \(\?=Help\)\? :", prompt):
             menu = ProxyMenu(self.game)
 
-
-
     def connectionLost(self, why):
         log.msg("lost connection %s" % why)
-        self.observer.emit('close', why)        
+        self.observer.emit("close", why)
         self.queue_player.put(False)
 
     def connectionFailed(self, why):