########
# Python MUD v0.06 by The13Ghost(at)hotmail.com
########
# some classes for the game... still thinking this out
#
#   -World Classes-
#
#   Objects(Obj) ->  Containers(Cont)
#
#   Containers(Cont) -> Rooms(Room)
#
#   Containers(Cont) -> Mobs(Mob)
#
#   Mobs(Mob) -> (NPCs,Monsters,Misc)(NPC)
#   Mobs(Mob) -> Player(Konnection)
#
#
#   RoomFactory - generates a room list
#   RoomFactory.generate(amount) - generates a random room list
#   RoomFactory.load_from_file(filename) - loads a room list from a file
#
#   -Net handling- merges with world classes by having the client connection
#   part of the Player
#
#   Konnection(dispatcher,Mob)
#   NetServer(dispatcher)
#
#   -Game Logic-
#
#   MUDMsg
#   MessageLoop
#   Command
#
########


from asyncore import *
from socket import *

import string

# Constants and stuff
PLAYER_STATE_LOGIN = 0
PLAYER_STATE_USERNAME = 1
PLAYER_STATE_PASSWORD = 2
PLAYER_STATE_INGAME = 3
PLAYER_STATE_FIGHTING = 4
PLAYER_STATE_SHOPPING = 5
PLAYER_STATE_DEAD = 6

AI_STATE_IDLE = 0
AI_STATE_MOVING = 1
AI_STATE_FIGHTING = 2

# GlobalEvent Queue
globalQueue = []

# rooms list?
rooms = []
npc_definitions = []
npc_list = []

class Obj:

    """ Root Class of all game objects """

    _name = ''
    _location = 0
    _description = ''

    def __init__(self):
        self._name = ''
        self._location = 0

    def __init__(self, name, location):
        self._name = name
        self._location = location

    def move(self, to):
        if self._location != 0:
            rooms[self._location].remove(self)

        self._location = to
        rooms[self._location].insert(self)

    def set_name(self, _string):
        self._name = _string

    def get_name(self):
        return self._name

    def set_description(self, data):
        self._description = data

    def get_description(self):
        return self._description

    def set_location(self, id):
        self._location = id

    def get_location(self):
        return self._location

class Cont (Obj):

    """ A container, all Mobs are containers and rooms as well """

    _inventory = None

    def __init__(self):
        Obj.__init__(self)
        self._inventory = []

    def __init__(self, name, location):
        Obj.__init__(self, name, location)
        self._inventory = []

    def contents(self):
        pass

    def push(self, data):
        pass

    def pop(self):
        pass

    def insert(self, data):
        self._inventory.append(data)

    def remove(self, data):
        self._inventory.remove(data)

    def move(self, to):
        Obj.move(self, to)

class Room (Cont):

    """A Room is just a fancy container"""

    _exits = None
    _hidden = None

    def __init__(self):
        self._name = "void"
        self._description = "You are in nothingness\r\n"
        self._exits = {}
        self._hidden = {}
        Cont.__init__(self, self._name, 0)

    def insert(self, data):
        pass
    def remove(self, data):
        pass

    def get_mobs_amount(self):
        count = 0
        for x in self._inventory:
            if isinstance(x, Mob):
                count += 1
        return count

    def get_mobs(self):
        out = []
        for x in self._inventory:
            if isinstance(x, Mob):
                out.append(x)
        return out

    # hidden Exits
    def update_hidden(self, **new):
        self._hidden.update(new)

    def get_hidden_exits_as_string(self):
        lineToWrite = "\r\nHidden Exits:\r\n"
        for dir in self._hidden:
            lineToWrite += dir + ', '
        return lineToWrite[:-2] + '\r\n'

    def get_hidden_exits(self):
        return self._hidden

    # normal Exits
    def update_exits(self, **new):
        self._exits.update(new)

    def get_exits(self):
        return self._exits

    def get_exits_as_string(self):
        lineToWrite = "\r\nObvious Exits:\r\n"
        for dir in self._exits:
            lineToWrite += dir + ', '
        return lineToWrite[:-2] + '\r\n'

