root/adventure/place.py

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

#  MUDMUC
#  place.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 xmpp import Message, Presence, NS_MUC_USER

from thing import NonPlayableCharacter

class Place(object):
    def __init__(self, world, name, description):
        self.world = world
        self.name = name
        self.description = description
        
        self.visitors = list() # Players ; Role: visitors
        self.npcs = list() # Role: Participants
        
        self.things = list() # List of Things
        self.exits = dict() # { spec: place_name }
    
    def player_leaved(self, player):
        """
        Broadcast unavaibility of Player or NonPlayableCharacter,
        Trigger on-leave events and remove
        Player/NonPlayableCharacter from the lists.
        """
        
        if player.place:
            message = '/me leaves %s going to %s' % (self.name,
                                                     player.place.name)
        else:
            message = '/me disintegrates'
        
        if isinstance(player, NonPlayableCharacter):
            player.trigger_event('on-self-leave')
            self.npcs.remove(player)
        else:
            self.visitors.remove(player)
            
            # Send players and npcs unaivaibility to player
            for npc in self.npcs:
                pres = Presence(node=npc.presence)
                pres.setType('unavailable')
                player.send_presence(npc.name, pres)
            for visitor in self.visitors:
                if visitor is not player:
                    pres = visitor.fix_presence()
                    pres.setType('unavailable')
                    player.send_presence(visitor.name, pres)
        
        # Broadcast player's unavailibility to all players in the room
        self.broadcast_message(player.name, message)
        self.broadcast_status(player, 'unavailable')
        
        # Trigger on-leave events
        self.trigger_event('on-leave', player)
    
    def player_entered(self, player, old_place=None):
        """
        Broadcast avaibility of Player or NonPlayableCharacter,
        Trigger on-enter events, append
        Player/NonPlayableCharacter to the lists and send description
        of the room to the Player.
        """
        
        if old_place:
            message = '/me enters in %s coming from %s' % (self.name,
                                                      old_place.name)
        else:
            message = '/me spawns'
        
        # Broadcast player's availibility to all players in the room
        self.broadcast_status(player)
        self.broadcast_message(player.name, message)
        
        if isinstance(player, NonPlayableCharacter):
            self.npcs.append(player)
            player.trigger_event('on-self-enter')
        else:
            self.visitors.append(player)
            
            # Send players and npcs avaibility to player
            for npc in self.npcs:
                player.send_presence(npc.name, npc.presence)
            for visitor in self.visitors:
                if visitor is not player:
                    pres = visitor.fix_presence()
                    player.send_presence(visitor.name, pres)
            
            pres = player.fix_presence(to_self=True)
            player.send_presence(player.name, pres)
            
            # Send description of the room
            player.send_message(None, None,
                                '%s: %s' % (self.world.name,
                                            self.name.capitalize()))
            player.send_message(None,
                            '\n******\n\n\n\n**********\n'
                            'Entering %s\n**********'
                            '\n\n%s\nYou can go %s.' % (self.name.capitalize(),
                                                        self.description,
                                                        ', '.join(self.exits.keys())))
        
        # Trigger on-enter events
        self.trigger_event('on-enter', player)
    
    def trigger_event(self, event_type, actor):
        """ Trigger event of type event_type for all things and npcs """
        for npc in self.npcs:
            if actor is not npc:
                npc.trigger_event(event_type, actor)
        for thing in self.things:
            thing.trigger_event(event_type, actor)
            
    def broadcast_status(self, player, status=None):
        """ Broadcast a presence stanza in the room """
        presence = player.fix_presence()
        if status is not None:
            presence.setType(status)
        for visitor in self.visitors:
            visitor.send_presence(player.name, presence)
    
    def broadcast_message(self, from_, message):
        """ Broadcast a message in all visitors in the room """
        for visitor in self.visitors:
            visitor.send_message(from_, message)