예제 #1
0
def Relo(tMedo,rMedo):
    # Load Stuff
    relocator = ops.loadmeta()
    rKind = rMedo.metakind
    tKind = tMedo.metakind
    premove = copy.copy(tMedo)

    if tMedo.cowner:
        origin = tMedo.cowner
    else:
        origin = 'Location'+tMedo.xloc+tMedo.yloc+tMedo.zloc+tMedo.lattice
    oKID = ops.metasplit(origin)
    oKind = oKID[0]
    oID = oKID[1]
    ops.mdb(origin, 'the non location')
    
    try:
        oMedo = ndb.Key(oKind, int(oID)).get()
    except ValueError:
        ops.mdb('except')
    
    if oKind == 'Location':
        oMedo = Location()
        oMedo.name = relocator.cokid
        
    
    # Do Stuff
    tMedo.cowner = rMedo.kid
    
    if tKind == 'Meta':
        pass #shouldn't pass the frontend check
    elif rKind == 'Location':
        tMedo.xloc = rMedo.xloc
        tMedo.yloc = rMedo.yloc
        tMedo.zloc = rMedo.zloc
        tMedo.lattice = rMedo.lattice
        tMedo.cokind = 'Location'
        tMedo.coid = str(rMedo.xloc)+str(rMedo.yloc)+str(rMedo.zloc)+str(rMedo.lattice)
        tMedo.put()
        
    elif rKind == 'Meta':
        tMedo.xloc = ''
        tMedo.yloc = ''
        tMedo.zloc = ''
        tMedo.lattice = rMedo.lattice
        tMedo.cokind = 'Meta'
        tMedo.coid = str(rMedo.metaid)
        tMedo.put()
    who = relocator.name
    if rMedo == relocator:
        what = ' picks up [' + tMedo.name + '] from [' + oMedo.name + ']'
    elif rMedo.metakind == 'Location':
        what = ' drops [' + tMedo.name + '] @ [' + rMedo.name + ']'
    else:
        what = ' moves ...'
    vision = who + what
    
    DepthPerception(premove,tMedo,vision)
예제 #2
0
def DepthPerception(before,after,vision=False):
    cmeta = ops.loadmeta()
    cloc = ops.loadcloc()
    bMetaIDs = ops.fetchXYZMIDs(before.xyz)
    aMetaIDs = ops.fetchXYZMIDs(after.xyz)
    eMetaIDs = ops.conKIDs(bMetaIDs, aMetaIDs)
    pack = Packet()
    pack.refresh = True
    pack.who = cmeta.kid
    
    if before.databits != after.databits:
        pack.type = 'Databits'
        pack.metakind = before.metakind
        pack.metaid = before.metaid
        pack.kid = before.kid
        pack.medo = after
        for metaID in eMetaIDs:
            channel.send_message(str(metaID), ops.jsonify(pack))
    elif before.xyz != after.xyz: #Relocation
        pack.metakind = before.metakind
        pack.metaid = before.metaid
        pack.kid = before.kid
        pack.fromkind = before.cokind
        pack.tokind = after.cokind 
        pack.fromkid = before.cokind + str(before.coid)
        pack.tokid = after.cokind + str(after.coid)
        pack.medo = after
#        for metaID in eMetaIDs:
#            channel.send_message(str(metaID), ops.jsonify(pack))
        for bMeta in bMetaIDs:
            pack.type = 'MedoMove'
            channel.send_message(str(bMeta), ops.jsonify(pack))
        for aMeta in aMetaIDs:
            if after.metakind != 'Meta':
                if after.cowner == cmeta.kid:
                    pack.type = 'ItemUpdate'
                else:
                    pack.type = 'ItemArrive'
            elif aMeta == cmeta.metaid:
                #ops.mdb(aMeta, 'test')
                pack.type = 'YouArrive'
                pack.cloc = cloc
                pack.nMetas = ops.fetchLocalMetas(after.metakind, after.metaid)
                pack.nItems = ops.fetchLocalItems(after.metakind, after.metaid)
            else:
                pack.type = 'MetaArrive'    
            channel.send_message(str(aMeta), ops.jsonify(pack))
    else:
        ops.mdb('This is else')

    if vision:
        for metaID in eMetaIDs:
            pack = Packet()
            pack.type = 'vision'
            pack.vision = True
            pack.formatted = vision
            channel.send_message(str(metaID), ops.jsonify(pack))
예제 #3
0
    def post(self,dest):
        cmeta = ops.loadmeta()
        sloc = ops.loadcloc()
        content = self.request.get('content')
        pack = Packet()
        
        if dest == 'command':
            cProc(self.request.get('content'))
            ops.mdb(self.request.get('content'), 'command pack')
            formatted = "["+sloc.name+"]<b> " + cmeta.name + "</b>: " + self.request.get('content')
            packtype = 'broadcast'
            scopename = sloc.name
            scope = 'local'

        if dest == 'local':
            
            packtype = 'broadcast'
            scopename = sloc.name
            scope = 'local'
            formatted = "["+sloc.name+"]<b> " + cmeta.name + "</b>: " + self.request.get('content')
            console = True
            
            PackPacket(console,packtype,scopename,scope,formatted,content)
            
        if dest == 'global':
#            if self.request.get('content')[0] == '@':
#                formatted = self.request.get('content')[1:]
#            else:
#                formatted = "[Global]<b> " + cmeta.name + "</b>: " + self.request.get('content')

            packtype = 'broadcast'
            scopename = 'Global'
            scope = 'global'
            formatted = "[Global]<b> " + cmeta.name + "</b>: " + self.request.get('content')
            console = True
            
            PackPacket(console,packtype,scopename,scope,formatted,content)

        elif dest == 'login':
          
            packtype = 'userlogin'
            scopename = 'System'
            scope = 'system'
            content = cmeta.name + "</b> has logged into MetaEden."
            formatted = "[System]<b> " + cmeta.name + "</b> has logged into MetaEden."
            console = 'edenop.ChanRouter.dest==login'
            
            PackPacket(console,packtype,scopename,scope,formatted,content,cmeta)
            
        elif dest == 'pm':
            metakind = self.request.get('metakind')
            metaid = self.request.get('metaid')
            content = self.request.get('content')
            formatted = "[PM]<b> " + cmeta.name + "</b>: " + content
            pack.type = 'pm'
            pack.scope = 'private'
            pack.formatted = formatted
            pack.content = content
            pack.masterid = str(cmeta.masterid)
            pack.name = cmeta.name
            pack.metakind = cmeta.metakind
            pack.metaid = str(cmeta.metaid)
            channel.send_message(str(metaid), ops.jsonify(pack))
            pack.name = metakind+metaid 
            pack.metakind = metakind
            pack.metaid = metaid
            self.response.out.write(ops.jsonify(pack))
        else:
            pack.type = 'msg'
            pack.content = content
            pack.to = str(dest)
            pack.masterid = str(cmeta.masterid)
            pack.name = cmeta.name
            pack.metakind = 'Meta'
            pack.metaid = cmeta.metaid
            pack = json.dumps(pack.to_dict())
            channel.send_message(str(dest), pack)
            self.response.out.write(pack)