class RoomFactory:

    """ Generate a Random World or Load one from a file """

    def generate(self, amount):
        for x in range(amount):
            rooms.append(Room())

    def load_from_file(self, filename):
        # create room 0
        rooms.append(Room())

        # open the file and read
        goto_next = 0
        currentLine = ''
        r = rooms[0]
        f = open(filename)
        for line in f:
            line = line.strip()

            if len(line) > 0:
                if goto_next > 0:
                    if line[len(line)-1] == '\\' and line[len(line)-2] != '\\':
                        currentLine += '\r\n' + line[:len(line)-1]
                    else:
                        r.set_description(currentLine + '\r\n' + line + '\r\n')
                        goto_next = 0

                elif line[0] == '#':
                    continue
                elif line[0] == 'R' and len(line) > 3:
                    room = int(line[1])
                    rooms.append(Room())
                    r = rooms[room]
                    property = line[2]

                    if property == 'N':
                        if len(line) > 4:
                            line2 = line[4:].strip()
                            newLine = self._return_without_comments(line2)
                            r.set_name(newLine+'\r\n')

                    elif property == 'D':
                        if len(line) > 4:
                            line2 = line[4:].strip()

                            if line2[len(line2)-1] == '\\' and line2[len(line2)-2] != '\\':
                                    currentLine = line2[:len(line2)-1]
                                    goto_next = 1
                            else:
                                r.set_description(line2)
                    elif property == 'X':
                        self._parse_exits(r.update_exits, line)

                    elif property == 'H':
                        self._parse_exits(r.update_hidden, line)

                    elif property == 'C':
                        if len(line) > 4:
                            line2 = line[4:].strip()
                            newLine = self._return_without_comments(line2)

                            storing = 0
                            name = ''

                            FOUND = 0
                            for i in range(len(newLine)):
                                if newLine[i] == '"':
                                    if storing == 1:
                                        storing = 0
                                        for x in npc_definitions:
                                            for y in x.keys():
                                                if name == y:
                                                    FOUND = 1
                                                    n = NPC()
                                                    n.set_name = name
                                                    n.set_description = x['desc']
                                                    n._Hp = x['HP']
                                                    n._Fatigue = x['Fatigue']
                                                    npc_list.append(n)
                                                    r.append(n)
                                        name = ''
                                    else:
                                        storing = 1
                                if storing == 1:
                                    name = name + newLine[i]
        f.close()

    def _parse_exits(self, room_update, line):
        if len(line) > 4:
            newLine = self._return_without_comments(line)

            for i in range(len(newLine)):
                if newLine[i] == 'R':
                    if len(newLine[i:]) > 1:
                        which = room_update
                        direction = newLine[i-1]
                        room = newLine[i+1]
                        self._set_exits(which, direction, room)

    def _set_exits(self, room_update, direction, room):
        if direction == 'N':
            #room_update({'North':room})
            room_update(North=room)

        elif direction == 'S':
            #room_update({'South':room})
            room_update(South=room)

        elif direction == 'W':
            #room_update({'West':room})
            room_update(West=room)

        elif direction == 'E':
            #room_update({'East':room})
            room_update(East=room)

        elif direction == 'U':
            #room_update({'Up':room})
            room_update(Up=room)

        elif direction == 'D':
            #room_update({'Down':room})
            room_update(Down=room)

    def _return_without_comments(self, line):
        comment_pos = line.find('#')

        if comment_pos == -1:
            return line
        elif comment_pos == 0:
            return ''

        done = 0
        while done < 1:
            if line[(comment_pos-1)] == '\\':
                comment_pos = line[(comment_pos+1):].find('#')
                if comment_pos == -1:
                    return line
            else:
                return line[:comment_pos]

class Mob (Cont):

    """ any creature or person or NPC etc """

    _HP = 0
    _Fatigue = 0

    _Endurance = 0
    _Lore = 0
    _Discipline = 0

# Stats-attributes?
#   Hp is the same as in most cases
#   fatigue on the other hand serves another aspect,
#   fatigue serves as the limit for your actions, both magic and physical
#   call up magic? fatigue takes a punch if you call too much power
#   or too often
#   swinging a sword? same application
#
# skills-feats?
# spells? i dunno what i should add >.<

    def __init__(self, name, location):
        Cont.__init__(self, name, location)

    def move(self, to):
        Cont.move(self, to)

class NPC (Mob):

    """should hold all the AI info needed for the system to control the mob"""
# ID
# Personality:
#   Agressive 0
#   defensive 1
#   Passive   2
# movement:
#   static  0
#   wanders 1
# quest related y/n
# shop y/n
# respawns y/n
# unique y/n

    def __init__(self, name, location):
        Mob.__init__(self, name, location)

