when in serverless mode, short-circuit simulation ownership bids

libraries/entities/src/EntityEditPacketSender.cpp

@@ -73,7 +73,6 @@ void EntityEditPacketSender::queueEditAvatarEntityMessage(PacketType type,
     _myAvatar->updateAvatarEntity(entityItemID, binaryProperties);
 
     entity->setLastBroadcast(usecTimestampNow());
-    return;
 }
 
 
@@ -81,10 +80,6 @@ void EntityEditPacketSender::queueEditEntityMessage(PacketType type,
                                                     EntityTreePointer entityTree,
                                                     EntityItemID entityItemID,
                                                     const EntityItemProperties& properties) {
-    if (!_shouldSend) {
-        return; // bail early
-    }
-
     if (properties.getClientOnly() && properties.getOwningAvatarID() == _myAvatar->getID()) {
         // this is an avatar-based entity --> update our avatar-data rather than sending to the entity-server
         queueEditAvatarEntityMessage(type, entityTree, entityItemID, properties);
@@ -143,9 +138,6 @@ void EntityEditPacketSender::queueEditEntityMessage(PacketType type,
 }
 
 void EntityEditPacketSender::queueEraseEntityMessage(const EntityItemID& entityItemID) {
-    if (!_shouldSend) {
-        return; // bail early
-    }
 
     // in case this was a clientOnly entity:
     if(_myAvatar) {

libraries/octree/src/OctreeEditPacketSender.cpp

@@ -22,7 +22,6 @@ const int OctreeEditPacketSender::DEFAULT_MAX_PENDING_MESSAGES = PacketSender::D
 
 
 OctreeEditPacketSender::OctreeEditPacketSender() :
-    _shouldSend(true),
     _maxPendingMessages(DEFAULT_MAX_PENDING_MESSAGES),
     _releaseQueuedMessagesPending(false)
 {
@@ -145,10 +144,6 @@ void OctreeEditPacketSender::queuePendingPacketToNodes(std::unique_ptr<NLPacket>
 }
 
 void OctreeEditPacketSender::queuePacketToNodes(std::unique_ptr<NLPacket> packet) {
-    if (!_shouldSend) {
-        return; // bail early
-    }
-
     assert(serversExist()); // we must have servers to be here!!
 
     auto node = DependencyManager::get<NodeList>()->soloNodeOfType(getMyNodeType());
@@ -161,10 +156,6 @@ void OctreeEditPacketSender::queuePacketToNodes(std::unique_ptr<NLPacket> packet
 // NOTE: editMessage - is JUST the octcode/color and does not contain the packet header
 void OctreeEditPacketSender::queueOctreeEditMessage(PacketType type, QByteArray& editMessage) {
 
-    if (!_shouldSend) {
-        return; // bail early
-    }
-
     // If we don't have servers, then we will simply queue up all of these packets and wait till we have
     // servers for processing
     if (!serversExist()) {

libraries/octree/src/OctreeEditPacketSender.h

@@ -41,12 +41,10 @@ public:
 
     /// are we in sending mode. If we're not in sending mode then all packets and messages will be ignored and
     /// not queued and not sent
-    bool getShouldSend() const { return _shouldSend; }
 
     /// set sending mode. By default we are set to shouldSend=TRUE and packets will be sent. If shouldSend=FALSE, then we'll
     /// switch to not sending mode, and all packets and messages will be ignored, not queued, and not sent. This might be used
     /// in an application like interface when all octree features are disabled.
-    void setShouldSend(bool shouldSend) { _shouldSend = shouldSend; }
 
     /// if you're running in non-threaded mode, you must call this method regularly
     virtual bool process() override;
@@ -76,7 +74,6 @@ public slots:
 protected:
     using EditMessagePair = std::pair<PacketType, QByteArray>;
 
-    bool _shouldSend;
     void queuePacketToNode(const QUuid& nodeID, std::unique_ptr<NLPacket> packet);
     void queuePacketListToNode(const QUuid& nodeUUID, std::unique_ptr<NLPacketList> packetList);
 

libraries/physics/src/EntityMotionState.cpp

@@ -348,7 +348,7 @@ bool EntityMotionState::remoteSimulationOutOfSync(uint32_t simulationStep) {
 
     if (_numInactiveUpdates > 0) {
         const uint8_t MAX_NUM_INACTIVE_UPDATES = 20;
-        if (_numInactiveUpdates > MAX_NUM_INACTIVE_UPDATES) {
+        if (_numInactiveUpdates > MAX_NUM_INACTIVE_UPDATES || isServerlessMode()) {
             // clear local ownership (stop sending updates) and let the server clear itself
             _entity->clearSimulationOwnership();
             return false;
@@ -827,3 +827,9 @@ void EntityMotionState::clearObjectVelocities() const {
     }
     _entity->setAcceleration(glm::vec3(0.0f));
 }
+
+bool EntityMotionState::isServerlessMode() {
+    EntityTreeElementPointer element = _entity->getElement();
+    EntityTreePointer tree = element ? element->getTree() : nullptr;
+    return tree ? tree->isServerlessMode() : false;
+}

libraries/physics/src/EntityMotionState.h

@@ -156,6 +156,8 @@ protected:
     uint8_t _numInactiveUpdates { 1 };
     uint8_t _bidPriority { 0 };
     bool _serverVariablesSet { false };
+
+    bool isServerlessMode();
 };
 
 #endif // hifi_EntityMotionState_h

libraries/physics/src/PhysicalEntitySimulation.cpp

@@ -327,10 +327,18 @@ void PhysicalEntitySimulation::handleChangedMotionStates(const VectorOfMotionSta
 }
 
 void PhysicalEntitySimulation::addOwnershipBid(EntityMotionState* motionState) {
-    motionState->initForBid();
-    motionState->sendBid(_entityPacketSender, _physicsEngine->getNumSubsteps());
-    _bids.push_back(motionState);
-    _nextBidExpiry = glm::min(_nextBidExpiry, motionState->getNextBidExpiry());
+    if (getEntityTree()->isServerlessMode()) {
+        EntityItemPointer entity = motionState->getEntity();
+        auto nodeList = DependencyManager::get<NodeList>();
+        auto sessionID = nodeList->getSessionUUID();
+        entity->setSimulationOwner(SimulationOwner(sessionID, SCRIPT_GRAB_SIMULATION_PRIORITY));
+        _owned.push_back(motionState);
+    } else {
+        motionState->initForBid();
+        motionState->sendBid(_entityPacketSender, _physicsEngine->getNumSubsteps());
+        _bids.push_back(motionState);
+        _nextBidExpiry = glm::min(_nextBidExpiry, motionState->getNextBidExpiry());
+    }
 }
 
 void PhysicalEntitySimulation::addOwnership(EntityMotionState* motionState) {