twgs-proxy/flexible.py

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()