class NPCLoader:
    def __init__(self):
        pass

    def load_from_file(self, filename):
        # create room 0
        counter = 0
        npc_definitions.append({})
        definition = npc_definitions[counter]

        # open the file and read
        goto_next = 0
        currentLine = ''
        f = open(filename)
        for line in f:
            line = line.strip()

            if len(line) > 0:
                if goto_next > 0:
                    if line[len(line)-1] == '\\' and line[len(line)-2] != '\\':
                        currentLine += '\r\n' + line[:len(line)-1]
                    else:
                        definition.update({'desc':currentLine + '\r\n' + line + '\r\n'})
                        goto_next = 0

                elif line[0] == '#':
                    continue
                elif line[0] == 'N' and len(line) > 3:
                    which = int(line[1])
                    if which == counter:
                        npc_definitions.append({})
                        definition = npc_definitions[counter]
                    property = line[2]

                    if property == 'N':
                        if len(line) > 4:
                            line2 = line[4:].strip()
                            newLine = self._return_without_comments(line2)
                            definition.update({'name':newLine})

                    elif property == 'D':
                        if len(line) > 4:
                            line2 = line[4:].strip()

                            if line2[len(line2)-1] == '\\' and line2[len(line2)-2] != '\\':
                                    currentLine = line2[:len(line2)-1]
                                    goto_next = 1
                            else:
                                definition.update({'desc':line2})
                    elif property == 'A':
                        self._parse_for_attribs(line, definition.update)

                    #elif property == 'H':
                    #   self._parse_exits(r.update_hidden, line)

        f.close()

    def _parse_for_attribs(self,line,update):
        if len(line) > 4:
            newLine = self._return_without_comments(line)

            attrib = ''
            num = ''
            lookfor= 0
            for i in range(len(newLine)):
                if line[i] == ' ' or line[i] == '\t':
                    continue
                if lookfor == 0:
                    if line[i] in string.letters:
                        attrib = attrib + line[i]
                    else:
                        lookfor = 1
                if lookfor == 1:
                    if line[i] in string.letters:
                        num = num + line[i]
                    else:
                        lookfor = 0
                        if attrib == 'HP':
                            update({'HP':int(num)})
                        elif attrib == 'FA':
                            update({'Fatigue':int(num)})
                        attrib = ''
                        num = ''
                        if line[i] in string.letters:
                            attrib = attrib + line[i]
class MUDMsg:

    """Basic class for a MUDMsg"""

    _caller = None
    _contents = None

    def __init__(self, data, caller):
        self._caller = caller
        self._contents = data

    def get_caller(self):
        return self._caller

    def set_caller(self, obj):
        self._caller = obj

    def get_content(self):
        return self._contents

    def set_content(self, data):
        self._contents = data

class MessageLoop:

    """Should be named EventHandler... not sure
       Reads the globalQueue and processes events on it"""

    def handle_messages(self):
        for event in globalQueue:
            caller = event.get_caller()
            callerState = caller.get_state()

            if isinstance(caller, Konnection):
                if callerState == PLAYER_STATE_LOGIN:
                    if event.get_content() == "LOGGING IN":
                        self.greet(caller)
                        caller.write("\r\nUser Name: ")
                        caller.set_state(PLAYER_STATE_USERNAME)

                elif callerState == PLAYER_STATE_USERNAME:
                    if len(event.get_content()) > 0:
                        caller.assign_player(event.get_content(), 0)
                        caller.set_state(PLAYER_STATE_PASSWORD)
                        globalQueue.append(MUDMsg("ENTERING PASSWORD SCREEN", caller))

                elif callerState == PLAYER_STATE_PASSWORD:
                    if event.get_content() == "ENTERING PASSWORD SCREEN":
                        passmasg = "\r\nHi!, " + caller.get_name() + ". Use the Look command. Since this is just for testing" + "\r\nYou will be signed in without an account\r\n"
                        caller.write(passmasg)
                        caller.set_state(PLAYER_STATE_INGAME)
                        caller.move(1)

                elif callerState == PLAYER_STATE_INGAME:
                    Command(caller, event.get_content())
                    self.prompt(caller)

                #elif callerState:
                    #pass

            elif isinstance(event.get_caller(), NPC):
                pass

            globalQueue.remove(event)

    def prompt(self, caller):
        pass

    def greet(self, caller):
        greetmsg = """
        Hello, and welcome to the test Server im working
        on for my newest project!\r\n"""
        caller.write(greetmsg)

