Changeset 103

Timestamp:

10/14/07 13:02:39 (3 years ago)

Author:

elghinn

Message:

ThibG and me: some stuff

Location:

adventure

Files:

• adventuremuc.py (modified) (4 diffs)
• cave.xml (modified) (1 diff)
• player.py (modified) (3 diffs)
• thing.py (modified) (2 diffs)
• world.dtd (modified) (4 diffs)
• world.py (modified) (9 diffs)

adventure/adventuremuc.py

@@ -24 +24 @@
     def add_world(self, filename):
         print 'Adding world from "%s"...' % filename
-        world = World.new_from_file(self, filename)
+        world = World(self, filename)
         self.worlds[world.node] = world
-        print ' ' + world.iname
+        print ' ' + world.name
 
     def send(self, worldnode, worldresource, stanza):
@@ -86 +86 @@
 
     def handle_presence(self, pres):
-        #print "presence: from #{pres.from} type #{pres.type} to #{pres.to}"
+        print 'presence: from %s type %s to %s' % (pres.getFrom(), pres.getType(), pres.getTo())
     
         world = self.worlds[pres.to.node]
         if not world:
             answer = pres.answer
-            answer.type = :error
-            answer.add(Jabber::Error.new('item-not-found', 'The world you are trying to reach is currently unavailable.'))
+            answer.setType('error')
+            #answer.add(Jabber::Error.new('item-not-found', 'The world you are trying to reach is currently unavailable.'))
             self.component.send(answer)
         else:
@@ -99 +99 @@
 
     def handle_message(msg):
-        print "message: from #{msg.from} type #{msg.type} to #{msg.to}: #{msg.body.inspect}"
+        print 'message: from %s type %s to %s: %s' % (msg.getFrom(), msg.getType(), msg.getTo(), repr(msg.getBody()))
 
         world = self.worlds[msg.getTo()]
         if not world:
             answer = msg.buildReply()
-            answer.type = 'error'
+            answer.setType('error')
             #answer.add(Jabber::Error.new('item-not-found', 'The world you are trying to reach is currently unavailable.'))
             self.send(answer)
@@ -116 +116 @@
 if __name__ == '__main__':
     if len argv != 4:
-        print 'Syntax: ./adventure.rb <JID> <Password> <Host> <Port>'
+        print 'Syntax: ./adventuremuc.py <JID> <Password> <Host> <Port>'
         print 'See README for further help'
     muc = AdventureMUC(*argv)

adventure/cave.xml

@@ -39 +39 @@
         <commands>
             <command name="look at"><narration>An ugly rat</narration></command>
-            <command name="use %s on" object="bottle">
+            <command name="use %s on" objects="bottle">
                 <use target="bottle" />
                 <narration>%actor% use alcool bottle on %self%</narration>

adventure/player.py

@@ -1 +1 @@
 # -*- coding: utf-8 -*-
-class Player:#(Thing):
+class Player(Thing):
     def __init__(self, world, name, jid):
         self.world = world
@@ -7 +7 @@
         self.place = None
   
-    def see(place):
+    def see(self, place):
         if not place:
             return
@@ -17 +17 @@
         send_message(None, 'You can go %s}' % ', '.join(place.exits.keys()))
 
-    def send_message(fromresource, text, subject=None):
-        msg = Jabber::Message.new(jid, text)
-        msg.type = :groupchat
-        msg.subject = subject unless subject.nil?
+    def send_message(self, fromresource, text, subject=None):
+        msg = Message(jid, text)
+        msg.setType('groupchat')
+        if subject:
+            msg.setSubject(subject)
         self.world.send(fromresource, msg)
 

adventure/thing.py

@@ -1 +1 @@
 # -*- coding: utf-8 -*-
 
+from player import Player
+
 class Thing:
-    def _init__(self, name, parent):
+    def _init__(self, world, name, parent):
+        self.word = word
         self.name = name
         self.parent = parent
         self.aliases = list() # Noms alternatifs
         self.actions = list()
-        self.presence = ...
+        self.presence = None
         self.UID = 0
         self.place = None
         
+    def command_name(self):
+        if attributes['command-name']:
+            return attributes['command-name']
+        return self.iname()
+
+    def jid():
+        return None
+
+    def presence():
+        xe = None
+        #for pres in each_element('presence'):
+        #    xe = Jabber::Presence.import(pres)
+        #if isinstance(self, Player):
+        #    xe.add(Jabber::MUC::XMUCUser.new).add(Jabber::MUC::XMUCUserItem.new('none', 'participant'))
+        #else:
+        #    xe.add(Jabber::MUC::XMUCUser.new).add(Jabber::MUC::XMUCUserItem.new('owner', 'moderator'))
+        return xe
+
+    def see(place):
+        pass
+
+    def send_message(fromresource, text, subject=None):
+        pass
+
+    def send_message_to_place(fromresource, text):
+        for thing in self.world.each_element('thing'):
+            if thing.place == place:
+                thing.send_message(fromresource, text)
+  
+    def on_enter(thing, from):
+        for c in each_element('on-enter'):
+            command(thing, c, [from])
+
+    def on_leave(thing, to):
+        for c in each_element('on-leave'):
+            command(thing, c, [to])
+
+    def command(source, command, arguments):
+            if command.action[1]:
+                text = command.action[1]
+            else:
+                text = ''
+            if command.action[2]:
+                target = .... # élément de nom command.action[2] avec le même place que self
+            else:
+                target = self
+            text.replace('%self%', target.name)
+            text.replace('%actor%', source.name)
+            text.replace('%place%', place)
+            if command.action[0] == 'say' or command.action[0] == 'narration':
+                sender = None
+                if command.action[0] == 'say':
+                    sender = self.name
+                if command.action[3] == 'all':
+                    send_message_to_place(sender, text)
+                else:
+                    source.send_message(sender, text)
+
+
+
+
 class Action:
     def _init__(self, name, parent):
@@ -19 +83 @@
                                   # un élément par alias ( ex "use bottle on", "use whiskey on" )
         #self.xmlelement = None # Élément XML à traiter si les objets sont dans l'inventaire
-        self.action = list()
+        self.action = list() # (("say","coucou",None,None),("destroy",None)) par exemple
+                             # à respecter : premier élément : nom de la commande, deuxième : texte, troisième : target

adventure/world.dtd

@@ -25 +25 @@
  respawn CDATA #IMPLIED>
  
-<!ELEMENT on-enter (say?,narration?,destroy?,use?,give)?>
-<!ELEMENT on-leave (say?,narration?,destroy?,use?,give)?>
+<!ELEMENT on-enter (say?,narration?,destroy?,use?,give?,move?)>
+<!ELEMENT on-leave (say?,narration?,destroy?,use?,give?,move?)>
 
 <!ELEMENT commands (command+,inherit+)>
@@ -37 +37 @@
  enabled CDATA #IMPLIED>
 
-<!ELEMENT command (say?,narration?,presence?,commands?,destroy?,use?,give?)>
+<!ELEMENT command (say?,narration?,presence?,commands?,destroy?,use?,give?,move?)>
 <!ATTLIST command
  name CDATA #REQUIRED
