Trunk: Merged the Devel-branch (branches/griatch) into /trunk. This constitutes a major refactoring of Evennia. Development will now continue in trunk. See the wiki and the past posts to the mailing list for info. /Griatch

game/gamesrc/commands/default/unimplemented/imc2.py

@@ -0,0 +1,211 @@
+"""
+IMC2 user and administrative commands.
+"""
+from django.conf import settings
+from src import comsys
+from src.cmdtable import GLOBAL_CMD_TABLE
+from src.ansi import parse_ansi
+from src.imc2.imc_ansi import IMCANSIParser
+from src.imc2 import connection as imc2_conn
+from src.imc2.packets import *
+from src.imc2.models import IMC2ChannelMapping    
+from src.imc2.trackers import IMC2_MUDLIST, IMC2_CHANLIST
+from src.channels.models import CommChannel
+
+def cmd_imcwhois(command):
+    """
+    imcwhois
+
+    Usage:
+      imcwhois
+      
+    IMC2 command. Shows a player's inventory.
+    """
+    source_object = command.source_object
+    if not command.command_argument:    
+        source_object.emit_to("Get what?")
+        return
+    else:
+        source_object.emit_to("Sending IMC whois request. If you receive no response, no matches were found.")
+        packet = IMC2PacketWhois(source_object, command.command_argument)
+        imc2_conn.IMC2_PROTOCOL_INSTANCE.send_packet(packet)
+GLOBAL_CMD_TABLE.add_command("imcwhois", cmd_imcwhois, help_category="Comms")
+
+def cmd_imcansi(command):
+    """
+    imcansi
+    
+    Usage:
+      imcansi <string>
+      
+    Test IMC ANSI conversion.
+    """
+    source_object = command.source_object
+    if not command.command_argument:    
+        source_object.emit_to("You must provide a string to convert.")
+        return
+    else:
+        retval = parse_ansi(command.command_argument, parser=IMCANSIParser())
+        source_object.emit_to(retval)
+GLOBAL_CMD_TABLE.add_command("imcansi", cmd_imcansi, help_category="Comms")
+
+def cmd_imcicerefresh(command):
+    """
+    imcicerefresh
+
+    Usage:
+      imcicerefresh
+
+    IMC2: Semds an ice-refresh packet.
+    """
+    source_object = command.source_object
+    packet = IMC2PacketIceRefresh()
+    imc2_conn.IMC2_PROTOCOL_INSTANCE.send_packet(packet)
+    source_object.emit_to("Sent")
+GLOBAL_CMD_TABLE.add_command("imcicerefresh", cmd_imcicerefresh, help_category="Comms")
+
+def cmd_imcchanlist(command):
+    """
+    imcchanlist
+
+    Usage:
+      imcchanlist
+      
+    Shows the list of cached channels from the IMC2 Channel list.
+    """
+    source_object = command.source_object
+    
+    retval = 'Channels on %s\n\r' % imc2_conn.IMC2_PROTOCOL_INSTANCE.network_name
+    
+    retval += ' Full Name          Name       Owner           Perm    Policy\n\r'
+    retval += ' ---------          ----       -----           ----    ------\n\r'
+    for channel in IMC2_CHANLIST.get_channel_list():
+        retval += ' %-18s %-10s %-15s %-7s %s\n\r' % (channel.name, 
+                                                      channel.localname,
+                                                      channel.owner, 
+                                                      channel.level,
+                                                      channel.policy)
+    retval += '%s channels found.' % len(IMC2_CHANLIST.chan_list)
+    source_object.emit_to(retval)
+GLOBAL_CMD_TABLE.add_command("imcchanlist", cmd_imcchanlist, help_category="Comms")
+
+def cmd_imclist(command):
+    """
+    imclist
+
+    Usage:
+       imclist
+
+    Shows the list of cached games from the IMC2 Mud list.
+    """
+    source_object = command.source_object
+    
+    retval = 'Active MUDs on %s\n\r' % imc2_conn.IMC2_PROTOCOL_INSTANCE.network_name
+    
+    for mudinfo in IMC2_MUDLIST.get_mud_list():
+        mudline = ' %-20s %s' % (mudinfo.name, mudinfo.versionid)
+        retval += '%s\n\r' % mudline[:78]
+    retval += '%s active MUDs found.' % len(IMC2_MUDLIST.mud_list)
+    source_object.emit_to(retval)
+GLOBAL_CMD_TABLE.add_command("imclist", cmd_imclist, help_category="Comms")
+
+def cmd_imcstatus(command):
+    """
+    imcstatus
+
+    Usage:
+      imcstatus
+      
+    Shows some status information for your IMC2 connection.
+    """
+    source_object = command.source_object
+    # This manages our game's plugged in services.
+    collection = command.session.server.service_collection
+    # Retrieve the IMC2 service.
+    service = collection.getServiceNamed('IMC2')
+    
+    if service.running == 1:
+        status_string = 'Running'
+    else:
+        status_string = 'Inactive'
+    
+    # Build the output to emit to the player.
+    retval = '-' * 50
+    retval += '\n\r'
+    retval += 'IMC Status\n\r'
+    retval += ' * MUD Name: %s\n\r' % (settings.IMC2_MUDNAME)
+    retval += ' * Status: %s\n\r' % (status_string)
+    retval += ' * Debugging Mode: %s\n\r' % (settings.IMC2_DEBUG)
+    retval += ' * IMC Network Address: %s\n\r' % (settings.IMC2_SERVER_ADDRESS)
+    retval += ' * IMC Network Port: %s\n\r' % (settings.IMC2_SERVER_PORT)
+    retval += '-' * 50
+    
+    source_object.emit_to(retval)
+GLOBAL_CMD_TABLE.add_command("imcstatus", cmd_imcstatus,
+                             priv_tuple=('imc2.admin_imc_channels',), help_category="Comms")
+
+
+def cmd_IMC2chan(command):
+    """
+    @imc2chan
+
+    Usage:
+      @imc2chan <IMCServer> : <IMCchannel> <channel>
+
+    Links an IMC channel to an existing evennia
+    channel. You can link as many existing
+    evennia channels as you like to the
+    IMC channel this way. Running the command with an
+    existing mapping will re-map the channels.
+
+    Use 'imcchanlist' to get a list of IMC channels and
+    servers. Note that both are case sensitive. 
+    """
+    source_object = command.source_object
+    if not settings.IMC2_ENABLED:
+        s = """IMC is not enabled. You need to activate it in game/settings.py."""
+        source_object.emit_to(s)
+        return
+    args = command.command_argument
+    if not args or len(args.split()) != 2 :
+        source_object.emit_to("Usage: @imc2chan IMCServer:IMCchannel channel")
+        return
+    #identify the server-channel pair
+    imcdata, channel = args.split()
+    if not ":" in imcdata:
+        source_object.emit_to("You need to supply an IMC Server:Channel pair.")
+        return
+    imclist = IMC2_CHANLIST.get_channel_list()
+    imc_channels = filter(lambda c: c.name == imcdata, imclist)    
+    if not imc_channels:
+        source_object.emit_to("IMC server and channel '%s' not found." % imcdata)
+        return
+    else:
+        imc_server_name, imc_channel_name = imcdata.split(":")
+        
+    #find evennia channel
+    try:
+        chanobj = comsys.get_cobj_from_name(channel)    
+    except CommChannel.DoesNotExist:
+        source_object.emit_to("Local channel '%s' not found (use real name, not alias)." % channel)
+        return
+       
+    #create the mapping.
+    outstring = ""
+    mapping = IMC2ChannelMapping.objects.filter(channel__name=channel)
+    if mapping:
+        mapping = mapping[0]
+        outstring = "Replacing %s. New " % mapping
+    else:
+        mapping = IMC2ChannelMapping()
+    
+    mapping.imc2_server_name = imc_server_name 
+    mapping.imc2_channel_name = imc_channel_name
+    mapping.channel = chanobj
+    mapping.save()
+    outstring += "Mapping set: %s." % mapping    
+    source_object.emit_to(outstring)
+
+GLOBAL_CMD_TABLE.add_command("@imc2chan",cmd_IMC2chan,
+                             priv_tuple=("imc2.admin_imc_channels",), help_category="Comms")
+    

