Changeset 101

Timestamp:

10/14/07 06:23:09 (2 years ago)

Author:

elghinn

Message:

ThibG and me: some stuff

Location:

adventure

Files:

• adventure.py (deleted)
• adventure.rb (deleted)
• adventuremuc.py (modified) (2 diffs)
• cave.xml (added)
• cube.xml (deleted)
• place.py (added)
• player.py (added)
• thing.py (added)
• tower.xml (deleted)
• world.dtd (added)
• world.py (modified) (8 diffs)

adventure/adventuremuc.py

@@ -1 @@
-import world
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
 
-class AdventureMUC:
-    def initialize(jid, secret, addr, port=5347):
+from xmpp import Component
+from sys import argv
+from world import World
+
+class AdventureMUC(Component):
+    def __init__(self, jid, password, server, port=5347):
         self.worlds = {}
     
-        self.component = Jabber::Component::new(jid)
-        self.component.connect(addr, port)
-        self.component.auth(secret)
-        self.component.on_exception { |e,|
-                                 puts "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-                                 }
+        Component.__init__(server, port)
+        if not self.connect(server, port):
+            raise Exception, 'Unable to connect to %s:%s' % (server, port))
+        if not self.auth(jid, password):
+            raise Exception, 'Unable to autenticate as %s' % jid
 
-        self.component.add_iq_callback { |iq|
-                                    handle_iq(iq)
-                                    }
-        self.component.add_presence_callback { |pres|
-                                          handle_presence(pres)
-                                          }
-        self.component.add_message_callback { |msg|
-                                         handle_message(msg)
-                                         }
-
+        self.RegisterHandler('iq', self.handle_iq)
+        self.RegisterHandler('presence', self.handle_presence)
+        self.RegisterHandler('message', self.handle_message)
         print 'Adventure component up and running'
 
 
-    def add_world(file):
-        print 'Adding world from #{file}...'
-        try:
-            world = World.new_from_file(self, file)
-        except Exception, e:
-            print e
-            exit
+    def add_world(self, filename):
+        print 'Adding world from "%s"...' % filename
+        world = World.new_from_file(self, filename)
         self.worlds[world.node] = world
         print ' ' + world.iname
 
-    def send(worldnode, worldresource, stanza):
+    def send(self, worldnode, worldresource, stanza):
         stanza.from = Jabber::JID::new(worldnode, self.component.jid.domain, worldresource)
         self.component.send(stanza)
 
-    def handle_iq(iq):
-        print "iq: from #{iq.from} type #{iq.type} to #{iq.to}: #{iq.queryns}"
+    def handle_iq(self, iq):
+        #print "iq: from #{iq.from} type #{iq.type} to #{iq.to}: #{iq.queryns}"
 
-        if iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoInfo):
-            handle_disco_info(iq)
-            return True
-        elif iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoItems):
-            handle_disco_items(iq)
-            return True
-        else:
-            return False
+        #if iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoInfo):
+        #    handle_disco_info(iq)
+        #    return True
+        #elif iq.query.kind_of?(Jabber::Discovery::IqQueryDiscoItems):
+        #    handle_disco_items(iq)
+        #    return True
+        #else:
+        #    return False
+        pass
   