- object CDATA #IMPLIED>
+ objects CDATA #IMPLIED>
  
 <!ELEMENT inherit (#EMPTY)>
@@ -54 +54 @@
 <!ELEMENT say (#PCDATA)>
 <!ATTLIST say
- target CDATA #IMPLIED>
+ target CDATA #IMPLIED
+ to CDATA #IMPLIED>
  
 <!ELEMENT destroy (#EMPTY)>
@@ -75 +76 @@
  place CDATA #REQUIRED>
  
+<!ELEMENT move (#EMPTY)>
+<!ATTLIST move
+ target CDATA #IMPLIED
+ place CDATA #REQUIRED>
+ 
 <!ELEMENT narration (#PCDATA)> 
 

adventure/world.py

@@ -4 +4 @@
 from player import Player
 from xml.dom.minidom import parse as xml_parse
-
+from xmpp import Message, Presence
 
 class World:
-    def __init__(self, muc):
+    def __init__(self, muc, filename):
         self.muc = muc
         self.places = dict() # {'place_name': place, ...}
-        #self.things = 
+        self.things = dict() 
 
         doc = xml_parse(filename).documentElement
@@ -22 +22 @@
             place_obj = Place(place.getAttribute('name'),
                               place.getAttribute('description'))
+            self.places[place_obj.name] = place_obj
             gos = place.getElementsByTagName('go')
             for go in gos:
@@ -41 +42 @@
         return None
 
-    def each_thing_by_place(placename):
+    def each_thing_by_place(self, placename):
         for thing in self.things.values():
             if thing.place == placename:
                 yield(thing)
 
-    def move_thing(thing, newplace):
+    def move_thing(self, thing, newplace):
         for t in each_thing_by_place(thing.place):
             # Call leave hooks
@@ -56 +57 @@
                 pres.setType('unavailable')
                 pres.SetTo(thing.jid)
-                send(t.iname, pres) unless t.jid == thing.jid
+                if t.jid != thing.jid:
+                    self.send(t.name, pres)
 
             # Broadcast unavailability presence to all who are here
             if thing.presence:
                 pres = Jabber::Presence.import(thing.presence)
-                pres.type = 'unavailable'
-                pres.to = t.jid
-                send(thing.iname, pres) unless thing.jid == t.jid
+                pres.setType('unavailable')
+                pres.setTo(t.jid)
+                if thing.jid != t.jid:
+                    self.send(thing.name, pres)
 
         # Enter new place
@@ -73 +76 @@
             if t.presence:
                 pres = Jabber::Presence.import(t.presence)
-                pres.to = thing.jid
-                send(t.iname, pres)
+                pres.setTo(thing.jid)
+                self.send(t.name, pres)
 
             # Broadcast availability presence to all who are here
             if thing.presence:
                 pres = Jabber::Presence.import(thing.presence)
-                pres.to = t.jid
-                send(thing.iname, pres)
+                pres.setTo(t.jid)
+                self.send(thing.name, pres)
 
         thing.send_message(None, ' ')
         if newplace:
-            subject = newplace.dup.capitalize()
+            subject = newplace.capitalize()
         else:
             subject = ' '
@@ -97 +100 @@
     def handle_presence(pres):
         # A help for the irritated first:
-        if pres.type == 'subscribe':
-            msg = Jabber::Message.new(pres.from)
+        if pres.getType() == 'subscribe':
+            msg = Message(pres.from)
             msg.type = 'normal'
             msg.subject = 'Adventure component help'
@@ -154 +157 @@
         player = None
         for thing in self.things.values():
-            if thing.kind_of?(Player) && msg.to.resource == None && msg.from == thing.jid:
+            if isinstance(thing, Player) and msg.getTo().getResource() == None && msg.getFrom() == thing.jid:
                 player = thing
 
         if not player:
             answer = msg.answer
-            answer.type = :error
-            answer.add(Jabber::Error::new('forbidden'))
-            send(msg.to.resource, answer)
-            return True
-
-        if not command(player, msg.body):
+            answer.setType('error')
+            #answer.add(Jabber::Error::new('forbidden'))
+            send(msg.getTo().getResource(), answer)
+            return True
+
+        if not command(player, msg.getBody()):
             for thing in each_thing_by_place(player.place):
                 thing.send_message(player.iname, msg.body)
@@ -172 +175 @@
             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 %s' % #{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}')
+                for c in thing.actions:
+                    player.send_message(None, '(Command) %s %s' % (c.expressions[0], thing.name))
             return True
         else:
-            words = text.split(/ /)
-            cmd = words.shift
-            what = words.shift or ''
+            words = text.split(' ')
+            cmd = words.pop(0)
+            if len(words):
+                what = words.pop(0)
+            else:
+                what = ''
             if cmd == 'go':
                 oldplace = place(player.place)
@@ -192 +198 @@
                     move_thing(player, newplace)
                 else:
-                    player.send_message(nil, 'You cannot go there')
+                    player.send_message(None, 'You cannot go there')
                 return True
             elif cmd == 'who':
-                player.send_message(None, "Players in \"#{iname}\":")
-                for thing in each_element('thing'):
-                    if thing.kind_of?(Player):
-                        player.send_message(None, "#{thing.iname} is at/in #{thing.place}")
+                player.send_message(None, 'Players in "%s":' % self.name)
+                for thing in self.things.values():
+                    if isinstance(thing, Player):
+                        player.send_message(None, '%s is at/in %s' % (thing.name, thing.place))
                 return True
             else:
                 handled = False
                 for thing in each_thing_by_place(player.place):
-                    if what.downcase == thing.command_name.downcase:
-                        for c in thing.each_element('on-command'):
-                            if c.attributes['command'] == cmd
-                            thing.command(player, c, words)
-                            handled = True
+                    if what.lower() in thing.aliases:
+                        for action in thing.actions:
+                            for c in action.expressions
+                                if c == cmd:
+                                    thing.command(player, action, words)
+                                    handled = True
                 if handled:
                     return True
         return False
 
-class Thing(REXML::Element):
-    def initialize(world):
-        super('thing')
-        self.world = world
-
-    def add(xmlelement):
-        if xmlelement.kind_of?(REXML::Element) && (xmlelement.name == 'presence'):
-            super(Jabber::Presence.import(xmlelement))
-        else:
-            super(xmlelement)
-
-    def iname(self):
-        return attributes['name']
-
-    def command_name(self):
-        if attributes['command-name']:
-            return attributes['command-name']
-        return self.iname()
-
-    def place():
-        return attributes['place']
-
-    def place(p):
-        attributes['place'] = p
-
-    def jid():
-        return None
-
-    def presence():
-        xe = nil
-        for pres in each_element('presence'):
-            xe = Jabber::Presence.import(pres)
-        if self.kind_of?(Player):
-            xe.add(Jabber::MUC::XMUCUser.new).add(Jabber::MUC::XMUCUserItem.new(:none, :participant))
-        else:
-            xe.add(Jabber::MUC::XMUCUser.new).add(Jabber::MUC::XMUCUserItem.new(:owner, :moderator))
-        return xe
-
-    def presence(pres):
-        delete_elements('presence')
-        add(pres)
-
-    def see(place):
-        pass
-
-    def send_message(fromresource, text, subject=None):
-        pass
-
-    def send_message_to_place(fromresource, text):
-        for thing in self.world.each_element('thing'):
-            if thing.place == place:
-                thing.send_message(fromresource, text)
-  
-    def on_enter(thing, from):
-        for c in each_element('on-enter'):
-            command(thing, c, [from])
-
-    def on_leave(thing, to):
-        for c in each_element('on-leave'):
-            command(thing, c, [to])
-
-    def command(source, command, arguments):
-        for action in command.each_element:
-            if action.text:
-                text = action.text.dup
-            else:
-                text = ''
-            text.gsub!('%self%', iname)
-            text.gsub!('%actor%', source.iname)
-            text.gsub!('%place%', place)
-            if action.name == 'say' or action.name == 'tell':
-                sender = nil
-                if action.name == 'say':
-                    sender = iname
-                if action.attributes['to'] == 'all':
-                    send_message_to_place(sender, text)
-                else:
-                    source.send_message(sender, text)
-