"""ClientRepository module: contains the ClientRepository class"""
from .ClientRepositoryBase import ClientRepositoryBase
from direct.directnotify import DirectNotifyGlobal
from .MsgTypesCMU import *
from .PyDatagram import PyDatagram
from .PyDatagramIterator import PyDatagramIterator
from panda3d.core import UniqueIdAllocator
[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)
self.doIdAllocator.free(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 == 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 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)
self.notify.info("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 = globalClock.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(ostream)
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)
