dune.py

# Dune client
import select
import socket
import string
import sys
import termios
import threading
import tty

HOST = 'dune.servint.com'
PORT = 6789

NEWLINE = '\n'
MACROS = {
    '1': 'sw',
    '2': 's',
    '3': 'se',
    '4': 'w',
    '5': 'l',
    '6': 'e',
    '7': 'nw',
    '8': 'n',
    '9': 'ne',
    '\x1b[11~': 'F1',   # F1 key
    '\x1b[12~': 'F2',   # F2 key
    '\x1b[13~': 'F3',   # F3 key
    '\x1b[14~': 'F4',   # F4 key
    '\x1b[15~': 'F5',   # F5 key
    '\x1b[17~': 'F6',   # F6 key
    '\x1b[18~': 'F7',   # F7 key
    '\x1b[19~': 'F8',   # F8 key
    '\x1b[20~': 'F9',   # F9 key
    '\x1b[21~': 'F10',  # F10 key
    '\x1b[23~': 'F11',  # F11 key
    '\x1b[24~': 'F12',  # F12 key
    '+': 'plus',
}
GAG = [
    'Newbies: Use portal to access small areas.',
    'A list of the top 40 ranked players',
    'A schedule',
]

def getch():
    fd = sys.stdin.fileno()
    old_settings = termios.tcgetattr(fd)
    try:
        tty.setraw(fd)
        ch = sys.stdin.read(1)
    finally:
        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
    return ch


class mysock(threading.Thread):
    "My socket class"
    def __init__(self,dune_client,host=HOST,port=PORT):
        self.dune = dune_client
        self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.s.settimeout(2)
        self.host = host
        self.port = port
        threading.Thread.__init__(self)
        self.connect()

    def connect(self):
        # connect to remote host
        try :
            self.s.connect((self.host, self.port))
        except :
            print 'Unable to connect'
            sys.exit()

        print 'Connected to remote host'

    def receive(self):
        # Get the list sockets which are readable
        read_sockets, write_sockets, error_sockets = select.select([self.s], [], [])

        data = self.s.recv(4096)
        if not data :
            print 'Connection closed'
            sys.exit()
        else :
            return data

    def send(self,msg):
        self.s.send(msg)

    def run(self):
        while True:
            data = self.receive()
            if self.dune.repr:
                sys.stdout.write('*' * 30)
                sys.stdout.write(repr(data))
                sys.stdout.flush()

            data = self.dune.sanitize_output(data)
            sys.stdout.write(data)
            sys.stdout.flush()

class inputs(object):
    def __init__(self,dune_sock,dune):
        self.dune_sock = dune_sock
        self.dune = dune

    def get_inputs(self):
        ch = getch()
        if self.dune.echo:
            sys.stdout.write(ch)
        data = self.dune.process(ch)
        if data:
            self.dune_sock.send(data)

    def run(self):
        while True:
            self.get_inputs()


class dune(object):
    def __init__(self):
        self.buffer = ''
        self.gag = True
        self.echo = True
        self.repr = False
        self.macro = True

        self.hp = None
        self.cp = None
        self.target = None
        self.slices = 0

    def process(self,ch):
        self.buffer += ch
        self.commands(self.buffer)
        if self.macro and self.buffer in MACROS.keys():
            data = self.buffer
            self.buffer = ''
            return MACROS[data]+NEWLINE
        elif ord(ch) == 13: # enter key
            data = self.buffer
            self.buffer = ''
            return data

    def commands(self,buff):
        if buff.upper() == 'GAG ON':
            self.gag = True
            self.clear_buffer()
            sys.stdout.write('\nGAG SET ON\n')
            sys.stdout.flush()
        elif buff.upper() == 'GAG OFF':
            self.gag = False
            self.clear_buffer()
            sys.stdout.write('\nGAG SET OFF\n')
            sys.stdout.flush()
        elif buff.upper() == 'ECHO ON':
            self.echo = True
            self.clear_buffer()
            sys.stdout.write('\nECHO SET ON\n')
            sys.stdout.flush()
        elif buff.upper() == 'ECHO OFF':
            self.echo = False
            self.clear_buffer()
            sys.stdout.write('\nECHO SET OFF\n')
            sys.stdout.flush()
        elif buff.upper() == 'REPR ON':
            self.repr = True
            self.clear_buffer()
            sys.stdout.write('\nREPR SET ON\n')
            sys.stdout.flush()
        elif buff.upper() == 'REPR OFF':
            self.repr = False
            self.clear_buffer()
            sys.stdout.write('\nREPR SET OFF\n')
            sys.stdout.flush()
        elif buff.upper() == 'MACRO ON':
            self.macro = True
            self.clear_buffer()
            sys.stdout.write('\nMACRO SET ON\n')
            sys.stdout.flush()
        elif buff.upper() == 'MACRO OFF':
            self.macro = False
            self.clear_buffer()
            sys.stdout.write('\nMACRO SET OFF\n')
            sys.stdout.flush()

    def clear_buffer(self):
        self.buffer = ''

    def sanitize_output(self,data):
        if self.gag:
            for line in GAG:
                data = data.replace(line,'')
            while '\r\n\r\n' in data:
                data = data.replace('\r\n\r\n','\r\n')
        return data


def main():
    try:
        dune_client = dune()
        dune_socket = mysock(dune_client)
        myinputs = inputs(dune_socket,dune_client)
        dune_socket.start()
        myinputs.run()
        dune_socket.join()
    except socket.error:
        pass

if __name__ == "__main__":
    main()