-    def handle_disco_info(iq):
-        if iq.type != :get :
-            answer = iq.answer
-            answer.type = :error
-            answer.add(Jabber::Error.new('bad-request'))
-            self.component.send(answer) if iq.type != :error
-            return
-        answer = iq.answer
-        answer.type = :result
-        if iq.to.node == nil:
-            answer.query.add(Jabber::Discovery::Identity.new('conference', 'Adventure component', 'text'))
-            answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoInfo.new.namespace))
-            answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoItems.new.namespace))
-        else:
-            world = self.worlds[iq.to.node]
-            if world.nil? :
-                answer.type = :error
-                answer.query.add(Jabber::Error.new('item-not-found', 'The world you are trying to reach is currently unavailable.'))
-            else:
-                answer.query.add(Jabber::Discovery::Identity.new('conference', world.iname, 'text'))
-                answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoInfo.new.namespace))
-                answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoItems.new.namespace))
-                answer.query.add(Jabber::Discovery::Feature.new(Jabber::MUC::XMUC.new.namespace))
-                answer.query.add(Jabber::Discovery::Feature.new(Jabber::MUC::XMUCUser.new.namespace))
-        self.component.send(answer)
+    #def handle_disco_info(iq):
+    #    if iq.type != :get :
+    #        answer = iq.answer
+    #        answer.type = :error
+    #        answer.add(Jabber::Error.new('bad-request'))
+    #        self.component.send(answer) if iq.type != :error
+    #        return
+    #    answer = iq.answer
+    #    answer.type = :result
+    #    if iq.to.node == nil:
+    #        answer.query.add(Jabber::Discovery::Identity.new('conference', 'Adventure component', 'text'))
+    #        answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoInfo.new.namespace))
+    #        answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoItems.new.namespace))
+    #    else:
+    #        world = self.worlds[iq.to.node]
+    #        if world.nil? :
+    #            answer.type = :error
+    #            answer.query.add(Jabber::Error.new('item-not-found', 'The world you are trying to reach is currently unavailable.'))
+    #        else:
+    #            answer.query.add(Jabber::Discovery::Identity.new('conference', world.iname, 'text'))
+    #            answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoInfo.new.namespace))
+    #            answer.query.add(Jabber::Discovery::Feature.new(Jabber::Discovery::IqQueryDiscoItems.new.namespace))
+    #            answer.query.add(Jabber::Discovery::Feature.new(Jabber::MUC::XMUC.new.namespace))
+    #            answer.query.add(Jabber::Discovery::Feature.new(Jabber::MUC::XMUCUser.new.namespace))
+    #    self.component.send(answer)
   
-    def handle_disco_items(iq):
-        if iq.type != :get :
-            answer = iq.answer
-            answer.add(Jabber::Error.new('bad-request'))
-            self.component.send(answer)
-            return
-        answer = iq.answer
-        answer.type = :result
-        if iq.to.node == nil:
-            self.worlds.each { |node,world|
-                          answer.query.add(Jabber::Discovery::Item.new(Jabber::JID::new(String::new(node), self.component.jid.domain), world.iname))
-                          }
-        self.component.send(answer)
+    #def handle_disco_items(iq):
+    #    if iq.type != :get :
+    #        answer = iq.answer
+    #        answer.add(Jabber::Error.new('bad-request'))
+    #        self.component.send(answer)
+    #        return
+    #    answer = iq.answer
+    #    answer.type = :result
+    #    if iq.to.node == nil:
+    #        self.worlds.each { |node,world|
+    #                      answer.query.add(Jabber::Discovery::Item.new(Jabber::JID::new(String::new(node), self.component.jid.domain), world.iname))
+    #                      }
+    #    self.component.send(answer)
 
-    def handle_presence(pres):
-        print "presence: from #{pres.from} type #{pres.type} to #{pres.to}"
+    def handle_presence(self, pres):
+        #print "presence: from #{pres.from} type #{pres.type} to #{pres.to}"
     
         world = self.worlds[pres.to.node]
-        if world.nil? :
+        if not world:
             answer = pres.answer
             answer.type = :error
@@ -117 +111 @@
             world.handle_message(msg)
         return True
+
+
+
+if __name__ == '__main__':
+    if len argv != 4:
+        print 'Syntax: ./adventure.rb <JID> <Password> <Host> <Port>'
+        print 'See README for further help'
+    muc = AdventureMUC(*argv)
+    muc.add_world('cave.xml')

adventure/world.py

@@ -1 @@
-require 'rexml/document'
-
-class World(REXML::Element):
-    def initialize(muc):
-        super('world')
-
+# -*- coding: utf-8 -*-
+
+from place import Place
+from xml.dom.minidom import parse as xml_parse
+
+
+class World:
+    def __init__(self, muc):
         self.muc = muc
+        self.places = dict() # {'place_name': place, ...}
+        #self.things = 
+
+        doc = xml_parse(filename).documentElement
+        get_elements = doc.documentElement.getElementsByTagName
+
+        places = get_elements('places')
+        for place in places:
+            name = place.getAttribute('name')
+            place_obj = Place(name)
+            gos = place.getElementsByTagName('go')
+            for go in gos:
+                place_obj.exits[
+                    go.getAttribute('spec')] = go.getAttribute('place')
+        #things = get_elements('thing')
+        #for thing in things:
+            
+
 
     def send(resource, stanza):