game/gamesrc/commands/default/unimplemented/irc.py

@@ -0,0 +1,130 @@
+"""
+IRC-related commands
+"""
+from twisted.application import internet
+from django.conf import settings
+from src.irc.connection import IRC_CHANNELS
+from src.irc.models import IRCChannelMapping
+from src import comsys
+from src.cmdtable import GLOBAL_CMD_TABLE
+from src.channels.models import CommChannel
+
+def cmd_IRC2chan(command):
+    """
+    @irc2chan - link irc to ingame channel
+
+    Usage:    
+      @irc2chan <#IRCchannel> <local channel>
+
+    Links an IRC channel (including #) to an existing
+    evennia channel. You can link as many existing
+    evennia channels as you like to the
+    IRC channel this way. Running the command with an
+    existing mapping will re-map the channels.
+
+    """
+    source_object = command.source_object
+    if not settings.IRC_ENABLED:
+        s = """IRC is not enabled. You need to activate it in game/settings.py."""
+        source_object.emit_to(s)
+        return
+    args = command.command_argument
+    if not args or len(args.split()) != 2 :
+        source_object.emit_to("Usage: @irc2chan IRCchannel channel")
+        return
+    irc_channel, channel = args.split()
+    if irc_channel not in [o.factory.channel for o in IRC_CHANNELS]:
+        source_object.emit_to("IRC channel '%s' not found." % irc_channel)
+        return
+    try:
+        chanobj = comsys.get_cobj_from_name(channel)    
+    except CommChannel.DoesNotExist:
+        source_object.emit_to("Local channel '%s' not found (use real name, not alias)." % channel)
+        return
+       
+    #create the mapping.
+    outstring = ""
+    mapping = IRCChannelMapping.objects.filter(channel__name=channel)
+    if mapping:
+        mapping = mapping[0]
+        outstring = "Replacing %s. New " % mapping
+    else:
+        mapping = IRCChannelMapping()
+    
+    mapping.irc_server_name = settings.IRC_NETWORK
+    mapping.irc_channel_name = irc_channel   
+    mapping.channel = chanobj
+    mapping.save()
+    outstring += "Mapping set: %s." % mapping    
+    source_object.emit_to(outstring)
+
+GLOBAL_CMD_TABLE.add_command("@irc2chan",cmd_IRC2chan,
+                             priv_tuple=("irc.admin_irc_channels",),
+                             help_category="Comms")
+    
+def cmd_IRCjoin(command):
+    """
+    @ircjoin - join a new irc channel
+
+    Usage:
+      @ircjoin <#IRCchannel>
+
+    Attempts to connect a bot to a new IRC channel (don't forget that
+    IRC channels begin with a #).
+    The bot uses the connection details defined in the main settings. 
+
+    Observe that channels added using this command does not survive a reboot. 
+    """
+
+    source_object = command.source_object
+    arg = command.command_argument
+    if not arg:
+        source_object.emit_to("Usage: @ircjoin #irc_channel")
+        return
+    channel = arg.strip()
+    if channel[0] != "#": channel = "#%s" % channel
+
+    if not settings.IRC_ENABLED:
+        source_object.emit_to("IRC services are not active. You need to turn them on in preferences.")
+        return 
+
+    #direct creation of bot (do not add to services)
+    from src.irc.connection import connect_to_IRC
+    connect_to_IRC(settings.IRC_NETWORK,
+                   settings.IRC_PORT,
+                   channel, settings.IRC_NICKNAME)
+
+#    ---below should be checked so as to add subequent IRC bots to Services.
+#       it adds just fine, but the bot does not connect. /Griatch
+#    from src.irc.connection import IRC_BotFactory
+#    from src.server import mud_service
+#    irc = internet.TCPClient(settings.IRC_NETWORK, 
+#                             settings.IRC_PORT, 
+#                             IRC_BotFactory(channel,
+#                                            settings.IRC_NETWORK,
+#                                            settings.IRC_NICKNAME))            
+#    irc.setName("%s:%s" % ("IRC",channel))
+#    irc.setServiceParent(mud_service.service_collection)
+
+GLOBAL_CMD_TABLE.add_command("@ircjoin",cmd_IRCjoin,
+                             priv_tuple=("irc.admin_irc_channels",),
+                             help_category="Comms")
+
+def cmd_IRCchanlist(command):
+    """
+    ircchanlist
+
+    Usage:
+      ircchanlist
+
+    Lists all externally available IRC channels.
+    """
+    source_object = command.source_object
+    s = "Available IRC channels:"
+    for c in IRC_CHANNELS:
+        s += "\n  %s \t(nick '%s') on %s" % (c.factory.channel,
+                                             c.factory.nickname,
+                                             c.factory.network,)
+    source_object.emit_to(s)
+GLOBAL_CMD_TABLE.add_command("ircchanlist", cmd_IRCchanlist,
+                             help_category="Comms")

