root/adventure/thing.py

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

#  MUDMUC
#  thing.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 movable import Movable

class Thing(object):
    def __init__(self, world, name, place):
        self.world = world
        self.name = name
        self.place = place
        self.aliases = [name,] # Alternative names
        self.commands = list() # List of dicts : name, actions : list()
        self.on_enters = list()
        self.on_leaves = list()
    
    def add_aliases(self, aliases_obj, alias_str):
        """ Safely add aliases """
        if not (isinstance(alias_str, str) or isinstance(alias_str, unicode)):
            return False
        if alias_str:
            aliases = alias_str.split(',')
            for alias in aliases:
                if alias:
                    aliases_obj.append(alias.strip())
    
    def parse_commands(self, command_elements):
        """ Parse commands and store them in self.commands """
        for command in command_elements:
            if command.getAttribute('objects'):
                objects = command.getAttribute('objects').split(',')
                required_objects = tuple(objects)
            else:
                required_objects = tuple()
            command_obj = dict()
            command_obj['name'] = command.getAttribute('name').replace('%self%', '<<self>>')
            command_obj['name'] = command_obj['name'] % required_objects
            command_obj['aliases'] = list()
            command_obj['aliases'].append(command_obj['name'])
            command_obj['actions'] = list()
            command_obj['signal'] = command.getAttribute('signal').strip()
            command_obj['objects'] = list(required_objects)
            
            aliases = command.getAttribute('aliases')
            self.add_aliases(command_obj['aliases'], aliases)
            
            action_elements = command.getElementsByTagName('*')
            for i in action_elements:
                self.parse_action(command_obj['actions'], i)
            self.commands.append(command_obj)
        
    def parse_action(self, action_list, action_element):
        """
        Parse action_element (xml.dom.minidom.Element)
        and append each action in action_list
        """
        action_obj = dict()
        action_obj['name'] = action_element.localName
        
        action_obj['target'] = action_element.getAttribute('target')
        if action_element.hasAttribute('count'):
            action_obj['count'] = int(action_element.getAttribute('count'))
        
        if action_element.firstChild and action_element.firstChild.data:
            action_obj['params'] = action_element.firstChild.data.strip()
        action_list.append(action_obj)

    def do_action(self, action, player=None):
        """ Execute a stored action """
        # Resolve target: None, self, player, or a Player instance
        target = False
        if action['target'] == 'actor':
            target = player
        elif action['target'] == 'self':
            target = self
        elif action['target']:
            target = None
            for i in (self.place.visitors + self.place.npcs):
                if action['target'] == i.name:
                    target = i
                    break
        
        # Parse parameters, replace %self% and %actor%
        params = ''
        if action.has_key('params'):
            params = action['params']
            params = params.replace('%self%', self.name)
            if player:
                params = params.replace('%actor%', player.name)
        
        # Execute actions
        #   <say [target="actor|self|name"]>text</say>
        if action['name'] == 'say':
            if target:
                self.say(params, target)
            else:
                self.say(params)
        
        #   <narration>text</narration>
        elif action['name'] == 'narration':
            if target:
                target.send_message(None, params)
            else:
                self.place.broadcast_message(None, params)
        
        #   <follow [target="actor|self|name"] />
        elif action['name'] == 'follow':
            if target.place is not None and not isinstance(target, NonPlayableCharacter):
                forbidden_places = params.split(',')
                for i in xrange(len(forbidden_places)):
                    forbidden_places[i] = forbidden_places[i].strip()
                if not target.place.name in forbidden_places:
                    self.say('/me follows ' + target.name)
                    self.move_to(target.place)
        
        #   <signal [target="name"]>signal</signal>
        elif action['name'] == 'signal':
            if target is False:
                for i in (self.place.npcs + self.place.things):
                    i.trigger_signal(params, player)
            elif target:
                target.trigger_signal(params, player)
            elif ':Failed' not in params:
                for i in (self.place.npcs + self.place.things):
                    i.trigger_signal(params+':Failed', player)
        
        #   <move [target="actor|self|name"]>place</move>
        elif action['name'] == 'move':
            if not target:
                target = self
            if not params or params == target.place.name:
                for name, place in target.place.exits.items():
                    target.move_to(self.world.place(place))
                    break
            else:
                target.move_to(target.world.place(params))
        
        #   <add-exit>spec: place</add-exit>
        elif action['name'] == 'add-exit':
            (spec, place) = params.split(':')
            spec = spec.strip()
            place = place.strip()
            self.place.exits[spec] = place
        
        #   <del-exit>spec</del-exit>
        elif action['name'] == 'del-exit':
            if self.place.exits.has_key(params):
                del self.place.exits[params]
        #   <give target="target">object</give>
        elif action['name'] == 'give':
            if not target:
                target = player
            if target:
                if not 'count' in action or target.inventory.count(params) < action['count']:
                    target.inventory.append(params)
        #   <use target="target">object</give>
        elif action['name'] == 'use':
            if not target:
                target = player
            if target:
                target.inventory.remove(params)
    
    def trigger_event(self, event, actor=None):
        """ Trigger events if handled by the NPC"""
        if event == 'on-enter':
            for on_enter in self.on_enters:
                if (not on_enter['target'] or
                    on_enter['target'].lower() == actor.name.lower()):
                    for action in on_enter['actions']:
                        self.do_action(action, actor)
        
        if event == 'on-leave':
            for on_leave in self.on_leaves:
                if (not on_leave['target'] or
                    on_leave['target'].lower() == actor.name.lower()):
                    for action in on_leave['actions']:
                        self.do_action(action, actor)
        
        if event == 'on-self-enter':
            for i in self.on_self_enter:
                self.do_action(i, actor)
        
        if event == 'on-self-leave':
            for i in self.on_self_leave:
                self.do_action(i, actor)
    
    def trigger_signal(self, signal, actor=None):
        """ Trigger a signal if handled by the NPC """
        for command in self.commands:
            if signal.strip() == command['signal'].strip():
                for action in command['actions']:
                    self.do_action(action, actor)
    
    def handle_command(self, text, player):
        """
        Test all combinations with all aliasies.
        If command is handled, execute actions and return True.
        Else, return False.
        """
        for alias in self.aliases:
            for command_obj in self.commands:
                for command in command_obj['aliases']:
                    command_txt = command
                    command_txt = command_txt.replace('<<self>>', alias)
                    command_txt = command_txt.lower()
                    if command_txt and command_txt in text.lower().strip():
                        has_required = True
                        for i in command_obj['objects']:
                            if i not in player.inventory:
                                player.send_message('Help!',
                                                    'You don\'t have a %s' % i)
                                has_required = False
                                break
                        if has_required:
                            player.say('/me %s' % command_obj['name'].replace(
                                '<<self>>', self.name))
                            for action in command_obj['actions']:
                                self.do_action(action, player)
                        return True
        return False


class NonPlayableCharacter(Movable, Thing):
    def __init__(self, world, name, jid, place):
        Movable.__init__(self, world, name, jid)
        Thing.__init__(self, world, name, place)
        
        self.on_self_enter = list()
        self.on_self_leave = list()
    
    def fix_presence(self, role='participant', affiliation='member'):
        return Movable.fix_presence(self, role, affiliation)