@@ -12 +32 @@
             self.muc.send(node, resource, stanza)
 
-    def World.new_from_file(muc, filename):
-        file = File.new(filename)
-        world = World.new(muc)
-        world.import(REXML::Document.new(file).root)
-        file.close
-        world
-
-    def add(xmlelement):
-        if xmlelement.kind_of?(REXML::Element) && (xmlelement.name == 'place'):
-            super(Place::new.import(xmlelement))
-        elif xmlelement.kind_of?(REXML::Element) && (xmlelement.name == 'thing') && !xmlelement.kind_of?(Player):
-            super(Thing::new(self).import(xmlelement))
-        else:
-            super(xmlelement)
-
-    def node():
-        return attributes['node']
-
-    def iname():
-        return attributes['name']
-
     def place(placename):
-        pl = None
-        for place in each_element('place'):
-            if place.iname == placename:
-                pl = place
-        return pl
-
-    def each_thing_by_place(place, &block):
-        for thing in each_element('thing'):
-            if thing.place == place:
+        if self.places.has_key(placename):
+            return self.places[placename]
+        return None
+
+    def each_thing_by_place(placename):
+        for thing in self.things.values():
+            if thing.place == placename:
                 yield(thing)
 
@@ -94 +91 @@
     def handle_presence(pres):
         # A help for the irritated first:
-        if pres.type == :subscribe :
+        if pres.type == 'subscribe':
             msg = Jabber::Message.new(pres.from)
-            msg.type = :normal
-            msg.subject = "Adventure component help"
-            msg.body = "You don't need to subscribe to my presence. Simply use your Jabber client to join the MUC or conference at #{pres.to.strip}"
+            msg.type = 'normal'
+            msg.subject = 'Adventure component help'
+            msg.body = 'You don\'t need to subscribe to my presence. Simply use your Jabber client to join the MUC or conference at #{pres.to.strip}'
             send(None, msg)
             return True
@@ -104 +101 @@
         # Look if player is already known
         player = None
-        for thing in each_element('thing'):
+        for thing in self.things.values():
             if thing.kind_of?(Player) && pres.to.resource == thing.iname:
                 player = thing
@@ -150 +147 @@
     def handle_message(msg):
         player = None
-        for thing in each_element('thing'):
-            if thing.kind_of?(Player) && msg.to.resource == nil && msg.from == thing.jid:
+        for thing in self.things.values():
+            if thing.kind_of?(Player) && msg.to.resource == None && msg.from == thing.jid:
                 player = thing
 
@@ -167 +164 @@
     def command(player, text):
         if text == '?':
-            player.send_message(nil, "(Command) who")
+            player.send_message(None, '(Command) who')
             for go in place(player.place).each_element('go'):
-                player.send_message(None, "(Command) go #{go.attributes['spec']}")
+                player.send_message(None, '(Command) go #{go.attributes['spec']}')
             for thing in foreach_thing_by_place(player.place):
                 for c in thing.each_element('on-command'):
-                    player.send_message(None, "(Command) #{c.attributes['command']} #{thing.command_name}")
+                    player.send_message(None, '(Command) #{c.attributes['command']} #{thing.command_name}')
             return True
         else:
             words = text.split(/ /)
             cmd = words.shift
-            what = words.shift or ""
+            what = words.shift or ''
             if cmd == 'go':
                 oldplace = place(player.place)
-                newplace = nil
+                newplace = None
 
                 for go in oldplace.each_element('go'):
@@ -207 +204 @@
                 if handled:
                     return True
-        False
-
-class Place(REXML::Element):
-    def initialize:
-        super('place')
-
-    def iname():
-        return attributes['name']
+        return False
 
 class Thing(REXML::Element):
@@ -227 +217 @@
             super(xmlelement)
 
-    def iname():
+    def iname(self):
         return attributes['name']
 
-    def command_name():
-        return attributes['command-name'].nil? ? iname : attributes['command-name']
+    def command_name(self):
+        if attributes['command-name']:
+            return attributes['command-name']
+        return self.iname()
 
     def place():