From 8f02530c64225cb245a624ea3e8cf7562bf7653e Mon Sep 17 00:00:00 2001 From: David Rose Date: Tue, 19 Aug 2003 01:26:45 +0000 Subject: [PATCH] split serverTime into serverTimeSec and serverTimeUSec --- .../src/distributed/DistributedSmoothNode.py | 51 ++++++++++++++----- 1 file changed, 38 insertions(+), 13 deletions(-) diff --git a/direct/src/distributed/DistributedSmoothNode.py b/direct/src/distributed/DistributedSmoothNode.py index 6d3718f8a8..b4572a0159 100644 --- a/direct/src/distributed/DistributedSmoothNode.py +++ b/direct/src/distributed/DistributedSmoothNode.py @@ -11,6 +11,9 @@ import Task # avatar and suggest a resync for both. MaxFuture = base.config.GetFloat("smooth-max-future", 0.2) +# How frequently can we suggest a resynchronize with another client? +MinSuggestResync = base.config.GetFloat("smooth-min-suggest-resync", 15) + # These flags indicate whether global smoothing and/or prediction is # allowed or disallowed. EnableSmoothing = base.config.GetBool("smooth-enable-smoothing", 1) @@ -81,6 +84,7 @@ class DistributedSmoothNode(DistributedNode.DistributedNode): self.smoother = SmoothMover() self.smoothStarted = 0 + self.lastSuggestResync = 0 ### Methods to handle computing and updating of the smoothed ### position. @@ -283,8 +287,8 @@ class DistributedSmoothNode(DistributedNode.DistributedNode): now = globalClock.getFrameTime() local = globalClockDelta.networkToLocalTime(timestamp, now) - real = globalClock.getRealTime() - chug = real - now + realTime = globalClock.getRealTime() + chug = realTime - now # Sanity check the timestamp from the other avatar. It should # be just slightly in the past, but it might be off by as much @@ -292,10 +296,16 @@ class DistributedSmoothNode(DistributedNode.DistributedNode): howFarFuture = local - now if howFarFuture - chug >= MaxFuture: # Too far off; advise the other client of our clock information. - if globalClockDelta.getUncertainty() != None: + if globalClockDelta.getUncertainty() != None and \ + realTime - self.lastSuggestResync >= MinSuggestResync: + self.lastSuggestResync = realTime + timestampB = globalClockDelta.localToNetworkTime(realTime) + serverTime = realTime - globalClockDelta.getDelta() + self.notify.info("Suggesting resync for %s, with discrepency %s; local time is %s and server time is %s." % ( + self.doId, howFarFuture - chug, + realTime, serverTime)) self.d_suggestResync(self.cr.localToonDoId, timestamp, - globalClockDelta.getRealNetworkTime(), - real - globalClockDelta.getDelta(), + timestampB, serverTime, globalClockDelta.getUncertainty()) self.smoother.setTimestamp(local) @@ -337,39 +347,54 @@ class DistributedSmoothNode(DistributedNode.DistributedNode): ### Monitor clock sync ### - def d_suggestResync(self, avId, timestampA, timestampB, serverTime, uncertainty): - self.sendUpdate("suggestResync", [avId, timestampA, timestampB, serverTime, uncertainty]) + def d_suggestResync(self, avId, timestampA, timestampB, + serverTime, uncertainty): + serverTimeSec = math.floor(serverTime) + serverTimeUSec = (serverTime - serverTimeSec) * 10000.0 + self.sendUpdate("suggestResync", [avId, timestampA, timestampB, + serverTimeSec, serverTimeUSec, + uncertainty]) - def suggestResync(self, avId, timestampA, timestampB, serverTime, uncertainty): - """suggestResync(self, avId) + def suggestResync(self, avId, timestampA, timestampB, + serverTimeSec, serverTimeUSec, uncertainty): + """suggestResync(self, avId, ....) This message is sent from one client to another when the other client receives a timestamp from this client that is so far out of date as to suggest that one or both clients needs to resynchronize their clock information. """ + serverTime = float(serverTimeSec) + float(serverTimeUSec) / 10000.0 result = \ self.peerToPeerResync(avId, timestampA, serverTime, uncertainty) if result >= 0 and \ globalClockDelta.getUncertainty() != None: other = self.cr.doId2do.get(avId) if other and hasattr(other, "d_returnResync"): - real = globalClock.getRealTime() + realTime = globalClock.getRealTime() + serverTime = realTime - globalClockDelta.getDelta() + self.notify.info("Returning resync for %s; local time is %s and server time is %s." % ( + self.doId, realTime, serverTime)) other.d_returnResync(self.cr.localToonDoId, timestampB, - real - globalClockDelta.getDelta(), + serverTime, globalClockDelta.getUncertainty()) def d_returnResync(self, avId, timestampB, serverTime, uncertainty): - self.sendUpdate("returnResync", [avId, timestampB, serverTime, uncertainty]) + serverTimeSec = math.floor(serverTime) + serverTimeUSec = (serverTime - serverTimeSec) * 10000.0 + self.sendUpdate("returnResync", [avId, timestampB, + serverTimeSec, serverTimeUSec, + uncertainty]) - def returnResync(self, avId, timestampB, serverTime, uncertainty): + def returnResync(self, avId, timestampB, serverTimeSec, serverTimeUSec, uncertainty): """returnResync(self, avId) A reply sent by a client whom we recently sent suggestResync to, this reports the client's new delta information so we can adjust our clock as well. """ + serverTime = float(serverTimeSec) + float(serverTimeUSec) / 10000.0 self.peerToPeerResync(avId, timestampB, serverTime, uncertainty) def peerToPeerResync(self, avId, timestamp, serverTime, uncertainty):