root/adventure/world.py

# -*- coding: utf-8 -*-

#  MUDMUC
#  world.py
#  Copyright (c) 2008 Thibaut Girka, Anaël Verrier

#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; version 3 only.

#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.

#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

from os.path import dirname, abspath
from xml.dom.minidom import parse as xml_parse

from xmpp import Message, Presence, NS_MUC_USER, JID
from xmpp_error import Error

from place import Place
from player import Player
from thing import Thing, NonPlayableCharacter

class World(object):
    """ World class.
    Worlds have their own JID and correspond to an xml file """
    def __init__(self, muc, filename):
        """ Init a world.
        muc is the MUC component handling messages and presences.
        filename is the world's filename. """
        self.muc = muc
        self.places = dict() # { place_name: Place() }
        self.players = list()
        self.things = list()
        self.npcs = list()
        
        self.data_dir = dirname(abspath(filename))

        self.bag = Player(self, 'Bag', 'Bag')
        self.bag.presence = Presence()
        self.bag.presence.setShow('available')
        self.bag.presence.setStatus('A bag (your inventory)')
        self.bag.presence = self.bag.fix_presence('moderator', 'owner')
        self.bag.set_vcard('bag.png')

        doc = xml_parse(filename)
        doc_getAttribute = doc.documentElement.getAttribute
        self.node = doc_getAttribute('node')
        self.name = doc_getAttribute('name')
        self.start = doc_getAttribute('start')
        get_elements = doc.documentElement.getElementsByTagName
        places = get_elements('place')
        
        # Parsing places
        for place in places:
            place_obj = Place(self,
                place.getAttribute('name'),
                place.getElementsByTagName('description')[0].firstChild.data)
            self.places[place_obj.name] = place_obj
            
            # Parsing exits of the place
            gos = place.getElementsByTagName('go')
            for go in gos:
                place_obj.exits[
                    go.getAttribute('spec')] = go.getAttribute('place')
            
            # Parsing NPCs in the place
            npcs = place.getElementsByTagName('npc')
            for npc in npcs:
                npc_obj = NonPlayableCharacter(self,
                                            npc.getAttribute('name'),
                                            npc.getAttribute('name'),
                                            place_obj)
                npc_obj.add_aliases(npc_obj.aliases,
                                    npc.getAttribute('aliases'))
                
                # Parsing NPC presence
                pres = Presence()
                presences = npc.getElementsByTagName('presence')
                image = None
                if len(presences):
                    # Set up NPC status
                    shows = presences[0].getElementsByTagName('show')
                    if len(shows):
                        pres.setShow(shows[0].firstChild.data)
                    status = presences[0].getElementsByTagName('status')
                    if len(status):
                        pres.setStatus(status[0].firstChild.data)
                    images = presences[0].getElementsByTagName('image')
                    if len(images):
                        image = images[0].firstChild.data
                npc_obj.presence = pres
                npc_obj.presence = npc_obj.fix_presence()
                npc_obj.set_vcard(image)
                
                # Add NPC to the World and to the Place
                place_obj.npcs.append(npc_obj)
                self.npcs.append(npc_obj)
                
                # Parse NPC's commands
                commands = npc.getElementsByTagName('commands')
                if len(commands):
                    commands = commands[0].getElementsByTagName('command')
                    npc_obj.parse_commands(commands)
                
                # Set up NPC's on-enter event
                on_enters = npc.getElementsByTagName('on-enter')
                for on_enter in on_enters:
                    actions = on_enter.getElementsByTagName('*')
                    on_enter_obj = dict()
                    on_enter_obj['target'] = on_enter.getAttribute('target').strip()
                    on_enter_obj['actions'] = list()
                    npc_obj.on_enters.append(on_enter_obj)
                    for action in actions:
                        npc_obj.parse_action(on_enter_obj['actions'], action)
                
                # Set up NPC's on-enter event
                on_leaves = npc.getElementsByTagName('on-leave')
                for on_leave in on_leaves:
                    actions = on_leave.getElementsByTagName('*')
                    on_leave_obj = dict()
                    on_leave_obj['target'] = on_leave.getAttribute('target').strip()
                    on_leave_obj['actions'] = list()
                    npc_obj.on_leaves.append(on_leave_obj)
                    for action in actions:
                        npc_obj.parse_action(on_leave_obj['actions'], action)
                
                # Set up NPC's on-self-enter event
                on_self_enters = npc.getElementsByTagName('on-self-enter')
                if len(on_self_enters):
                    actions = on_self_enters[0].getElementsByTagName('*')
                    for action in actions:
                        npc_obj.parse_action(npc_obj.on_self_enter, action)
                
                # Set up NPC's on-self-leave event
                on_self_leave = npc.getElementsByTagName('on-self-leave')
                if len(on_self_leave):
                    actions = on_self_leave[0].getElementsByTagName('*')
                    for action in actions:
                        npc_obj.parse_action(npc_obj.on_self_leave, action)
        
            # Parsing Things in the place
            things = place.getElementsByTagName('thing')
            for thing in things:
                thing_obj = Thing(self, thing.getAttribute('name'), place_obj)
                thing_obj.add_aliases(thing_obj.aliases, thing.getAttribute('aliases'))
                
                # Add Thing to the World and to the Place
                place_obj.things.append(thing_obj)
                self.things.append(thing_obj)
                
                # Parse Thing's commands
                commands = thing.getElementsByTagName('commands')
                if len(commands):
                    commands = commands[0].getElementsByTagName('command')
                    thing_obj.parse_commands(commands)
                
                # Set up Thing's on-enter event
                on_enters = thing.getElementsByTagName('on-enter')
                for on_enter in on_enters:
                    actions = on_enter.getElementsByTagName('*')
                    on_enter_obj = dict()
                    on_enter_obj['target'] = on_enter.getAttribute('target').strip()
                    on_enter_obj['actions'] = list()
                    thing_obj.on_enters.append(on_enter_obj)
                    for action in actions:
                        thing_obj.parse_action(on_enter_obj['actions'], action)
                
                # Set up Thing's on-enter event
                on_leaves = thing.getElementsByTagName('on-leave')
                for on_leave in on_leaves:
                    actions = on_leave.getElementsByTagName('*')
                    on_leave_obj = dict()
                    on_leave_obj['target'] = on_leave.getAttribute('target').strip()
                    on_leave_obj['actions'] = list()
                    thing_obj.on_leaves.append(on_leave_obj)
                    for action in actions:
                        thing_obj.parse_action(on_leave_obj['actions'], action)



    def send(self, resource, stanza):
        """ Send stanza through the room """
        # Avoid sending to things without JID
        if stanza.getTo():
            self.muc.snd(self.node, resource, stanza)

    def place(self, placename):
        """ Return the Place whose name is placename """
        if self.places.has_key(placename):
            return self.places[placename]
        return None

    def move_thing(self, thing, newplace, warning=True):
        """ Move thing thing to its new place """
        thing.move_to(self.place(newplace), warning)

    def handle_presence(self, pres):
        """ Handle presence stanzas coming to the room """
        # A help for the irritated first:
        if pres.getType() == 'subscribe':
            msg = Message(pres.getFrom())
            msg.setType('normal')
            msg.setSubject('Adventure component help')
            msg.setBody('You don\'t need to subscribe to my presence. '
                        'Simply use your Jabber client to join the MUC or '
                        'conference at %s' % pres.getTo())
            self.send(None, msg)
            return True

        # Look if player is already known
        player = None
        for thing in self.players:
            if pres.getTo().getResource() == thing.name:
                player = thing

            # Disallow nick changes
            if (pres.getFrom() == thing.jid and player != thing):
                answer = Error(pres, 'not-acceptable',
                               'Nickchange not allowed')
                self.send(thing.name, answer)
                return True
        
        # Either nick-collission or empty nick
        if (player and pres.getFrom() != player.jid or
            len(pres.getTo().getResource()) < 2):
            answer = None
            if len(pres.getTo().getResource()) > 1:
                answer = Error(pres, 'conflict', 'Nickname already used')
            else:
                answer = Error(pres, 'not-acceptable', 'Please use a nickname')
            self.send(None, answer)
            return True
        
        # Disallow nick "Bag", since it's used internally by the MUD
        if pres.getTo().getResource() == 'Bag':
            answer = Error(pres, 'not-acceptable', 'Nickname already used by a non-playbable character')
            self.send(None, answer)
            return True
        
        # Nick-collision with a NPC
        for npc in self.npcs:
            if npc.name == pres.getTo().getResource():
                answer = Error(pres, 'not-acceptable', 'Nickname already used by a non-playbable character')
                self.send(None, answer)
                return True

        # Add the valid player
        if not player:
            player = Player(self, pres.getTo().getResource(), pres.getFrom())
            player.presence = pres
            self.players.append(player)
            self.move_thing(player, self.start)
            
            # Send the bag presence to the player:
            player.send_presence('Bag', self.bag.presence)
        # Or broadcast updated presence
        else:
            player.presence = pres
            
            player.place.broadcast_status(player)
    
        # Remove the player instantly
        if pres.getType() in ('error', 'unavailable'):
            self.move_thing(player, None, warning=False)
            self.players.remove(player)

    def handle_message(self, msg):
        """ Handle message stanzas coming to the MUC """
        player = None
        
        # Search the player by its JID
        for thing in self.players:
            if msg.getFrom() == thing.jid:
                player = thing

        # If the player were not found, send an answer to the message
        if not player:
            answer = Error(msg, 'forbidden')
            self.send(msg.getTo().getResource(), answer)
            return True
        elif msg.getTo() == JID(node=self.node,
                                domain=self.muc.jid.getDomain()):
            tag_x = msg.getTag('x')
            if tag_x:
                tag_invite = tag_x.getTag('invite')
                # Is the message an invitation?
                if tag_invite:
                    self.send_invitation(msg.getTo(),
                                         tag_invite.getAttr('to'))
        elif msg.getTo().getResource() == 'Bag':
            self.bag_command(player, msg.getBody())
            return True
        
        if msg.getTo().getResource():
            for visitor in player.place.visitors:
                if visitor.name == msg.getTo().getResource():
                    visitor.send_message(player.name, msg.getBody(),
                                         msg_type='normal')
                    return True
            for npc in player.place.npcs:
                if npc.name == msg.getTo().getResource():
                    player.send_message(npc.name,
                                        'Sorry, I\'m a NPC, you can\'t send private messages to me.',
                                        msg_type='normal')
                    return True
        # Parse the content. If not handled, broadcast it.
        if not self.command(player, msg.getBody()):
            player.say(msg.getBody())

    def send_invitation(self, from_, to_):
        """ Send an invitation to jid to_ from jid from_ """
        msg = Message(to_)
        msg.setFrom(JID(node=self.node, domain=self.muc.jid.getDomain()))
        msg_x = msg.setTag(NS_MUC_USER + ' x')
        msg_invite = msg_x.setTag(NS_MUC_USER + ' invite')
        msg_invite.setAttr('from', from_)
        msg_reason = msg_invite.setTag(NS_MUC_USER + ' reason')
        msg_reason.setData('Join the super MUDMUC!(World %s)' % self.name)
        self.send(None, msg)

    def bag_command(self, player, text):
        """ Try to parse commands or return False if not handled """
        if text in ('list', 'ls'):
            
            temp_items = list()
            temp_numbers = list()
            for item in player.inventory:
                if item in temp_items:
                    temp_numbers[temp_items.index(item)] += 1
                else:
                    temp_items.append(item)
                    temp_numbers.append(1)
            if not len(temp_items):
                player.send_message('Bag', 'Your bag is empty!',
                                    msg_type='normal')
            elif len(temp_items) == 1:
                player.send_message('Bag',
                                    'Your bag contains: %s (x%d)'
                                        % (temp_items[0], temp_numbers[0]),
                                    msg_type='normal')
            else:
                answer_text = 'Your bag contains: '
                for item_i in xrange(len(temp_items)-1):
                    answer_text += '%s (x%d), ' % (temp_items[item_i],
                                                   temp_numbers[item_i])
                answer_text += 'and %s (x%d)' % (temp_items[len(temp_items)-1], temp_numbers[len(temp_numbers)-1])
                player.send_message('Bag', answer_text, msg_type='normal')
        else:
            player.send_message('Bag', 'I don\'t want to chat. If you want to use me, type ls or list', msg_type='normal')

    def command(self, player, text):
        """ Try to parse commands or return False if not handled """
        if text in ('?', '!help'):
            player.send_message('Help!', '(Command) who')
            player.send_message('Help!', '(Command) inventory')
            place = player.place
            if place:
                for exit_name in place.exits.keys():
                    player.send_message('Help!', '(Command) go %s' % exit_name)
            for thing in (player.place.npcs + player.place.things):
                for c in thing.commands:
                    if len(c['name']) > 3:
                        has_required = True
                        for i in c['objects']:
                            if i not in player.inventory:
                                has_required = False
                                break
                        if has_required:
                            player.send_message('Help!',
                                                '(Command) %s'
                                                  % (c['name'].replace('<<self>>',
                                                     thing.name)))
            return True
        elif text:
            words = text.split(' ')
            cmd = words.pop(0)
            if len(words):
                what = words.pop(0)
            else:
                what = ''
            if cmd == 'go':
                oldplace = player.place
                newplace = None

                for name, place in oldplace.exits.items():
                    if name.lower() == what.lower():
                        newplace = place

                if newplace:
                    self.move_thing(player, newplace)
                else:
                    player.send_message(None, 'You cannot go there')
                return True
            elif cmd == 'inventory':
                self.bag_command(player, 'ls')
                return True
            elif cmd == 'who':
                player.send_message(None, 'Players in "%s":' % self.name)
                for thing in self.players:
                    player.send_message(None,
                                        ' - %s is at/in %s' % (thing.name,
                                                              thing.place.name))
                return True
            else:
                handled = False
                for thing in (player.place.npcs + player.place.things):
                    if thing.handle_command(text, player):
                        handled = True
                if handled:
                    return True
        return False