game/gamesrc/commands/default/unimplemented/search.py

@@ -0,0 +1,235 @@
+"""
+Implementation of the @search command that resembles MUX2.
+"""
+from django.db.models import Q
+#from src.objects.models import Object
+from src.utils import OBJECT as Object 
+from src import defines_global
+from src.cmdtable import GLOBAL_CMD_TABLE
+
+def _parse_restriction_split(source_object, restriction_split, search_low_dbnum,
+                                                               search_high_dbnum):
+    """
+    Parses a split restriction string and sets some needed variables.
+    
+    Returns a tuple in the form of: (low dbnum, high dbnum)
+    """
+    restriction_size = len(restriction_split)
+    if restriction_size >= 2:
+        try:
+            search_low_dbnum = int(restriction_split[1].strip())
+        except ValueError:
+            source_object.msg("Invalid value for low dbref limit.")
+            return False
+    if restriction_size >= 3:
+        try:
+            search_high_dbnum = int(restriction_split[2].strip())
+        except ValueError:
+            source_object.msg("Invalid value for high dbref limit.")
+            return False
+        
+    return search_low_dbnum, search_high_dbnum
+
+def display_results(source_object, search_query):
+    """
+    Display the results to the searcher.
+    """
+    # Lists to hold results by type. There may be a better way to do this
+    thing_list = []
+    room_list = []
+    exit_list = []
+    player_list = []
+    # this bits gotta get totally redone 
+    for obj in search_query:
+        thing_list.append(obj)
+
+    # Render each section for different object types
+    if thing_list:
+        source_object.msg("\n\rTHINGS:")
+        for thing in thing_list:
+            source_object.msg(thing.name)
+            
+    if exit_list:
+        source_object.msg("\n\rEXITS:")
+        for exit in exit_list:
+            source_object.msg(exit.name)
+            
+    if room_list:
+        source_object.msg("\n\rROOMS:")
+        for room in room_list:
+            source_object.msg(room.name)
+            
+    if player_list:
+        source_object.msg("\n\rPLAYER:")
+        for player in player_list:
+            source_object.msg(player.name)
+            
+    # Show the total counts by type
+    source_object.msg("\n\rFound:  Rooms...%d  Exits...%d  Things...%d  Players...%d" % (
+                                len(room_list),
+                                len(exit_list),
+                                len(thing_list),
+                                len(player_list)))
+    
+def build_query(source_object, search_query, search_player, search_type, 
+                search_restriction, search_low_dbnum, search_high_dbnum):
+    """
+    Builds and returns a QuerySet object, or None if an error occurs.
+    """
+    # Look up an Object matching the player search query
+    if search_player:
+        # Replace the string variable with an Object reference
+        search_player = source_object.search_for_object(search_player)
+        # Use standard_objsearch to handle duplicate/nonexistant results
+        if not search_player:
+            return None
+        
+        # Searching by player, chain filter
+        search_query = search_query.filter(owner=search_player)
+    
+    # Check to ensure valid search types
+    if search_type == "type":
+        if search_restriction == "room":
+            search_query = search_query.filter(type=defines_global.OTYPE_ROOM)
+        elif search_restriction == "thing":
+            search_query = search_query.filter(type=defines_global.OTYPE_THING)
+        elif search_restriction == "exit":
+            search_query = search_query.filter(type=defines_global.OTYPE_EXIT)
+        elif search_restriction == "player":
+            search_query = search_query.filter(type=defines_global.OTYPE_PLAYER)
+        else:
+            source_object.msg("Invalid class. See 'help SEARCH CLASSES'.")
+            return None
+    elif search_type == "parent":
+        search_query = search_query.filter(script_parent__iexact=search_restriction)
+    elif search_type == "object" or search_type == "thing":
+        search_query = search_query.filter(name__icontains=search_restriction,
+                                           type=defines_global.OTYPE_THING)
+    elif search_type == "rooms":
+        search_query = search_query.filter(name__icontains=search_restriction,
+                                           type=defines_global.OTYPE_ROOM)
+    elif search_type == "exits":
+        search_query = search_query.filter(name__icontains=search_restriction,
+                                           type=defines_global.OTYPE_EXIT)
+    elif search_type == "players":
+        search_query = search_query.filter(name__icontains=search_restriction,
+                                           type=defines_global.OTYPE_PLAYER)
+    elif search_type == "zone":
+        zone_obj = source_object.search_for_object(search_restriction)
+        # Use search_for_object to handle duplicate/nonexistant results.
+        if not zone_obj:
+            return None
+        search_query = search_query.filter(zone=zone_obj)
+    elif search_type == "power":
+        # TODO: Need this once we have powers implemented.
+        source_object.msg("To be implemented...")
+        return None
+    elif search_type == "flags":
+        flag_list = search_restriction.split()
+        #source_object.msg("restriction: %s" % flag_list)
+        for flag in flag_list:
+            search_query = search_query.filter(Q(flags__icontains=flag) | Q(nosave_flags__icontains=flag))
+    
+    if search_low_dbnum:
+        search_query = search_query.filter(id__gte=search_low_dbnum)
+        
+    if search_high_dbnum:
+        search_query = search_query.filter(id__lte=search_high_dbnum)
+        
+    return search_query
+
+def cmd_search(command):
+    """
+    search
+
+    Usage:
+      search <name>
+
+    Searches for owned objects as per MUX2.
+    """
+    source_object = command.source_object
+    
+    search_player = None
+    search_type = None
+    search_restriction = None
+    search_low_dbnum = None
+    search_high_dbnum = None
+
+    if not command.command_argument:
+        search_player = "#" + str(source_object.id)
+    else:
+        first_check_split = command.command_argument.split(' ', 1)
+        if '=' in first_check_split[0]:
+            # @search class=restriction...
+            eq_split = command.command_argument.split('=', 1)
+            search_type = eq_split[0]
+            restriction_split = eq_split[1].split(',')
+            search_restriction = restriction_split[0].strip()
+            #source_object.msg("@search class=restriction")
+            #source_object.msg("eq_split: %s" % eq_split)
+            #source_object.msg("restriction_split: %s" % restriction_split)
+            
+            try:
+                search_low_dbnum, search_high_dbnum = _parse_restriction_split(source_object,
+                                                     restriction_split,
+                                                     search_low_dbnum,
+                                                     search_high_dbnum)
+            except TypeError:
+                return
+            
+        else:
+            # @search player
+            if len(first_check_split) == 1:
+                #source_object.msg("@search player")
+                #source_object.msg(first_check_split)
+                search_player = first_check_split[0]
+            else:
+                #source_object.msg("@search player class=restriction")
+                #source_object.msg(first_check_split)
+                search_player = first_check_split[0]
+                eq_split = first_check_split[1].split('=', 1)
+                search_type = eq_split[0]
+                #source_object.msg("eq_split: %s" % eq_split)
+                restriction_split = eq_split[1].split(',')
+                search_restriction = restriction_split[0]
+                #source_object.msg("restriction_split: %s" % restriction_split)
+                
+                try:
+                    search_low_dbnum, search_high_dbnum = _parse_restriction_split(source_object,
+                                                         restriction_split,
+                                                         search_low_dbnum,
+                                                         search_high_dbnum)
+                except TypeError:
+                    return  
+    
+    search_query = Object.objects.all()
+        
+    #source_object.msg("search_player: %s" % search_player)
+    #source_object.msg("search_type: %s" % search_type)
+    #source_object.msg("search_restriction: %s" % search_restriction)
+    #source_object.msg("search_lowdb: %s" % search_low_dbnum)
+    #source_object.msg("search_highdb: %s" % search_high_dbnum)
+    
+    # Clean up these variables for comparisons.
+    try:
+        search_type = search_type.strip().lower()
+    except AttributeError:
+        pass
+    try:
+        search_restriction = search_restriction.strip().lower()
+    except AttributeError:
+        pass
+    
+    # Build the search query.
+    search_query = build_query(source_object, search_query, search_player, search_type, 
+                               search_restriction, search_low_dbnum, 
+                               search_high_dbnum)
+    
+    # Something bad happened in query construction, die here.
+    if search_query is None:
+        return
+                
+    display_results(source_object, search_query)
+GLOBAL_CMD_TABLE.add_command("@search", cmd_search,
+                             priv_tuple=("objects.info",),
+                             help_category="Building")