class Command:

    """Parses and handles commands"""

    def __init__(self, caller, data):
        if data.lower() == "look":
            self.look(caller)
        elif data == 'exit':
            self.exit(caller)
        elif data.lower() == 'n' or data.lower() == 'north':
            self.move(caller, 'North')
        elif data.lower() == 's' or data.lower() == 'south':
            self.move(caller, 'South')
        elif data.lower() == 'w' or data.lower() == 'west':
            self.move(caller, 'West')
        elif data.lower() == 'e' or data.lower() == 'east':
            self.move(caller, 'East')
        elif data.lower() == 'u' or data.lower() == 'up':
            self.move(caller, 'Up')
        elif data.lower() == 'd' or data.lower() == 'down':
            self.move(caller, 'Down')

    def look(self,caller):
        location = caller.get_location()
        caller.write(rooms[location].get_name())
        caller.write(rooms[location].get_description())
        if rooms[location].get_mobs_amount() > 1:
            out = 'You see '
            for x in rooms[location].get_mobs():
                if not x.get_name() == caller.get_name():
                    out = out + x.get_name() + ', '
            out = out[:-2] + ' in here as well.\r\n'
            caller.write(out)
        caller.write(rooms[location].get_exits_as_string())

    def exit(self,caller):
        caller.write("\r\nDisconectting from server...\r\n")
        caller.end_connection()

    def move(self, caller, dir):
        location = caller.get_location()
        if dir in rooms[location].get_exits():
            caller.move(int(rooms[location].get_exits()[dir]))
        elif dir in rooms[location].get_hidden_exits():
            caller.move(int(rooms[location].get_hidden_exits()[dir]))
        else:
            caller.write("Can't move there\r\n")

class Konnection (dispatcher, Mob):

    """Client Connections"""

    def __init__(self, address, sk, server):
        self.realSelf = self
        dispatcher.__init__(self, sk)
        self.conn = sk
        self.ip = address[0]
        self.server = server
        self.buffer = []
        self.playState = PLAYER_STATE_LOGIN
        self.write("\r\nConnecting to the Server...\r\n")
        print "Login from " + self.ip
        globalQueue.append(MUDMsg("LOGGING IN",self))

    def writable(self):
        return self.buffer

    def end_connection(self):
        self.buffer.append(None)

    def write(self, data):
        self.buffer.append(data)

    def handle_read(self):
        data = self.recv(1024)

        if  data != "\n" and  data != "\r\n":
            data = data.strip()

        if data:
            globalQueue.append(MUDMsg(data, self))

    def handle_write(self):
        if self.buffer[0] is None:
            self.close()
            return

        sent = self.send(self.buffer[0])
        if sent >= len(self.buffer[0]):
            self.buffer.pop(0)
        else:
            self.buffer[0] = self.buffer[0][send:]

    def handle_close(self):
        print "Disconnection from " + self.ip
        self.server.connections.insert(0, self)
        for x in reversed(self.server.connections):
            if x == self.server.connections[0]:
                self.server.connections.remove(x)

    def get_state(self):
        return self.playState

    def set_state(self,STATE):
        self.playState = STATE

    def assign_player(self, name, location):
        self._name = name
        self._location = location

    def move(self, to):
        Mob.move(self, to)
        globalQueue.append(MUDMsg("look",self))

class NetServer (dispatcher):

    """ Server class, listens for incoming connections and passes them off to
        a new Konnection """

    def __init__(self, host, port):
        dispatcher.__init__(self)
        self.create_socket(AF_INET, SOCK_STREAM)
        self.set_reuse_addr()
        self.bind((host,port))
        self.listen(5)
        self.connections = []
        print 'Listening on port ' +  `port` + '.'

    def writable(self):
        return 0

    def handle_accept(self):
        conn, addr= self.accept()
        self.connections.append(Konnection(addr, conn, self))

    def end_server(self):
            self.close()
            for co in self.connections:
                co.write("\r\nSERVER IS SHUTTING DOWN\r\n")
                co.end_connection()

def updateAI():
    pass

# Main

server = NetServer("0.0.0.0",2002)
game = MessageLoop()
rF = RoomFactory()

rF.load_from_file("roomList")

try:
    while 1:
        game.handle_messages()
        updateAI()
        poll() #loop(1.0, count = 1)
except KeyboardInterrupt:
    server.end_server()
    loop(1.0)