def post(self,metaAction):
cmeta = ops.loadmeta()
tKind = self.request.get('tKind')
tID = self.request.get('tID')
tMedo = ndb.Key(tKind,int(tID)).get()
if self.request.get('rKind'):
rKind = self.request.get('rKind')
rID = self.request.get('rID')
if rKind == 'Location':
rMedo = Location()
rMedo.metakind = 'Location'
rMedo.xloc = cmeta.xloc
rMedo.yloc = cmeta.yloc
rMedo.zloc = cmeta.zloc
rMedo.lattice = cmeta.lattice
rMedo.name = cmeta.cokid
else:
rMedo = ndb.Key(rKind,int(rID)).get()
if metaAction == 'Laugh':
Laugh()
# channel.send_message(str(localmeta), ops.jsonify(pack))
if metaAction == 'MineNode':
MineNode(cmeta,tMedo)
if metaAction == 'Kick':
Kick(cmeta,tMedo)
if metaAction == 'Relo':
Relo(tMedo,rMedo)
def get(self):
try:
cmeta = ops.loadmeta()
q = Location.query(
Location.xloc == cmeta.xloc,
Location.yloc == cmeta.yloc,
Location.zloc == cmeta.zloc,
Location.lattice == cmeta.lattice)
q = q.get()
self.response.out.write(ops.jsonify(q))
except AttributeError:
q = Location()
q.exits = 'n,e,s,w,nw,ne,se,sw,u,d'
q.metakind = 'Location'
q.metaid = cmeta.xloc+cmeta.yloc+cmeta.zloc+cmeta.lattice
q.name = 'Beyond Eden'
q.info = "You have wandered beyond constructed space. Don't get lost!"
if cmeta:
q.xloc = cmeta.xloc
q.yloc = cmeta.yloc
q.zloc = cmeta.zloc
q.lattice = cmeta.lattice
else:
q.xloc = '500'
q.yloc = '500'
q.zloc = '500'
q.lattice = '0'
q = q.to_dict()
jsonData = json.dumps(q)
self.response.out.write(jsonData)
def PackObj(sitem):
cmeta = ops.loadmeta()
if sitem.kid == cmeta.kid:
sitem.metasheetupdater = True
sitem.updater = True
localmetas = ops.fetchLocalMetaMetaIDs('Meta',cmeta.metaid)
for localmeta in localmetas:
channel.send_message(str(localmeta), ops.jsonify(sitem))
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)
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))
def SelfEcho(content):
cmeta = ops.loadmeta()
pack = Packet()
sloc = ops.loadcloc()
pack.scopename = sloc.name
pack.type = 'action'
pack.scope = 'local'
pack.formatted = content
pack.content = content + " hohum"
pack.masterid = str(cmeta.masterid)
pack.name = cmeta.name
pack.metakind = cmeta.metakind
pack.metaid = cmeta.metaid
channel.send_message(str(cmeta.metaid), ops.jsonify(pack))
def MetaEcho(content):
cmeta = ops.loadmeta()
pack = Packet()
localmetas = ops.fetchLocalMetaMetaIDs('Meta',cmeta.metaid)
sloc = ops.loadcloc()
formatted = "["+sloc.name+"]<b> " + cmeta.name + "</b>: " + content + " haha"
for localmeta in localmetas:
pack.scopename = sloc.name
pack.type = 'broadcast'
pack.scope = 'local'
pack.formatted = formatted
pack.content = content + " hoho"
pack.masterid = str(cmeta.masterid)
pack.name = cmeta.name
pack.metakind = cmeta.metakind
pack.metaid = cmeta.metaid
channel.send_message(str(localmeta), ops.jsonify(pack))
def post(self,metakind,metaid,dkind,did):
mobject = ndb.Key(metakind, int(metaid)).get()
if 'Location' in mobject.cowner:
ops.updateclocstate()
mobject.cowner = dkind+'.'+did
if metakind == 'Meta':
pass
elif dkind == 'Location':
cloc = ops.loadcloc()
mobject.xloc = cloc.xloc
mobject.yloc = cloc.yloc
mobject.zloc = cloc.zloc
mobject.put()
ops.updateclocstate()
elif dkind == 'Meta':
cmeta = ops.loadmeta()
nowner = ndb.Key('Meta', int(did)).get()
pack = Packet()
pack.type = 'reinv'
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(nowner.masterid, pack)
mobject.xloc = ''
mobject.yloc = ''
mobject.zloc = ''
mobject.put()
mobject = mobject.to_dict()
jsonData = json.dumps(mobject)
self.response.out.write(jsonData)
def post(self):
cmeta = ops.loadmeta()
spec = Item();
spec.name = self.request.get('title')
spec.info = self.request.get('info')
spec.itype = 'YouTube'
spec.primertype = 'Item'
spec.shardtype = 'Generic'
spec.fragtype = 'YouTube'
spec.cowner = 'Meta'+str(cmeta.metaid)
spec.lattice = '0'
spec.metakind = 'Item'
spec.ytlink = self.request.get('ytlink')
spec.actions = ['Kick','Watch']
spec.put()
spec.metaid = spec.key.id()
spec.put()
def get(self,target):
if target == 'self' or target == '':
tMeta = ops.loadmeta()
else:
tMeta = ops.KIDtoMedo(target)
q = []
for crystal in Crystal.query(Crystal.cowner == 'Meta'+str(tMeta.metaid)).fetch(50):
q.append(crystal)
for blueprint in Blueprint.query(Blueprint.cowner == 'Meta'+str(tMeta.metaid)).fetch(50):
q.append(blueprint)
for item in Item.query(Item.cowner == 'Meta'+str(tMeta.metaid)).fetch(50):
q.append(item)
cinv = q
invli = []
for inv in cinv:
inv = inv.to_dict()
invli.append(inv)
self.response.out.write(ops.sonify(invli))
def CreateDigiFort():
cmeta = ops.loadmeta()
spec = Item();
spec.name = 'Digital Fortress of ' + cmeta.name
spec.info = 'This is a test item.'
spec.itype = 'Test'
spec.primertype = 'Generic'
spec.shardtype = 'Generic'
spec.fragtype = 'Generic'
spec.cowner = 'Meta'+str(cmeta.metaid)
spec.lattice = '0'
spec.metakind = 'Item'
spec.actions = ['Enter']
spec.supertype = 'Landmark'
spec.regtype = 'Mine'
spec.databit = 0
spec.put()
spec.metaid = spec.key.id()
spec.put()
def PackPacket(packtype,scopename,scope,formatted,content):
cmeta = ops.loadmeta()
pack = Packet()
if scope == 'local':
targetmetas = ops.fetchLocalMetaMetaIDs('Meta',cmeta.metaid)
elif scope == 'global' or scope == 'system':
targetmetas = ops.fetchAllMetaMetaIDs()
for targetmeta in targetmetas:
pack.scopename = scopename
pack.type = packtype
pack.scope = scope
pack.formatted = formatted
pack.content = content
pack.masterid = str(cmeta.masterid)
pack.name = cmeta.name
pack.metakind = cmeta.metakind
pack.metaid = cmeta.metaid
channel.send_message(str(targetmeta), ops.jsonify(pack))
def cProc(command):
cmeta = ops.loadmeta()
if command == '/datamine':
unicon.CreateDataMine()
SelfEcho('DataMine Created.')
elif command == '/digifort':
unicon.CreateDigiFort()
SelfEcho('DigitalFortress Created.')
elif command == '/spawnloc':
unicon.Spawn().Location()
SelfEcho('Location Created.')
elif command == '/newloc':
para = Packet()
para.name = 'Test'
para.info = 'Test Info'
para.xloc = cmeta.xloc
para.yloc = cmeta.yloc
para.zloc = cmeta.zloc
para.lattice = cmeta.lattice
protos.spawnLoca(para)
else:
content = 'Invalid Command: ' + command
SelfEcho(content)
def CreateDataMine():
cmeta = ops.loadmeta()
spec = Item();
spec.name = 'Data Mine 4'
spec.info = 'This is a test item.'
spec.itype = 'Test'
spec.primertype = 'Generic'
spec.shardtype = 'Generic'
spec.fragtype = 'Generic'
spec.cowner = 'Meta'+str(cmeta.metaid)
spec.lattice = '0'
spec.metakind = 'Item'
spec.actions = ['Mine Node','Kick']
spec.supertype = 'Landmark'
spec.regtype = 'Mine'
spec.databit = 0
spec.ispopup = True
spec.xloc = '500'
spec.yloc = '500'
spec.zloc = '500'
spec.put()
spec.metaid = spec.key.id()
spec.put()
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)
def post(self, direction):
cmeta = ops.loadmeta()
cmeta.cokind = 'Location' #Not robust
premove = copy.copy(ops.loadmeta())
cloc = ops.loadcloc()
localmetas = ops.fetchLocalMetaMetaIDs('Meta',cmeta.metaid)
pack = Packet()
pack.scope = 'local'
pack.type = 'move'
for localmeta in localmetas:
if localmeta == cmeta.metaid:
pack.content = "You move " + ops.dirFull(direction) + "."
pack.type = 'usermove'
channel.send_message(str(localmeta), ops.jsonify(pack))
else:
pack.content = cmeta.name + " has moved " + ops.dirFull(direction)
pack.name = cmeta.name
pack.destination = ops.dirFull(direction)
pack.type = 'userleave'
channel.send_message(str(localmeta), ops.jsonify(pack))
if direction == 'n':
cmeta.yloc = str(int(cmeta.yloc)+1)
elif direction == 's':
cmeta.yloc = str(int(cmeta.yloc)-1)
elif direction == 'e':
cmeta.xloc = str(int(cmeta.xloc)+1)
elif direction == 'w':
cmeta.xloc = str(int(cmeta.xloc)-1)
elif direction == 'u':
cmeta.zloc = str(int(cmeta.zloc)+1)
elif direction == 'd':
cmeta.zloc = str(int(cmeta.zloc)-1)
elif direction == 'ne':
cmeta.xloc = str(int(cmeta.xloc)+1)
cmeta.yloc = str(int(cmeta.yloc)+1)
elif direction == 'se':
cmeta.xloc = str(int(cmeta.xloc)+1)
cmeta.yloc = str(int(cmeta.yloc)-1)
elif direction == 'sw':
cmeta.xloc = str(int(cmeta.xloc)-1)
cmeta.yloc = str(int(cmeta.yloc)-1)
elif direction == 'nw':
cmeta.xloc = str(int(cmeta.xloc)-1)
cmeta.yloc = str(int(cmeta.yloc)+1)
cmeta.put()
newlocalmetas = ops.fetchLocalMetaMetaIDs('Meta',cmeta.metaid)
for newlocalmeta in newlocalmetas:
if newlocalmeta == cmeta.metaid:
pass
else:
pack.content = cmeta.name + " has arrived from the " + ops.dirOpp(direction)
pack.type = 'userenter'
pack.name = cmeta.name
pack.destination = ops.dirOpp(direction)
channel.send_message(str(newlocalmeta), ops.jsonify(pack))
DepthPerception(premove,cmeta)
#self.response.out.write(cmeta.xloc+cmeta.yloc+cmeta.zloc+cmeta.lattice)
nLocaMetas = ops.fetchLocalMetas(Meta, cmeta.metaid)
nloc = Packet()
nloc.locdata = cloc
nloc.metashere = nLocaMetas
self.response.out.write(ops.jsonify(nloc))
def get(self):
cmeta = ops.loadmeta()
if cmeta:
self.response.out.write(json.dumps(cmeta.to_dict()))
else:
self.response.out.write(json.dumps('false'))
def get(self):
if ops.loadmeta():
self.response.out.write(ops.jsonify(ops.loadmeta()))
else:
self.response.out.write(ops.jsonify('nometa'))
def get(self):
cmeta = ops.loadmeta()
puis = ops.fetchPopUpItems('Meta',cmeta.metaid)
self.response.out.write(ops.sonify(puis))
def get(self):
cmeta = ops.loadmeta()
localitems = ops.fetchLocalItems('Meta',cmeta.metaid)
self.response.out.write(ops.sonify(localitems))
def get(self):
cmeta = ops.loadmeta()
token = channel.create_channel(str(cmeta.metaid),1440)
self.response.out.write(ops.sonify(token))
