Source code for direct.distributed.ClientRepository

"""ClientRepository module: contains the ClientRepository class"""

from .ClientRepositoryBase import ClientRepositoryBase
from direct.directnotify import DirectNotifyGlobal
from direct.showbase.MessengerGlobal import messenger
from .MsgTypesCMU import *
from .PyDatagram import PyDatagram
from .PyDatagramIterator import PyDatagramIterator
from panda3d.core import UniqueIdAllocator, Notify, ClockObject

[docs]class ClientRepository(ClientRepositoryBase): """ This is the open-source ClientRepository as provided by CMU. It communicates with the ServerRepository in this same directory. If you are looking for the VR Studio's implementation of the client repository, look to OTPClientRepository (elsewhere). """ notify = DirectNotifyGlobal.directNotify.newCategory("ClientRepository") # This is required by DoCollectionManager, even though it's not # used by this implementation. GameGlobalsId = 0 doNotDeallocateChannel = True
[docs] def __init__(self, dcFileNames = None, dcSuffix = '', connectMethod = None, threadedNet = None): ClientRepositoryBase.__init__(self, dcFileNames = dcFileNames, dcSuffix = dcSuffix, connectMethod = connectMethod, threadedNet = threadedNet) self.setHandleDatagramsInternally(False) base.finalExitCallbacks.append(self.shutdown) # The doId allocator. The CMU LAN server may choose to # send us a block of doIds. If it chooses to do so, then we # may create objects, using those doIds. self.doIdAllocator = None self.doIdBase = 0 self.doIdLast = 0 # The doIdBase of the client message currently being # processed. self.currentSenderId = None # Explicitly-requested interest zones. self.interestZones = []
[docs] def handleSetDoIdrange(self, di): self.doIdBase = di.getUint32() self.doIdLast = self.doIdBase + di.getUint32() self.doIdAllocator = UniqueIdAllocator(self.doIdBase, self.doIdLast - 1) self.ourChannel = self.doIdBase self.createReady()
[docs] def createReady(self): # Now that we've got a doId range, we can safely generate new # distributed objects. messenger.send('createReady', taskChain = 'default') messenger.send(self.uniqueName('createReady'), taskChain = 'default')
[docs] def handleRequestGenerates(self, di): # When new clients join the zone of an object, they need to hear # about it, so we send out all of our information about objects in # that particular zone. zone = di.getUint32() for obj in self.doId2do.values(): if obj.zoneId == zone: if self.isLocalId(obj.doId): self.resendGenerate(obj)
[docs] def resendGenerate(self, obj): """ Sends the generate message again for an already-generated object, presumably to inform any newly-arrived clients of this object's current state. """ # get the list of "ram" fields that aren't # required. These are fields whose values should # persist even if they haven't been received # lately, so we have to re-broadcast these values # in case the new client hasn't heard their latest # values. extraFields = [] for i in range(obj.dclass.getNumInheritedFields()): field = obj.dclass.getInheritedField(i) if field.hasKeyword('broadcast') and field.hasKeyword('ram') and not field.hasKeyword('required'): if field.asMolecularField(): # It's a molecular field; this means # we have to pack the components. # Fortunately, we'll find those # separately through the iteration, so # we can ignore this field itself. continue extraFields.append(field.getName()) datagram = self.formatGenerate(obj, extraFields) self.send(datagram)
[docs] def handleGenerate(self, di): self.currentSenderId = di.getUint32() zoneId = di.getUint32() classId = di.getUint16() doId = di.getUint32() # Look up the dclass dclass = self.dclassesByNumber[classId] distObj = self.doId2do.get(doId) if distObj and distObj.dclass == dclass: # We've already got this object. Probably this is just a # repeat-generate, synthesized for the benefit of someone # else who just entered the zone. Accept the new updates, # but don't make a formal generate. assert self.notify.debug("performing generate-update for %s %s" % (dclass.getName(), doId)) dclass.receiveUpdateBroadcastRequired(distObj, di) dclass.receiveUpdateOther(distObj, di) return assert self.notify.debug("performing generate for %s %s" % (dclass.getName(), doId)) dclass.startGenerate() # Create a new distributed object, and put it in the dictionary distObj = self.generateWithRequiredOtherFields(dclass, doId, di, 0, zoneId) dclass.stopGenerate()
[docs] def allocateDoId(self): """ Returns a newly-allocated doId. Call freeDoId() when the object has been deleted. """ return self.doIdAllocator.allocate()
[docs] def reserveDoId(self, doId): """ Removes the indicate doId from the available pool, as if it had been explicitly allocated. You may pass it to freeDoId() later if you wish. """ self.doIdAllocator.initialReserveId(doId) return doId
[docs] def freeDoId(self, doId): """ Returns a doId back into the free pool for re-use. """ assert self.isLocalId(doId)
[docs] def storeObjectLocation(self, object, parentId, zoneId): # The CMU implementation doesn't use the DoCollectionManager # much. object.parentId = parentId object.zoneId = zoneId
[docs] def createDistributedObject(self, className = None, distObj = None, zoneId = 0, optionalFields = None, doId = None, reserveDoId = False): """ To create a DistributedObject, you must pass in either the name of the object's class, or an already-created instance of the class (or both). If you pass in just a class name (to the className parameter), then a default instance of the object will be created, with whatever parameters the default constructor supplies. Alternatively, if you wish to create some initial values different from the default, you can create the instance yourself and supply it to the distObj parameter, then that instance will be used instead. (It should be a newly-created object, not one that has already been manifested on the network or previously passed through createDistributedObject.) In either case, the new DistributedObject is returned from this method. This method will issue the appropriate network commands to make this object appear on all of the other clients. You should supply an initial zoneId in which to manifest the object. The fields marked "required" or "ram" will be broadcast to all of the other clients; if you wish to broadcast additional field values at this time as well, pass a list of field names in the optionalFields parameters. Normally, doId is None, to mean allocate a new doId for the object. If you wish to use a particular doId, pass it in here. If you also pass reserveDoId = True, this doId will be reserved from the allocation pool using self.reserveDoId(). You are responsible for ensuring this doId falls within the client's allowable doId range and has not already been assigned to another object. """ if not className: if not distObj: self.notify.error("Must specify either a className or a distObj.") className = distObj.__class__.__name__ if doId is None: doId = self.allocateDoId() elif reserveDoId: self.reserveDoId(doId) dclass = self.dclassesByName.get(className) if not dclass: self.notify.error("Unknown distributed class: %s" % (distObj.__class__)) classDef = dclass.getClassDef() if classDef is None: self.notify.error("Could not create an undefined %s object." % ( dclass.getName())) if not distObj: distObj = classDef(self) if not isinstance(distObj, classDef): self.notify.error("Object %s is not an instance of %s" % (distObj.__class__.__name__, classDef.__name__)) distObj.dclass = dclass distObj.doId = doId self.doId2do[doId] = distObj distObj.generateInit() distObj._retrieveCachedData() distObj.generate() distObj.setLocation(0, zoneId) distObj.announceGenerate() datagram = self.formatGenerate(distObj, optionalFields) self.send(datagram) return distObj
[docs] def formatGenerate(self, distObj, extraFields): """ Returns a datagram formatted for sending the generate message for the indicated object. """ return distObj.dclass.clientFormatGenerateCMU(distObj, distObj.doId, distObj.zoneId, extraFields)
[docs] def sendDeleteMsg(self, doId): datagram = PyDatagram() datagram.addUint16(OBJECT_DELETE_CMU) datagram.addUint32(doId) self.send(datagram)
[docs] def sendDisconnect(self): if self.isConnected(): # Tell the game server that we're going: datagram = PyDatagram() # Add message type datagram.addUint16(CLIENT_DISCONNECT_CMU) # Send the message self.send(datagram)"Sent disconnect message to server") self.disconnect() self.stopHeartbeat()
[docs] def setInterestZones(self, interestZoneIds): """ Changes the set of zones that this particular client is interested in hearing about. """ datagram = PyDatagram() # Add message type datagram.addUint16(CLIENT_SET_INTEREST_CMU) for zoneId in interestZoneIds: datagram.addUint32(zoneId) # send the message self.send(datagram) self.interestZones = interestZoneIds[:]
[docs] def setObjectZone(self, distObj, zoneId): """ Moves the object into the indicated zone. """ distObj.b_setLocation(0, zoneId) assert distObj.zoneId == zoneId # Tell all of the clients monitoring the new zone that we've # arrived. self.resendGenerate(distObj)
[docs] def sendSetLocation(self, doId, parentId, zoneId): datagram = PyDatagram() datagram.addUint16(OBJECT_SET_ZONE_CMU) datagram.addUint32(doId) datagram.addUint32(zoneId) self.send(datagram)
[docs] def sendHeartbeat(self): datagram = PyDatagram() # Add message type datagram.addUint16(CLIENT_HEARTBEAT_CMU) # Send it! self.send(datagram) self.lastHeartbeat = ClockObject.getGlobalClock().getRealTime() # This is important enough to consider flushing immediately # (particularly if we haven't run readerPollTask recently). self.considerFlush()
[docs] def isLocalId(self, doId): """ Returns true if this doId is one that we're the owner of, false otherwise. """ return doId >= self.doIdBase and doId < self.doIdLast
[docs] def haveCreateAuthority(self): """ Returns true if this client has been assigned a range of doId's it may use to create objects, false otherwise. """ return self.doIdLast > self.doIdBase
[docs] def getAvatarIdFromSender(self): """ Returns the doIdBase of the client that originally sent the current update message. This is only defined when processing an update message or a generate message. """ return self.currentSenderId
[docs] def handleDatagram(self, di): if self.notify.getDebug(): print("ClientRepository received datagram:") di.getDatagram().dumpHex(Notify.out()) msgType = self.getMsgType() self.currentSenderId = None # These are the sort of messages we may expect from the public # Panda server. if msgType == SET_DOID_RANGE_CMU: self.handleSetDoIdrange(di) elif msgType == OBJECT_GENERATE_CMU: self.handleGenerate(di) elif msgType == OBJECT_UPDATE_FIELD_CMU: self.handleUpdateField(di) elif msgType == OBJECT_DISABLE_CMU: self.handleDisable(di) elif msgType == OBJECT_DELETE_CMU: self.handleDelete(di) elif msgType == REQUEST_GENERATES_CMU: self.handleRequestGenerates(di) else: self.handleMessageType(msgType, di) # If we're processing a lot of datagrams within one frame, we # may forget to send heartbeats. Keep them coming! self.considerHeartbeat()
[docs] def handleMessageType(self, msgType, di): self.notify.error("unrecognized message type %s" % (msgType))
[docs] def handleUpdateField(self, di): # The CMU update message starts with an additional field, not # present in the Disney update message: the doIdBase of the # original sender. Extract that and call up to the parent. self.currentSenderId = di.getUint32() ClientRepositoryBase.handleUpdateField(self, di)
[docs] def handleDisable(self, di): # Receives a list of doIds. while di.getRemainingSize() > 0: doId = di.getUint32() # We should never get a disable message for our own object. assert not self.isLocalId(doId) self.disableDoId(doId)
[docs] def handleDelete(self, di): # Receives a single doId. doId = di.getUint32() self.deleteObject(doId)
[docs] def deleteObject(self, doId): """ Removes the object from the client's view of the world. This should normally not be called directly except in the case of error recovery, since the server will normally be responsible for deleting and disabling objects as they go out of scope. After this is called, future updates by server on this object will be ignored (with a warning message). The object will become valid again the next time the server sends a generate message for this doId. This is not a distributed message and does not delete the object on the server or on any other client. """ if doId in self.doId2do: # If it is in the dictionary, remove it. obj = self.doId2do[doId] # Remove it from the dictionary del self.doId2do[doId] # Disable, announce, and delete the object itself... # unless delayDelete is on... obj.deleteOrDelay() if self.isLocalId(doId): self.freeDoId(doId) elif self.cache.contains(doId): # If it is in the cache, remove it. self.cache.delete(doId) if self.isLocalId(doId): self.freeDoId(doId) else: # Otherwise, ignore it self.notify.warning( "Asked to delete non-existent DistObj " + str(doId))
[docs] def stopTrackRequestDeletedDO(self, *args): # No-op. Not entirely sure what this does on the VR Studio side. pass
[docs] def sendUpdate(self, distObj, fieldName, args): """ Sends a normal update for a single field. """ dg = distObj.dclass.clientFormatUpdate( fieldName, distObj.doId, args) self.send(dg)
[docs] def sendUpdateToChannel(self, distObj, channelId, fieldName, args): """ Sends a targeted update of a single field to a particular client. The top 32 bits of channelId is ignored; the lower 32 bits should be the client Id of the recipient (i.e. the client's doIdbase). The field update will be sent to the indicated client only. The field must be marked clsend or p2p, and may not be marked broadcast. """ datagram = distObj.dclass.clientFormatUpdate( fieldName, distObj.doId, args) dgi = PyDatagramIterator(datagram) # Reformat the packed datagram to change the message type and # add the target id. dgi.getUint16() dg = PyDatagram() dg.addUint16(CLIENT_OBJECT_UPDATE_FIELD_TARGETED_CMU) dg.addUint32(channelId & 0xffffffff) dg.appendData(dgi.getRemainingBytes()) self.send(dg)