From fdcd667d3c4f54c8958de1c89c9007adf8130582 Mon Sep 17 00:00:00 2001
From: howard-stearns <howard.stearns@gmail.com>
Date: Mon, 23 May 2016 13:33:42 -0700
Subject: [PATCH 01/14] Fix hand controller pointer after input changes.

---
 interface/resources/controllers/hydra.json    |   8 +-
 interface/resources/controllers/vive.json     |   4 +-
 .../controllers/handControllerPointer.js      | 112 ++++++------------
 3 files changed, 46 insertions(+), 78 deletions(-)

diff --git a/interface/resources/controllers/hydra.json b/interface/resources/controllers/hydra.json
index 42237033af..8233685763 100644
--- a/interface/resources/controllers/hydra.json
+++ b/interface/resources/controllers/hydra.json
@@ -16,8 +16,12 @@
         { "from": "Hydra.L0", "to": "Standard.Back" },
         { "from": "Hydra.R0", "to": "Standard.Start" },
 
-        { "from": [ "Hydra.L1", "Hydra.L2", "Hydra.L3", "Hydra.L4" ], "to": "Standard.LeftPrimaryThumb" },
-        { "from": [ "Hydra.R1", "Hydra.R2", "Hydra.R3", "Hydra.R4" ], "to": "Standard.RightPrimaryThumb" },
+        { "from": [ "Hydra.L1", "Hydra.L2" ], "to": "Standard.LeftPrimaryThumb" },
+        { "from": [ "Hydra.R1", "Hydra.R2" ], "to": "Standard.RightPrimaryThumb" },
+        { "from": [ "Hydra.L3" ], "to": "Standard.L3" },
+        { "from": [ "Hydra.R3" ], "to": "Standard.R3" },
+        { "from": [ "Hydra.R4" ], "to": "Standard.RightSecondaryThumb" },
+        { "from": [ "Hydra.L4" ], "to": "Standard.LeftSecondaryThumb" },
 
         { "from": "Hydra.LeftHand", "to": "Standard.LeftHand" }, 
         { "from": "Hydra.RightHand", "to": "Standard.RightHand" }
diff --git a/interface/resources/controllers/vive.json b/interface/resources/controllers/vive.json
index 4085d71c27..fec93c9132 100644
--- a/interface/resources/controllers/vive.json
+++ b/interface/resources/controllers/vive.json
@@ -17,8 +17,8 @@
         { "from": "Vive.RS", "to": "Standard.RS" },
         { "from": "Vive.RSTouch", "to": "Standard.RSTouch" },
 
-        { "from": "Vive.LeftApplicationMenu", "to": "Standard.Back" },
-        { "from": "Vive.RightApplicationMenu", "to": "Standard.Start" },
+        { "from": "Vive.LeftApplicationMenu", "to": "Standard.LeftSecondaryThumb" },
+        { "from": "Vive.RightApplicationMenu", "to": "Standard.RightSecondaryThumb" },
 
         { "from": "Vive.LeftHand", "to": "Standard.LeftHand" },
         { "from": "Vive.RightHand", "to": "Standard.RightHand" }
diff --git a/scripts/system/controllers/handControllerPointer.js b/scripts/system/controllers/handControllerPointer.js
index f4e4492a88..e7be3af5dd 100644
--- a/scripts/system/controllers/handControllerPointer.js
+++ b/scripts/system/controllers/handControllerPointer.js
@@ -22,10 +22,7 @@
 //   (For now, the thumb buttons on both controllers are always on.)
 // When over a HUD element, the reticle is shown where the active hand controller beam intersects the HUD.
 // Otherwise, the active hand controller shows a red ball where a click will act.
-//
-// Bugs:
-// On Windows, the upper left corner of Interface must be in the upper left corner of the screen, and the title bar must be 50px high. (System bug.)
-// While hardware mouse move switches to mouse move, hardware mouse click (without amove) does not.
+
 
 
 // UTILITIES -------------
@@ -270,75 +267,43 @@ function toggleHand() {
 }
 
 // Create clickMappings as needed, on demand.
-var clickMappings = {}, clickMapping, clickMapToggle;
-var hardware; // undefined
-function checkHardware() {
-    var newHardware = Controller.Hardware.Hydra ? 'Hydra' : (Controller.Hardware.Vive ? 'Vive' : null); // not undefined
-    if (hardware === newHardware) {
-        return;
-    }
-    print('Setting mapping for new controller hardware:', newHardware);
-    if (clickMapToggle) {
-        clickMapToggle.setState(false);
-    }
-    hardware = newHardware;
-    if (clickMappings[hardware]) {
-        clickMapping = clickMappings[hardware];
-    } else {
-        clickMapping = Controller.newMapping(Script.resolvePath('') + '-click-' + hardware);
-        Script.scriptEnding.connect(clickMapping.disable);
-        function mapToAction(button, action) {
-            clickMapping.from(Controller.Hardware[hardware][button]).peek().to(Controller.Actions[action]);
-        }
-        function makeHandToggle(button, hand, optionalWhen) {
-            var whenThunk = optionalWhen || function () {
-                return true;
-            };
-            function maybeToggle() {
-                if (activeHand !== Controller.Standard[hand]) {
-                    toggleHand();
-                }
+var clickMapping = Controller.newMapping(Script.resolvePath('') + '-click');
+Script.scriptEnding.connect(clickMapping.disable);
 
-            }
-            clickMapping.from(Controller.Hardware[hardware][button]).peek().when(whenThunk).to(maybeToggle);
-        }
-        function makeViveWhen(click, x, y) {
-            var viveClick = Controller.Hardware.Vive[click],
-                viveX = Controller.Standard[x],  // Standard after filtering by mapping
-                viveY = Controller.Standard[y];
-            return function () {
-                var clickValue = Controller.getValue(viveClick);
-                var xValue = Controller.getValue(viveX);
-                var yValue = Controller.getValue(viveY);
-                return clickValue && !xValue && !yValue;
-            };
-        }
-        switch (hardware) {
-            case 'Hydra':
-                makeHandToggle('R3', 'RightHand');
-                makeHandToggle('L3', 'LeftHand');
-
-                mapToAction('R3', 'ReticleClick');
-                mapToAction('L3', 'ReticleClick');
-                mapToAction('R4', 'ContextMenu');
-                mapToAction('L4', 'ContextMenu');
-                break;
-            case 'Vive':
-                // When touchpad click is NOT treated as movement, treat as left click
-                makeHandToggle('RS', 'RightHand', makeViveWhen('RS', 'RX', 'RY'));
-                makeHandToggle('LS', 'LeftHand', makeViveWhen('LS', 'LX', 'LY'));
-                clickMapping.from(Controller.Hardware.Vive.RS).when(makeViveWhen('RS', 'RX', 'RY')).to(Controller.Actions.ReticleClick);
-                clickMapping.from(Controller.Hardware.Vive.LS).when(makeViveWhen('LS', 'LX', 'LY')).to(Controller.Actions.ReticleClick);
-                mapToAction('RightApplicationMenu', 'ContextMenu');
-                mapToAction('LeftApplicationMenu', 'ContextMenu');
-                break;
-        }
-        clickMappings[hardware] = clickMapping;
-    }
-    clickMapToggle = new LatchedToggle(clickMapping.enable, clickMapping.disable);
-    clickMapToggle.setState(true);
+// Move these to vive.json
+function makeCenterClickWhen(click, x, y) {
+    var clickKey = Controller.Standard[click],
+        xKey = Controller.Standard[x],  // Standard after filtering by mapping
+        yKey = Controller.Standard[y];
+    return function () {
+        var clickValue = Controller.getValue(clickKey);
+        var xValue = Controller.getValue(xKey);
+        var yValue = Controller.getValue(yKey);
+        var answer = clickValue && !xValue && !yValue;
+        return answer;
+    };
 }
-checkHardware();
+if (Controller.Hardware.Vive) {
+    clickMapping.from(Controller.Hardware.Vive.RS).when(makeCenterClickWhen('RS', 'RX', 'RY')).to(Controller.Standard.R3);
+    clickMapping.from(Controller.Hardware.Vive.LS).when(makeCenterClickWhen('LS', 'LX', 'LY')).to(Controller.Standard.L3);
+}
+
+
+clickMapping.from(Controller.Standard.R3).peek().to(Controller.Actions.ReticleClick);
+clickMapping.from(Controller.Standard.L3).peek().to(Controller.Actions.ReticleClick);
+clickMapping.from(Controller.Standard.RightSecondaryThumb).peek().to(Controller.Actions.ContextMenu);
+clickMapping.from(Controller.Standard.LeftSecondaryThumb).peek().to(Controller.Actions.ContextMenu);
+clickMapping.from(Controller.Standard.R3).peek().to(function (on) {
+    if (on && (activeHand !== Controller.Standard.RightHand)) {
+        toggleHand();
+    }
+});
+clickMapping.from(Controller.Standard.L3).peek().to(function (on) {
+    if (on && (activeHand !== Controller.Standard.LeftHand)) {
+        toggleHand();
+    }
+});
+clickMapping.enable();
 
 // VISUAL AID -----------
 // Same properties as handControllerGrab search sphere
@@ -415,8 +380,8 @@ function update() {
         return turnOffVisualization();
     }
     var controllerPose = Controller.getPoseValue(activeHand);
-    // Vive is effectively invalid when not in HMD
-    if (!controllerPose.valid || ((hardware === 'Vive') && !HMD.active)) {
+    // Valid if any plugged-in hand controller is "on". (uncradled Hydra, green-lighted Vive...)
+    if (!controllerPose.valid) {
         return turnOffVisualization();
     } // Controller is cradled.
     var controllerPosition = Vec3.sum(Vec3.multiplyQbyV(MyAvatar.orientation, controllerPose.translation),
@@ -458,7 +423,6 @@ Script.scriptEnding.connect(function () {
 var SETTINGS_CHANGE_RECHECK_INTERVAL = 10 * 1000; // milliseconds
 function checkSettings() {
     updateFieldOfView();
-    checkHardware();
 }
 checkSettings();
 var settingsChecker = Script.setInterval(checkSettings, SETTINGS_CHANGE_RECHECK_INTERVAL);

From 1d9981e6242d7fda4e9e6db824948b5f6ad45a2a Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 13:31:19 -0700
Subject: [PATCH 02/14] first cut at support for verifying all protocol version
 compatibility

---
 domain-server/src/DomainGatekeeper.cpp        | 42 +++++++++++++----
 domain-server/src/DomainGatekeeper.h          |  5 +-
 domain-server/src/DomainServer.cpp            | 39 +++++++++++++++
 domain-server/src/DomainServer.h              |  2 +
 domain-server/src/NodeConnectionData.cpp      |  9 ++++
 domain-server/src/NodeConnectionData.h        |  2 +
 interface/src/Application.cpp                 | 23 ++++++++-
 interface/src/Application.h                   |  8 ++++
 interface/src/Menu.cpp                        |  7 +++
 interface/src/Menu.h                          |  1 +
 .../src/scripting/WindowScriptingInterface.h  |  4 +-
 libraries/networking/src/DomainHandler.cpp    | 47 +++++++++++++------
 libraries/networking/src/DomainHandler.h      | 12 ++++-
 libraries/networking/src/LimitedNodeList.cpp  |  4 ++
 libraries/networking/src/LimitedNodeList.h    |  6 ++-
 libraries/networking/src/NLPacket.cpp         |  9 ++--
 libraries/networking/src/NLPacket.h           |  4 +-
 libraries/networking/src/NodeList.cpp         | 32 +++++++++++--
 libraries/networking/src/NodeList.h           | 15 ++++++
 libraries/networking/src/PacketReceiver.cpp   | 13 ++++-
 .../networking/src/udt/PacketHeaders.cpp      | 43 ++++++++++++++++-
 libraries/networking/src/udt/PacketHeaders.h  | 21 ++++++++-
 22 files changed, 304 insertions(+), 44 deletions(-)

diff --git a/domain-server/src/DomainGatekeeper.cpp b/domain-server/src/DomainGatekeeper.cpp
index 61cc775e08..9d5ee75818 100644
--- a/domain-server/src/DomainGatekeeper.cpp
+++ b/domain-server/src/DomainGatekeeper.cpp
@@ -56,10 +56,24 @@ void DomainGatekeeper::processConnectRequestPacket(QSharedPointer<ReceivedMessag
         return;
     }
 
+    //qDebug() << __FUNCTION__ << "packetVersion:" << message->getVersion();
+
+
     QDataStream packetStream(message->getMessage());
 
     // read a NodeConnectionData object from the packet so we can pass around this data while we're inspecting it
     NodeConnectionData nodeConnection = NodeConnectionData::fromDataStream(packetStream, message->getSenderSockAddr());
+
+    QByteArray myProtocolVersion = protocolVersionsSignature();
+    if (nodeConnection.protocolVersion != myProtocolVersion) {
+        QString protocolVersionError = "Protocol version mismatch - Domain version:" + QCoreApplication::applicationVersion();
+        qDebug() << "Protocol Version mismatch - denying connection.";
+        sendConnectionDeniedPacket(protocolVersionError, message->getSenderSockAddr(), 
+                DomainHandler::ConnectionRefusedReason::ProtocolMismatch);
+        return;
+    }
+    //qDebug() << __FUNCTION__ << "Protocol Version MATCH - continue with processing connection.";
+
     
     if (nodeConnection.localSockAddr.isNull() || nodeConnection.publicSockAddr.isNull()) {
         qDebug() << "Unexpected data received for node local socket or public socket. Will not allow connection.";
@@ -97,7 +111,9 @@ void DomainGatekeeper::processConnectRequestPacket(QSharedPointer<ReceivedMessag
             }
         }
         
+        //qDebug() << __FUNCTION__ << " about to processAgentConnectRequest() ---------------------";
         node = processAgentConnectRequest(nodeConnection, username, usernameSignature);
+        //qDebug() << __FUNCTION__ << " AFTER processAgentConnectRequest() node: " << node << " ---------------------";
     }
     
     if (node) {
@@ -109,6 +125,9 @@ void DomainGatekeeper::processConnectRequestPacket(QSharedPointer<ReceivedMessag
         
         // signal that we just connected a node so the DomainServer can get it a list
         // and broadcast its presence right away
+
+        //qDebug() << __FUNCTION__ << " about to connectedNode(node) ---------------------";
+
         emit connectedNode(node);
     } else {
         qDebug() << "Refusing connection from node at" << message->getSenderSockAddr();
@@ -332,7 +351,7 @@ SharedNodePointer DomainGatekeeper::addVerifiedNodeFromConnectRequest(const Node
 bool DomainGatekeeper::verifyUserSignature(const QString& username,
                                            const QByteArray& usernameSignature,
                                            const HifiSockAddr& senderSockAddr) {
-    
+
     // it's possible this user can be allowed to connect, but we need to check their username signature
     QByteArray publicKeyArray = _userPublicKeys.value(username);
     
@@ -370,7 +389,8 @@ bool DomainGatekeeper::verifyUserSignature(const QString& username,
             } else {
                 if (!senderSockAddr.isNull()) {
                     qDebug() << "Error decrypting username signature for " << username << "- denying connection.";
-                    sendConnectionDeniedPacket("Error decrypting username signature.", senderSockAddr);
+                    sendConnectionDeniedPacket("Error decrypting username signature.", senderSockAddr,
+                        DomainHandler::ConnectionRefusedReason::LoginError);
                 }
                 
                 // free up the public key, we don't need it anymore
@@ -382,13 +402,15 @@ bool DomainGatekeeper::verifyUserSignature(const QString& username,
             // we can't let this user in since we couldn't convert their public key to an RSA key we could use
             if (!senderSockAddr.isNull()) {
                 qDebug() << "Couldn't convert data to RSA key for" << username << "- denying connection.";
-                sendConnectionDeniedPacket("Couldn't convert data to RSA key.", senderSockAddr);
+                sendConnectionDeniedPacket("Couldn't convert data to RSA key.", senderSockAddr,
+                    DomainHandler::ConnectionRefusedReason::LoginError);
             }
         }
     } else {
         if (!senderSockAddr.isNull()) {
             qDebug() << "Insufficient data to decrypt username signature - denying connection.";
-            sendConnectionDeniedPacket("Insufficient data", senderSockAddr);
+            sendConnectionDeniedPacket("Insufficient data", senderSockAddr,
+                DomainHandler::ConnectionRefusedReason::LoginError);
         }
     }
     
@@ -402,7 +424,8 @@ bool DomainGatekeeper::isVerifiedAllowedUser(const QString& username, const QByt
     if (username.isEmpty()) {
         qDebug() << "Connect request denied - no username provided.";
         
-        sendConnectionDeniedPacket("No username provided", senderSockAddr);
+        sendConnectionDeniedPacket("No username provided", senderSockAddr,
+            DomainHandler::ConnectionRefusedReason::LoginError);
         
         return false;
     }
@@ -416,7 +439,8 @@ bool DomainGatekeeper::isVerifiedAllowedUser(const QString& username, const QByt
         }
     } else {
         qDebug() << "Connect request denied for user" << username << "- not in allowed users list.";
-        sendConnectionDeniedPacket("User not on whitelist.", senderSockAddr);
+        sendConnectionDeniedPacket("User not on whitelist.", senderSockAddr,
+            DomainHandler::ConnectionRefusedReason::NotAuthorized);
         
         return false;
     }
@@ -452,7 +476,8 @@ bool DomainGatekeeper::isWithinMaxCapacity(const QString& username, const QByteA
             
             // deny connection from this user
             qDebug() << connectedUsers << "/" << maximumUserCapacity << "users connected, denying new connection.";
-            sendConnectionDeniedPacket("Too many connected users.", senderSockAddr);
+            sendConnectionDeniedPacket("Too many connected users.", senderSockAddr,
+                DomainHandler::ConnectionRefusedReason::TooManyUsers);
             
             return false;
         }
@@ -516,7 +541,8 @@ void DomainGatekeeper::publicKeyJSONCallback(QNetworkReply& requestReply) {
     }
 }
 
-void DomainGatekeeper::sendConnectionDeniedPacket(const QString& reason, const HifiSockAddr& senderSockAddr) {
+void DomainGatekeeper::sendConnectionDeniedPacket(const QString& reason, const HifiSockAddr& senderSockAddr, 
+            DomainHandler::ConnectionRefusedReason reasonCode) {
     // this is an agent and we've decided we won't let them connect - send them a packet to deny connection
     QByteArray utfString = reason.toUtf8();
     quint16 payloadSize = utfString.size();
diff --git a/domain-server/src/DomainGatekeeper.h b/domain-server/src/DomainGatekeeper.h
index c4ac32fabf..09e3b04ed7 100644
--- a/domain-server/src/DomainGatekeeper.h
+++ b/domain-server/src/DomainGatekeeper.h
@@ -19,6 +19,8 @@
 #include <QtCore/QObject>
 #include <QtNetwork/QNetworkReply>
 
+#include <DomainHandler.h>
+
 #include <NLPacket.h>
 #include <Node.h>
 #include <UUIDHasher.h>
@@ -74,7 +76,8 @@ private:
                                        const HifiSockAddr& senderSockAddr);
     
     void sendConnectionTokenPacket(const QString& username, const HifiSockAddr& senderSockAddr);
-    void sendConnectionDeniedPacket(const QString& reason, const HifiSockAddr& senderSockAddr);
+    void sendConnectionDeniedPacket(const QString& reason, const HifiSockAddr& senderSockAddr, 
+                    DomainHandler::ConnectionRefusedReason reasonCode = DomainHandler::ConnectionRefusedReason::Unknown);
     
     void pingPunchForConnectingPeer(const SharedNetworkPeer& peer);
     
diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index cfec72a24b..18ca7e2941 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -303,6 +303,36 @@ const QString FULL_AUTOMATIC_NETWORKING_VALUE = "full";
 const QString IP_ONLY_AUTOMATIC_NETWORKING_VALUE = "ip";
 const QString DISABLED_AUTOMATIC_NETWORKING_VALUE = "disabled";
 
+
+
+bool DomainServer::packetVersionMatch(const udt::Packet& packet) {
+    PacketType headerType = NLPacket::typeInHeader(packet);
+    PacketVersion headerVersion = NLPacket::versionInHeader(packet);
+
+    //qDebug() << __FUNCTION__ << "type:" << headerType << "version:" << (int)headerVersion;
+
+    auto nodeList = DependencyManager::get<LimitedNodeList>();
+
+    // This implements a special case that handles OLD clients which don't know how to negotiate matching
+    // protocol versions. We know these clients will sent DomainConnectRequest with older versions. We also
+    // know these clients will show a warning dialog if they get an EntityData with a protocol version they
+    // don't understand, so we can send them an empty EntityData with our latest version and they will
+    // warn the user that the protocol is not compatible
+    if (headerType == PacketType::DomainConnectRequest &&
+        headerVersion < static_cast<PacketVersion>(DomainConnectRequestVersion::HasProtocolVersions)) {
+
+        //qDebug() << __FUNCTION__ << "OLD VERSION checkin sending an intentional bad packet -------------------------------";
+
+        auto packetWithBadVersion = NLPacket::create(PacketType::EntityData);
+        nodeList->sendPacket(std::move(packetWithBadVersion), packet.getSenderSockAddr());
+        return false;
+    }
+
+    // let the normal nodeList implementation handle all other packets.
+    return nodeList->isPacketVerified(packet);
+}
+
+
 void DomainServer::setupNodeListAndAssignments(const QUuid& sessionUUID) {
 
     const QString CUSTOM_LOCAL_PORT_OPTION = "metaverse.local_port";
@@ -376,6 +406,10 @@ void DomainServer::setupNodeListAndAssignments(const QUuid& sessionUUID) {
     
     // add whatever static assignments that have been parsed to the queue
     addStaticAssignmentsToQueue();
+
+    // set packetVersionMatch as the verify packet operator for the udt::Socket
+    //using std::placeholders::_1;
+    nodeList->setPacketFilterOperator(&DomainServer::packetVersionMatch);
 }
 
 const QString ACCESS_TOKEN_KEY_PATH = "metaverse.access_token";
@@ -666,6 +700,8 @@ void DomainServer::populateDefaultStaticAssignmentsExcludingTypes(const QSet<Ass
 }
 
 void DomainServer::processListRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
+
+    //qDebug() << __FUNCTION__ << "---------------";
     
     QDataStream packetStream(message->getMessage());
     NodeConnectionData nodeRequestData = NodeConnectionData::fromDataStream(packetStream, message->getSenderSockAddr(), false);
@@ -746,6 +782,9 @@ void DomainServer::handleConnectedNode(SharedNodePointer newNode) {
 }
 
 void DomainServer::sendDomainListToNode(const SharedNodePointer& node, const HifiSockAddr &senderSockAddr) {
+
+    //qDebug() << __FUNCTION__ << "---------------";
+
     const int NUM_DOMAIN_LIST_EXTENDED_HEADER_BYTES = NUM_BYTES_RFC4122_UUID + NUM_BYTES_RFC4122_UUID + 2;
     
     // setup the extended header for the domain list packets
diff --git a/domain-server/src/DomainServer.h b/domain-server/src/DomainServer.h
index fef3221b7d..c39e405380 100644
--- a/domain-server/src/DomainServer.h
+++ b/domain-server/src/DomainServer.h
@@ -99,6 +99,8 @@ private:
 
     void optionallyGetTemporaryName(const QStringList& arguments);
 
+    static bool packetVersionMatch(const udt::Packet& packet);
+
     bool resetAccountManagerAccessToken();
 
     void setupAutomaticNetworking();
diff --git a/domain-server/src/NodeConnectionData.cpp b/domain-server/src/NodeConnectionData.cpp
index 28f769298c..5ddcbf1792 100644
--- a/domain-server/src/NodeConnectionData.cpp
+++ b/domain-server/src/NodeConnectionData.cpp
@@ -19,6 +19,15 @@ NodeConnectionData NodeConnectionData::fromDataStream(QDataStream& dataStream, c
     
     if (isConnectRequest) {
         dataStream >> newHeader.connectUUID;
+
+        // Read out the protocol version signature from the connect message
+        char* rawBytes;
+        uint length;
+
+        // FIXME -- do we need to delete the rawBytes after it's been copied into the QByteArray?
+        dataStream.readBytes(rawBytes, length);
+        newHeader.protocolVersion = QByteArray(rawBytes, length);
+        //qDebug() << __FUNCTION__ << "...got protocol version from node... version:" << newHeader.protocolVersion;
     }
     
     dataStream >> newHeader.nodeType
diff --git a/domain-server/src/NodeConnectionData.h b/domain-server/src/NodeConnectionData.h
index 34119ffdab..9264db637e 100644
--- a/domain-server/src/NodeConnectionData.h
+++ b/domain-server/src/NodeConnectionData.h
@@ -28,6 +28,8 @@ public:
     HifiSockAddr senderSockAddr;
     QList<NodeType_t> interestList;
     QString placeName;
+
+    QByteArray protocolVersion;
 };
 
 
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index b0e4880011..821cd83c31 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -631,6 +631,8 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     connect(&domainHandler, SIGNAL(connectedToDomain(const QString&)), SLOT(updateWindowTitle()));
     connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(updateWindowTitle()));
     connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(clearDomainOctreeDetails()));
+    
+    connect(&domainHandler, &DomainHandler::resetting, nodeList.data(), &NodeList::resetDomainServerCheckInVersion);
 
     // update our location every 5 seconds in the metaverse server, assuming that we are authenticated with one
     const qint64 DATA_SERVER_LOCATION_CHANGE_UPDATE_MSECS = 5 * MSECS_PER_SEC;
@@ -653,7 +655,11 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     connect(nodeList.data(), &NodeList::nodeActivated, this, &Application::nodeActivated);
     connect(nodeList.data(), &NodeList::uuidChanged, getMyAvatar(), &MyAvatar::setSessionUUID);
     connect(nodeList.data(), &NodeList::uuidChanged, this, &Application::setSessionUUID);
-    connect(nodeList.data(), &NodeList::limitOfSilentDomainCheckInsReached, nodeList.data(), &NodeList::reset);
+
+    connect(nodeList.data(), &NodeList::limitOfSilentDomainCheckInsReached, this, &Application::limitOfSilentDomainCheckInsReached);
+    //connect(nodeList.data(), &NodeList::limitOfSilentDomainCheckInsReached, nodeList.data(), &NodeList::reset);
+
+
     connect(nodeList.data(), &NodeList::packetVersionMismatch, this, &Application::notifyPacketVersionMismatch);
 
     // connect to appropriate slots on AccountManager
@@ -4569,6 +4575,21 @@ void Application::setSessionUUID(const QUuid& sessionUUID) const {
     Physics::setSessionUUID(sessionUUID);
 }
 
+
+// If we're not getting anything back from the domain server checkin, it might be that the domain speaks an 
+// older version of the DomainConnectRequest protocal. We will attempt to send and older version of DomainConnectRequest.
+// We won't actually complete the connection, but if the server responds, we know that it needs to be upgraded (or we
+// need to be downgraded to talk to it).
+void Application::limitOfSilentDomainCheckInsReached() {
+    //qDebug() << __FUNCTION__;
+
+    auto nodeList = DependencyManager::get<NodeList>();
+
+    nodeList->downgradeDomainServerCheckInVersion(); // attempt to use an older domain checkin version
+
+    nodeList->reset();
+}
+
 bool Application::askToSetAvatarUrl(const QString& url) {
     QUrl realUrl(url);
     if (realUrl.isLocalFile()) {
diff --git a/interface/src/Application.h b/interface/src/Application.h
index 28dbcead47..edd1b6187d 100644
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@@ -261,6 +261,12 @@ public slots:
     void resetSensors(bool andReload = false);
     void setActiveFaceTracker() const;
 
+#if (PR_BUILD || DEV_BUILD)
+    void sendWrongProtocolVersionsSignature(bool checked) {
+        ::sendWrongProtocolVersionsSignature(checked);
+    }
+#endif
+
 #ifdef HAVE_IVIEWHMD
     void setActiveEyeTracker();
     void calibrateEyeTracker1Point();
@@ -314,6 +320,8 @@ private slots:
     bool displayAvatarAttachmentConfirmationDialog(const QString& name) const;
 
     void setSessionUUID(const QUuid& sessionUUID) const;
+    void limitOfSilentDomainCheckInsReached();
+
     void domainChanged(const QString& domainHostname);
     void updateWindowTitle() const;
     void nodeAdded(SharedNodePointer node) const;
diff --git a/interface/src/Menu.cpp b/interface/src/Menu.cpp
index 538410a47d..a21aa71753 100644
--- a/interface/src/Menu.cpp
+++ b/interface/src/Menu.cpp
@@ -545,6 +545,13 @@ Menu::Menu() {
     addActionToQMenuAndActionHash(networkMenu, MenuOption::BandwidthDetails, 0,
         dialogsManager.data(), SLOT(bandwidthDetails()));
 
+    #if (PR_BUILD || DEV_BUILD)
+    addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::SendWrongProtocolVersion, 0, false,
+                qApp, SLOT(sendWrongProtocolVersionsSignature(bool)));
+    #endif
+
+    
+
 
     // Developer > Timing >>>
     MenuWrapper* timingMenu = developerMenu->addMenu("Timing");
diff --git a/interface/src/Menu.h b/interface/src/Menu.h
index 36d285e2cf..fcaf8e6caa 100644
--- a/interface/src/Menu.h
+++ b/interface/src/Menu.h
@@ -167,6 +167,7 @@ namespace MenuOption {
     const QString RunTimingTests = "Run Timing Tests";
     const QString ScriptEditor = "Script Editor...";
     const QString ScriptedMotorControl = "Enable Scripted Motor Control";
+    const QString SendWrongProtocolVersion = "Send wrong protocol version";
     const QString SetHomeLocation = "Set Home Location";
     const QString ShowDSConnectTable = "Show Domain Connection Timing";
     const QString ShowBordersEntityNodes = "Show Entity Nodes";
diff --git a/interface/src/scripting/WindowScriptingInterface.h b/interface/src/scripting/WindowScriptingInterface.h
index 0f51a484c4..145d17faaf 100644
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@@ -16,6 +16,8 @@
 #include <QtCore/QString>
 #include <QtScript/QScriptValue>
 
+#include <DomainHandler.h>
+
 class WebWindowClass;
 
 class WindowScriptingInterface : public QObject, public Dependency {
@@ -45,7 +47,7 @@ public slots:
 signals:
     void domainChanged(const QString& domainHostname);
     void svoImportRequested(const QString& url);
-    void domainConnectionRefused(const QString& reason);
+    void domainConnectionRefused(const QString& reasonMessage, DomainHandler::ConnectionRefusedReason reason = DomainHandler::ConnectionRefusedReason::Unknown);
 
 private slots:
     WebWindowClass* doCreateWebWindow(const QString& title, const QString& url, int width, int height);
diff --git a/libraries/networking/src/DomainHandler.cpp b/libraries/networking/src/DomainHandler.cpp
index 44ce63e6c6..08810010a6 100644
--- a/libraries/networking/src/DomainHandler.cpp
+++ b/libraries/networking/src/DomainHandler.cpp
@@ -355,34 +355,53 @@ void DomainHandler::processICEResponsePacket(QSharedPointer<ReceivedMessage> mes
     }
 }
 
+bool DomainHandler::reasonSuggestsLogin(ConnectionRefusedReason reasonCode) {
+    switch (reasonCode) {
+        case ConnectionRefusedReason::LoginError:
+        case ConnectionRefusedReason::NotAuthorized:
+            return true;
+    
+        default:
+        case ConnectionRefusedReason::Unknown:
+        case ConnectionRefusedReason::ProtocolMismatch:
+        case ConnectionRefusedReason::TooManyUsers:
+            return false;
+    }
+    return false;
+}
+
 void DomainHandler::processDomainServerConnectionDeniedPacket(QSharedPointer<ReceivedMessage> message) {
     // Read deny reason from packet
+    ConnectionRefusedReason reasonCode = DomainHandler::ConnectionRefusedReason::Unknown;
     quint16 reasonSize;
     message->readPrimitive(&reasonSize);
-    QString reason = QString::fromUtf8(message->readWithoutCopy(reasonSize));
+    QString reasonMessage = QString::fromUtf8(message->readWithoutCopy(reasonSize));
 
     // output to the log so the user knows they got a denied connection request
     // and check and signal for an access token so that we can make sure they are logged in
-    qCWarning(networking) << "The domain-server denied a connection request: " << reason;
+    qCWarning(networking) << "The domain-server denied a connection request: " << reasonMessage;
     qCWarning(networking) << "Make sure you are logged in.";
 
-    if (!_domainConnectionRefusals.contains(reason)) {
-        _domainConnectionRefusals.append(reason);
-        emit domainConnectionRefused(reason);
+    if (!_domainConnectionRefusals.contains(reasonMessage)) {
+        _domainConnectionRefusals.append(reasonMessage);
+        emit domainConnectionRefused(reasonMessage, reasonCode);
     }
 
     auto accountManager = DependencyManager::get<AccountManager>();
 
-    if (!_hasCheckedForAccessToken) {
-        accountManager->checkAndSignalForAccessToken();
-        _hasCheckedForAccessToken = true;
-    }
+    // Some connection refusal reasons imply that a login is required. If so, suggest a new login
+    if (reasonSuggestsLogin(reasonCode)) {
+        if (!_hasCheckedForAccessToken) {
+            accountManager->checkAndSignalForAccessToken();
+            _hasCheckedForAccessToken = true;
+        }
 
-    static const int CONNECTION_DENIALS_FOR_KEYPAIR_REGEN = 3;
+        static const int CONNECTION_DENIALS_FOR_KEYPAIR_REGEN = 3;
 
-    // force a re-generation of key-pair after CONNECTION_DENIALS_FOR_KEYPAIR_REGEN failed connection attempts
-    if (++_connectionDenialsSinceKeypairRegen >= CONNECTION_DENIALS_FOR_KEYPAIR_REGEN) {
-        accountManager->generateNewUserKeypair();
-        _connectionDenialsSinceKeypairRegen = 0;
+        // force a re-generation of key-pair after CONNECTION_DENIALS_FOR_KEYPAIR_REGEN failed connection attempts
+        if (++_connectionDenialsSinceKeypairRegen >= CONNECTION_DENIALS_FOR_KEYPAIR_REGEN) {
+            accountManager->generateNewUserKeypair();
+            _connectionDenialsSinceKeypairRegen = 0;
+        }
     }
 }
diff --git a/libraries/networking/src/DomainHandler.h b/libraries/networking/src/DomainHandler.h
index 03141d8fef..4d8505e549 100644
--- a/libraries/networking/src/DomainHandler.h
+++ b/libraries/networking/src/DomainHandler.h
@@ -84,6 +84,15 @@ public:
     bool isSocketKnown() const { return !_sockAddr.getAddress().isNull(); }
 
     void softReset();
+
+    enum class ConnectionRefusedReason : uint8_t {
+        Unknown,
+        ProtocolMismatch,
+        LoginError,
+        NotAuthorized,
+        TooManyUsers
+    };
+
 public slots:
     void setHostnameAndPort(const QString& hostname, quint16 port = DEFAULT_DOMAIN_SERVER_PORT);
     void setIceServerHostnameAndID(const QString& iceServerHostname, const QUuid& id);
@@ -115,9 +124,10 @@ signals:
     void settingsReceived(const QJsonObject& domainSettingsObject);
     void settingsReceiveFail();
 
-    void domainConnectionRefused(QString reason);
+    void domainConnectionRefused(QString reasonMessage, ConnectionRefusedReason reason = ConnectionRefusedReason::Unknown);
 
 private:
+    bool reasonSuggestsLogin(ConnectionRefusedReason reasonCode);
     void sendDisconnectPacket();
     void hardReset();
 
diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp
index 2c10d0627e..714b69fd89 100644
--- a/libraries/networking/src/LimitedNodeList.cpp
+++ b/libraries/networking/src/LimitedNodeList.cpp
@@ -162,13 +162,17 @@ QUdpSocket& LimitedNodeList::getDTLSSocket() {
 }
 
 bool LimitedNodeList::isPacketVerified(const udt::Packet& packet) {
+    //qDebug() << __FUNCTION__;
     return packetVersionMatch(packet) && packetSourceAndHashMatch(packet);
 }
 
 bool LimitedNodeList::packetVersionMatch(const udt::Packet& packet) {
+
     PacketType headerType = NLPacket::typeInHeader(packet);
     PacketVersion headerVersion = NLPacket::versionInHeader(packet);
 
+    //qDebug() << __FUNCTION__ << "headerType:" << headerType << "version:" << (int)headerVersion;
+
     if (headerVersion != versionForPacketType(headerType)) {
 
         static QMultiHash<QUuid, PacketType> sourcedVersionDebugSuppressMap;
diff --git a/libraries/networking/src/LimitedNodeList.h b/libraries/networking/src/LimitedNodeList.h
index 0cbe9668b3..3b648a138b 100644
--- a/libraries/networking/src/LimitedNodeList.h
+++ b/libraries/networking/src/LimitedNodeList.h
@@ -221,6 +221,10 @@ public:
 
     void setConnectionMaxBandwidth(int maxBandwidth) { _nodeSocket.setConnectionMaxBandwidth(maxBandwidth); }
 
+    void setPacketFilterOperator(udt::PacketFilterOperator filterOperator) { _nodeSocket.setPacketFilterOperator(filterOperator); }
+    bool packetVersionMatch(const udt::Packet& packet);
+    bool isPacketVerified(const udt::Packet& packet);
+
 public slots:
     void reset();
     void eraseAllNodes();
@@ -267,8 +271,6 @@ protected:
 
     void setLocalSocket(const HifiSockAddr& sockAddr);
     
-    bool isPacketVerified(const udt::Packet& packet);
-    bool packetVersionMatch(const udt::Packet& packet);
     bool packetSourceAndHashMatch(const udt::Packet& packet);
     void processSTUNResponse(std::unique_ptr<udt::BasePacket> packet);
 
diff --git a/libraries/networking/src/NLPacket.cpp b/libraries/networking/src/NLPacket.cpp
index 575a2c7a9c..93f8659663 100644
--- a/libraries/networking/src/NLPacket.cpp
+++ b/libraries/networking/src/NLPacket.cpp
@@ -24,8 +24,8 @@ int NLPacket::maxPayloadSize(PacketType type, bool isPartOfMessage) {
     return Packet::maxPayloadSize(isPartOfMessage) - NLPacket::localHeaderSize(type);
 }
 
-std::unique_ptr<NLPacket> NLPacket::create(PacketType type, qint64 size, bool isReliable, bool isPartOfMessage) {
-    auto packet = std::unique_ptr<NLPacket>(new NLPacket(type, size, isReliable, isPartOfMessage));
+std::unique_ptr<NLPacket> NLPacket::create(PacketType type, qint64 size, bool isReliable, bool isPartOfMessage, PacketVersion version) {
+    auto packet = std::unique_ptr<NLPacket>(new NLPacket(type, size, isReliable, isPartOfMessage, version));
         
     packet->open(QIODevice::ReadWrite);
     
@@ -61,13 +61,12 @@ std::unique_ptr<NLPacket> NLPacket::createCopy(const NLPacket& other) {
     return std::unique_ptr<NLPacket>(new NLPacket(other));
 }
 
-NLPacket::NLPacket(PacketType type, qint64 size, bool isReliable, bool isPartOfMessage) :
+NLPacket::NLPacket(PacketType type, qint64 size, bool isReliable, bool isPartOfMessage, PacketVersion version) :
     Packet((size == -1) ? -1 : NLPacket::localHeaderSize(type) + size, isReliable, isPartOfMessage),
     _type(type),
-    _version(versionForPacketType(type))
+    _version((version == 0) ? versionForPacketType(type) : version)
 {
     adjustPayloadStartAndCapacity(NLPacket::localHeaderSize(_type));
-    
     writeTypeAndVersion();
 }
 
diff --git a/libraries/networking/src/NLPacket.h b/libraries/networking/src/NLPacket.h
index 4527094322..f49f8498a5 100644
--- a/libraries/networking/src/NLPacket.h
+++ b/libraries/networking/src/NLPacket.h
@@ -38,7 +38,7 @@ public:
         sizeof(PacketType) + sizeof(PacketVersion) + NUM_BYTES_RFC4122_UUID + NUM_BYTES_MD5_HASH;
     
     static std::unique_ptr<NLPacket> create(PacketType type, qint64 size = -1,
-                                            bool isReliable = false, bool isPartOfMessage = false);
+                    bool isReliable = false, bool isPartOfMessage = false, PacketVersion version = 0);
     
     static std::unique_ptr<NLPacket> fromReceivedPacket(std::unique_ptr<char[]> data, qint64 size,
                                                         const HifiSockAddr& senderSockAddr);
@@ -73,7 +73,7 @@ public:
 
 protected:
     
-    NLPacket(PacketType type, qint64 size = -1, bool forceReliable = false, bool isPartOfMessage = false);
+    NLPacket(PacketType type, qint64 size = -1, bool forceReliable = false, bool isPartOfMessage = false, PacketVersion version = 0);
     NLPacket(std::unique_ptr<char[]> data, qint64 size, const HifiSockAddr& senderSockAddr);
     
     NLPacket(const NLPacket& other);
diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp
index c295ffc700..50677908a5 100644
--- a/libraries/networking/src/NodeList.cpp
+++ b/libraries/networking/src/NodeList.cpp
@@ -292,7 +292,9 @@ void NodeList::sendDomainServerCheckIn() {
             return;
         }
 
-        auto domainPacket = NLPacket::create(domainPacketType);
+        auto packetVersion = (domainPacketType == PacketType::DomainConnectRequest) ? _domainConnectRequestVersion : 0;
+        //qDebug() << __FUNCTION__ << " NLPacket::create() version:" << (int)packetVersion;
+        auto domainPacket = NLPacket::create(domainPacketType, -1, false, false, packetVersion);
         
         QDataStream packetStream(domainPacket.get());
 
@@ -312,12 +314,28 @@ void NodeList::sendDomainServerCheckIn() {
 
             // pack the connect UUID for this connect request
             packetStream << connectUUID;
+
+            // include the protocol version signature in our connect request
+            if (_domainConnectRequestVersion >= static_cast<PacketVersion>(DomainConnectRequestVersion::HasProtocolVersions)) {
+                QByteArray protocolVersionSig = protocolVersionsSignature();
+                packetStream.writeBytes(protocolVersionSig.constData(), protocolVersionSig.size());
+                //qDebug() << __FUNCTION__ << " including protocol version --------------------------";
+            } else {
+                //qDebug() << __FUNCTION__ << "_domainConnectRequestVersion less than HasProtocolVersions - not including protocol version";
+            }
+        } else {
+            //qDebug() << __FUNCTION__ << "NOT a DomainConnnectRequest ----------- not including checkin details -------";
         }
 
         // pack our data to send to the domain-server including
         // the hostname information (so the domain-server can see which place name we came in on)
-        packetStream << _ownerType << _publicSockAddr << _localSockAddr << _nodeTypesOfInterest.toList()
-            << DependencyManager::get<AddressManager>()->getPlaceName();
+        packetStream << _ownerType << _publicSockAddr << _localSockAddr << _nodeTypesOfInterest.toList();
+        if (_domainConnectRequestVersion >= static_cast<PacketVersion>(DomainConnectRequestVersion::HasHostname)) {
+            packetStream << DependencyManager::get<AddressManager>()->getPlaceName();
+            //qDebug() << __FUNCTION__ << " including host name --------------------------";
+        } else {
+            //qDebug() << __FUNCTION__ << "_domainConnectRequestVersion less than HasHostname - not including host name";
+        }
 
         if (!_domainHandler.isConnected()) {
             DataServerAccountInfo& accountInfo = accountManager->getAccountInfo();
@@ -345,6 +363,7 @@ void NodeList::sendDomainServerCheckIn() {
 
         // increment the count of un-replied check-ins
         _numNoReplyDomainCheckIns++;
+        //qDebug() << __FUNCTION__ << " _numNoReplyDomainCheckIns:" << _numNoReplyDomainCheckIns << " --------------------------";
     }
 }
 
@@ -504,15 +523,22 @@ void NodeList::processDomainServerConnectionTokenPacket(QSharedPointer<ReceivedM
 }
 
 void NodeList::processDomainServerList(QSharedPointer<ReceivedMessage> message) {
+    //qDebug() << __FUNCTION__;
+
     if (_domainHandler.getSockAddr().isNull()) {
         // refuse to process this packet if we aren't currently connected to the DS
         return;
     }
 
+    //qDebug() << __FUNCTION__ << "_numNoReplyDomainCheckIns:" << _numNoReplyDomainCheckIns;
+
     // this is a packet from the domain server, reset the count of un-replied check-ins
     _numNoReplyDomainCheckIns = 0;
 
+    //qDebug() << __FUNCTION__ << "RESET.... _numNoReplyDomainCheckIns:" << _numNoReplyDomainCheckIns;
+
     // emit our signal so listeners know we just heard from the DS
+    //qDebug() << __FUNCTION__ << "about to emit receivedDomainServerList() -----------------------------------------------";
     emit receivedDomainServerList();
 
     DependencyManager::get<NodeList>()->flagTimeForConnectionStep(LimitedNodeList::ConnectionStep::ReceiveDSList);
diff --git a/libraries/networking/src/NodeList.h b/libraries/networking/src/NodeList.h
index 4b196d5f7b..3158262c87 100644
--- a/libraries/networking/src/NodeList.h
+++ b/libraries/networking/src/NodeList.h
@@ -68,6 +68,13 @@ public:
     
     void setIsShuttingDown(bool isShuttingDown) { _isShuttingDown = isShuttingDown; }
 
+    /// downgrades the DomainConnnectRequest PacketVersion to attempt to probe for older domain servers
+    void downgradeDomainServerCheckInVersion() { 
+        qDebug() << __FUNCTION__ << "----------------------------------------------------------";
+        _domainConnectRequestVersion--;
+        
+    }
+
 public slots:
     void reset();
     void sendDomainServerCheckIn();
@@ -85,6 +92,12 @@ public slots:
 
     void processICEPingPacket(QSharedPointer<ReceivedMessage> message);
 
+    void resetDomainServerCheckInVersion()
+    { 
+        qDebug() << __FUNCTION__ << "----------------------------------------------------------";
+        _domainConnectRequestVersion = versionForPacketType(PacketType::DomainConnectRequest); 
+    }
+
 signals:
     void limitOfSilentDomainCheckInsReached();
     void receivedDomainServerList();
@@ -123,6 +136,8 @@ private:
     HifiSockAddr _assignmentServerSocket;
     bool _isShuttingDown { false };
     QTimer _keepAlivePingTimer;
+
+    PacketVersion _domainConnectRequestVersion = versionForPacketType(PacketType::DomainConnectRequest);
 };
 
 #endif // hifi_NodeList_h
diff --git a/libraries/networking/src/PacketReceiver.cpp b/libraries/networking/src/PacketReceiver.cpp
index 530efc5fb3..cb47625d6d 100644
--- a/libraries/networking/src/PacketReceiver.cpp
+++ b/libraries/networking/src/PacketReceiver.cpp
@@ -309,22 +309,29 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(SharedNodePointer, matchingNode));
-                        
+
+                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+
                     } else if (metaMethod.parameterTypes().contains(QSHAREDPOINTER_NODE_NORMALIZED)) {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(QSharedPointer<Node>, matchingNode));
-                        
+
+                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+
                     } else {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
+                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                     }
                 } else {
                     listenerIsDead = true;
                 }
             } else {
+                qDebug() << __FUNCTION__ << "line:" << __LINE__ << "Got verified unsourced packet list." << "packetType:" << packetType;
+
                 // qDebug() << "Got verified unsourced packet list: " << QString(nlPacketList->getMessage());
                 emit dataReceived(NodeType::Unassigned, receivedMessage->getSize());
                 
@@ -332,6 +339,8 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                 if (listener.object) {
                     success = listener.method.invoke(listener.object,
                                                      Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
+
+                    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                 } else {
                     listenerIsDead = true;
                 }
diff --git a/libraries/networking/src/udt/PacketHeaders.cpp b/libraries/networking/src/udt/PacketHeaders.cpp
index b04d582d6d..72875322f6 100644
--- a/libraries/networking/src/udt/PacketHeaders.cpp
+++ b/libraries/networking/src/udt/PacketHeaders.cpp
@@ -12,7 +12,9 @@
 #include "PacketHeaders.h"
 
 #include <math.h>
+#include <mutex>
 
+#include <QtCore/QDataStream>
 #include <QtCore/QDebug>
 #include <QtCore/QMetaEnum>
 
@@ -58,9 +60,13 @@ PacketVersion versionForPacketType(PacketType packetType) {
         case PacketType::AssetUpload:
             // Removal of extension from Asset requests
             return 18;
+
+        case PacketType::DomainConnectionDenied:
+            return static_cast<PacketVersion>(DomainConnectionDeniedVersion::IncludesReasonCode);
+
         case PacketType::DomainConnectRequest:
-            // addition of referring hostname information
-            return 18;
+            return static_cast<PacketVersion>(DomainConnectRequestVersion::HasProtocolVersions);
+
         default:
             return 17;
     }
@@ -80,3 +86,36 @@ QDebug operator<<(QDebug debug, const PacketType& type) {
     debug.nospace().noquote() << (uint8_t) type << " (" << typeName << ")";
     return debug.space();
 }
+
+#if (PR_BUILD || DEV_BUILD)
+static bool sendWrongProtocolVersion = false;
+void sendWrongProtocolVersionsSignature(bool sendWrongVersion) {
+    sendWrongProtocolVersion = sendWrongVersion;
+}
+#endif
+
+QByteArray protocolVersionsSignature() {
+    static QByteArray protocolVersionSignature;
+    static std::once_flag once;
+    std::call_once(once, [&] {
+        QByteArray buffer;
+        QDataStream stream(&buffer, QIODevice::WriteOnly);
+        uint8_t numberOfProtocols = static_cast<uint8_t>(PacketType::LAST_PACKET_TYPE) + 1;
+        stream << numberOfProtocols;
+        for (uint8_t packetType = 0; packetType < numberOfProtocols; packetType++) {
+            uint8_t packetTypeVersion = static_cast<uint8_t>(versionForPacketType(static_cast<PacketType>(packetType)));
+            stream << packetTypeVersion;
+        }
+        QCryptographicHash hash(QCryptographicHash::Md5);
+        hash.addData(buffer);
+        protocolVersionSignature = hash.result();
+    });
+
+    #if (PR_BUILD || DEV_BUILD)
+    if (sendWrongProtocolVersion) {
+        return QByteArray("INCORRECTVERSION"); // only for debugging version checking
+    }
+    #endif
+
+    return protocolVersionSignature;
+}
diff --git a/libraries/networking/src/udt/PacketHeaders.h b/libraries/networking/src/udt/PacketHeaders.h
index 030b4af8c9..b6237e74d6 100644
--- a/libraries/networking/src/udt/PacketHeaders.h
+++ b/libraries/networking/src/udt/PacketHeaders.h
@@ -61,7 +61,7 @@ public:
         AssignmentClientStatus,
         NoisyMute,
         AvatarIdentity,
-        AvatarBillboard,
+        TYPE_UNUSED_1,
         DomainConnectRequest,
         DomainServerRequireDTLS,
         NodeJsonStats,
@@ -94,7 +94,8 @@ public:
         ICEServerHeartbeatDenied,
         AssetMappingOperation,
         AssetMappingOperationReply,
-        ICEServerHeartbeatACK
+        ICEServerHeartbeatACK,
+        LAST_PACKET_TYPE = ICEServerHeartbeatACK
     };
 };
 
@@ -109,6 +110,11 @@ extern const QSet<PacketType> NON_SOURCED_PACKETS;
 extern const QSet<PacketType> RELIABLE_PACKETS;
 
 PacketVersion versionForPacketType(PacketType packetType);
+QByteArray protocolVersionsSignature(); /// returns a unqiue signature for all the current protocols
+
+#if (PR_BUILD || DEV_BUILD)
+void sendWrongProtocolVersionsSignature(bool sendWrongVersion); /// for debugging version negotiation
+#endif
 
 uint qHash(const PacketType& key, uint seed);
 QDebug operator<<(QDebug debug, const PacketType& type);
@@ -179,4 +185,15 @@ enum class AvatarMixerPacketVersion : PacketVersion {
     AvatarEntities
 };
 
+enum class DomainConnectRequestVersion : PacketVersion {
+    NoHostname = 17,
+    HasHostname,
+    HasProtocolVersions
+};
+
+enum class DomainConnectionDeniedVersion : PacketVersion {
+    ReasonMessageOnly = 17,
+    IncludesReasonCode
+};
+
 #endif // hifi_PacketHeaders_h

From 12a1857280f835db093cd12ece0cd1583d43520b Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 15:20:11 -0700
Subject: [PATCH 03/14] check point with protocol refusal working

---
 domain-server/src/DomainGatekeeper.cpp        | 17 +++++++-
 interface/src/Application.cpp                 | 13 +++++-
 interface/src/Application.h                   |  1 +
 .../src/scripting/WindowScriptingInterface.h  |  2 +-
 libraries/networking/src/DomainHandler.cpp    | 41 ++++++++++++++++---
 libraries/networking/src/DomainHandler.h      |  2 +-
 libraries/networking/src/PacketReceiver.cpp   | 10 ++---
 7 files changed, 72 insertions(+), 14 deletions(-)

diff --git a/domain-server/src/DomainGatekeeper.cpp b/domain-server/src/DomainGatekeeper.cpp
index 9d5ee75818..80137935ca 100644
--- a/domain-server/src/DomainGatekeeper.cpp
+++ b/domain-server/src/DomainGatekeeper.cpp
@@ -548,12 +548,27 @@ void DomainGatekeeper::sendConnectionDeniedPacket(const QString& reason, const H
     quint16 payloadSize = utfString.size();
     
     // setup the DomainConnectionDenied packet
-    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied, payloadSize + sizeof(payloadSize));
+    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied); // , payloadSize + sizeof(payloadSize)
     
     // pack in the reason the connection was denied (the client displays this)
     if (payloadSize > 0) {
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        qDebug() << __FUNCTION__ << "about to write reasonCode:" << (int)reasonCode;
+        uint8_t reasonCodeWire = (uint8_t)reasonCode;
+        qDebug() << __FUNCTION__ << "about to write reasonCodeWire:" << (int)reasonCodeWire;
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        connectionDeniedPacket->writePrimitive(reasonCodeWire);
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        qDebug() << __FUNCTION__ << "about to write payloadSize:" << payloadSize;
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
         connectionDeniedPacket->writePrimitive(payloadSize);
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+        qDebug() << __FUNCTION__ << "about to write utfString:" << utfString;
+        qDebug() << __FUNCTION__ << "about to write utfString.size():" << utfString.size();
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
         connectionDeniedPacket->write(utfString);
+        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
+
     }
     
     // send the packet off
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index eca3ecc679..58a273737c 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -630,8 +630,8 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     connect(&domainHandler, SIGNAL(connectedToDomain(const QString&)), SLOT(updateWindowTitle()));
     connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(updateWindowTitle()));
     connect(&domainHandler, SIGNAL(disconnectedFromDomain()), SLOT(clearDomainOctreeDetails()));
-    
     connect(&domainHandler, &DomainHandler::resetting, nodeList.data(), &NodeList::resetDomainServerCheckInVersion);
+    connect(&domainHandler, &DomainHandler::domainConnectionRefused, this, &Application::domainConnectionRefused);
 
     // update our location every 5 seconds in the metaverse server, assuming that we are authenticated with one
     const qint64 DATA_SERVER_LOCATION_CHANGE_UPDATE_MSECS = 5 * MSECS_PER_SECOND;
@@ -1068,6 +1068,17 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     firstRun.set(false);
 }
 
+void Application::domainConnectionRefused(const QString& reasonMessage, int reasonCode) {
+    qDebug() << __FUNCTION__ << "message:" << reasonMessage << "code:" << reasonCode;
+    qDebug() << __FUNCTION__ << "DomainHandler::ConnectionRefusedReason::ProtocolMismatch:" << (int)DomainHandler::ConnectionRefusedReason::ProtocolMismatch;
+
+    if (static_cast<DomainHandler::ConnectionRefusedReason>(reasonCode) == DomainHandler::ConnectionRefusedReason::ProtocolMismatch) {
+        qDebug() << __FUNCTION__ << " PROTOCOL MISMATCH!!!";
+        notifyPacketVersionMismatch();
+    }
+}
+
+
 QString Application::getUserAgent() {
     if (QThread::currentThread() != thread()) {
         QString userAgent;
diff --git a/interface/src/Application.h b/interface/src/Application.h
index edb69eb2ad..69f48e9541 100644
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@@ -330,6 +330,7 @@ private slots:
     static void packetSent(quint64 length);
     void updateDisplayMode();
     void updateInputModes();
+    void domainConnectionRefused(const QString& reasonMessage, int reason);
 
 private:
     static void initDisplay();
diff --git a/interface/src/scripting/WindowScriptingInterface.h b/interface/src/scripting/WindowScriptingInterface.h
index 145d17faaf..72f4ccd866 100644
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@@ -47,7 +47,7 @@ public slots:
 signals:
     void domainChanged(const QString& domainHostname);
     void svoImportRequested(const QString& url);
-    void domainConnectionRefused(const QString& reasonMessage, DomainHandler::ConnectionRefusedReason reason = DomainHandler::ConnectionRefusedReason::Unknown);
+    void domainConnectionRefused(const QString& reasonMessage, int reason);
 
 private slots:
     WebWindowClass* doCreateWebWindow(const QString& title, const QString& url, int width, int height);
diff --git a/libraries/networking/src/DomainHandler.cpp b/libraries/networking/src/DomainHandler.cpp
index d80d4e76fd..67a41c866a 100644
--- a/libraries/networking/src/DomainHandler.cpp
+++ b/libraries/networking/src/DomainHandler.cpp
@@ -103,7 +103,9 @@ void DomainHandler::hardReset() {
     _sockAddr.clear();
 
     _hasCheckedForAccessToken = false;
-    _domainConnectionRefusals.clear();
+
+    //qDebug() << __FUNCTION__ << "about to call _domainConnectionRefusals.clear();";
+    //_domainConnectionRefusals.clear();
 
     // clear any pending path we may have wanted to ask the previous DS about
     _pendingPath.clear();
@@ -142,6 +144,10 @@ void DomainHandler::setSocketAndID(const QString& hostname, quint16 port, const
             // set the new hostname
             _hostname = hostname;
 
+            // FIXME - is this the right place???
+            qDebug() << __FUNCTION__ << "about to call _domainConnectionRefusals.clear();";
+            _domainConnectionRefusals.clear();
+
             qCDebug(networking) << "Updated domain hostname to" << _hostname;
 
             // re-set the sock addr to null and fire off a lookup of the IP address for this domain-server's hostname
@@ -366,25 +372,50 @@ bool DomainHandler::reasonSuggestsLogin(ConnectionRefusedReason reasonCode) {
 
 void DomainHandler::processDomainServerConnectionDeniedPacket(QSharedPointer<ReceivedMessage> message) {
     // Read deny reason from packet
-    ConnectionRefusedReason reasonCode = DomainHandler::ConnectionRefusedReason::Unknown;
+    uint8_t reasonCodeWire;
+
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
+    message->readPrimitive(&reasonCodeWire);
+    qDebug() << __FUNCTION__ << "reasonCodeWire:" << reasonCodeWire;
+    ConnectionRefusedReason reasonCode = static_cast<ConnectionRefusedReason>(reasonCodeWire);
+    qDebug() << __FUNCTION__ << "reasonCode:" << (int)reasonCode;
+
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
+
     quint16 reasonSize;
     message->readPrimitive(&reasonSize);
-    QString reasonMessage = QString::fromUtf8(message->readWithoutCopy(reasonSize));
+    qDebug() << __FUNCTION__ << "reasonSize:" << reasonSize;
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
+    auto reasonText = message->readWithoutCopy(reasonSize);
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "reasonText:" << reasonText;
+    QString reasonMessage = QString::fromUtf8(reasonText);
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "reasonMessage:" << reasonMessage;
+
+    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
 
     // output to the log so the user knows they got a denied connection request
     // and check and signal for an access token so that we can make sure they are logged in
     qCWarning(networking) << "The domain-server denied a connection request: " << reasonMessage;
-    qCWarning(networking) << "Make sure you are logged in.";
+
+    qDebug(networking) << "_domainConnectionRefusals:" << _domainConnectionRefusals;
 
     if (!_domainConnectionRefusals.contains(reasonMessage)) {
+        qDebug(networking) << "about to call _domainConnectionRefusals.append(reasonMessage);";
         _domainConnectionRefusals.append(reasonMessage);
-        emit domainConnectionRefused(reasonMessage, reasonCode);
+        qDebug(networking) << "_domainConnectionRefusals:" << _domainConnectionRefusals;
+
+
+        emit domainConnectionRefused(reasonMessage, (int)reasonCode);
+    } else {
+        qDebug(networking) << "ALREADY EMITTED domainConnectionRefused() ----------------------------";
     }
 
     auto accountManager = DependencyManager::get<AccountManager>();
 
     // Some connection refusal reasons imply that a login is required. If so, suggest a new login
     if (reasonSuggestsLogin(reasonCode)) {
+        qCWarning(networking) << "Make sure you are logged in.";
+
         if (!_hasCheckedForAccessToken) {
             accountManager->checkAndSignalForAccessToken();
             _hasCheckedForAccessToken = true;
diff --git a/libraries/networking/src/DomainHandler.h b/libraries/networking/src/DomainHandler.h
index 41a3e544f6..226186f1d0 100644
--- a/libraries/networking/src/DomainHandler.h
+++ b/libraries/networking/src/DomainHandler.h
@@ -124,7 +124,7 @@ signals:
     void settingsReceived(const QJsonObject& domainSettingsObject);
     void settingsReceiveFail();
 
-    void domainConnectionRefused(QString reasonMessage, ConnectionRefusedReason reason = ConnectionRefusedReason::Unknown);
+    void domainConnectionRefused(QString reasonMessage, int reason);
 
 private:
     bool reasonSuggestsLogin(ConnectionRefusedReason reasonCode);
diff --git a/libraries/networking/src/PacketReceiver.cpp b/libraries/networking/src/PacketReceiver.cpp
index cb47625d6d..8df9a1038a 100644
--- a/libraries/networking/src/PacketReceiver.cpp
+++ b/libraries/networking/src/PacketReceiver.cpp
@@ -310,7 +310,7 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(SharedNodePointer, matchingNode));
 
-                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
 
                     } else if (metaMethod.parameterTypes().contains(QSHAREDPOINTER_NODE_NORMALIZED)) {
                         success = metaMethod.invoke(listener.object,
@@ -318,19 +318,19 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(QSharedPointer<Node>, matchingNode));
 
-                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
 
                     } else {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
-                        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                     }
                 } else {
                     listenerIsDead = true;
                 }
             } else {
-                qDebug() << __FUNCTION__ << "line:" << __LINE__ << "Got verified unsourced packet list." << "packetType:" << packetType;
+                //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "Got verified unsourced packet list." << "packetType:" << packetType;
 
                 // qDebug() << "Got verified unsourced packet list: " << QString(nlPacketList->getMessage());
                 emit dataReceived(NodeType::Unassigned, receivedMessage->getSize());
@@ -340,7 +340,7 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                     success = listener.method.invoke(listener.object,
                                                      Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
 
-                    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
+                    //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                 } else {
                     listenerIsDead = true;
                 }

From 2eef07e414854815b17ef8a155ea5dce9939dae9 Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 15:38:08 -0700
Subject: [PATCH 04/14] cleanup and dead code removal

---
 domain-server/src/DomainGatekeeper.cpp        | 26 +------------------
 domain-server/src/DomainServer.cpp            | 13 +---------
 domain-server/src/NodeConnectionData.cpp      |  5 ++--
 interface/src/Application.cpp                 | 13 ----------
 interface/src/Application.h                   |  4 +--
 .../src/scripting/WindowScriptingInterface.h  |  4 +--
 libraries/networking/src/DomainHandler.cpp    | 24 -----------------
 libraries/networking/src/LimitedNodeList.cpp  |  4 ---
 libraries/networking/src/NLPacket.cpp         |  1 +
 libraries/networking/src/NodeList.cpp         | 17 ------------
 libraries/networking/src/NodeList.h           | 13 +++-------
 libraries/networking/src/PacketReceiver.cpp   | 11 --------
 12 files changed, 11 insertions(+), 124 deletions(-)

diff --git a/domain-server/src/DomainGatekeeper.cpp b/domain-server/src/DomainGatekeeper.cpp
index 80137935ca..bc89b99e8a 100644
--- a/domain-server/src/DomainGatekeeper.cpp
+++ b/domain-server/src/DomainGatekeeper.cpp
@@ -55,10 +55,6 @@ void DomainGatekeeper::processConnectRequestPacket(QSharedPointer<ReceivedMessag
     if (message->getSize() == 0) {
         return;
     }
-
-    //qDebug() << __FUNCTION__ << "packetVersion:" << message->getVersion();
-
-
     QDataStream packetStream(message->getMessage());
 
     // read a NodeConnectionData object from the packet so we can pass around this data while we're inspecting it
@@ -72,8 +68,6 @@ void DomainGatekeeper::processConnectRequestPacket(QSharedPointer<ReceivedMessag
                 DomainHandler::ConnectionRefusedReason::ProtocolMismatch);
         return;
     }
-    //qDebug() << __FUNCTION__ << "Protocol Version MATCH - continue with processing connection.";
-
     
     if (nodeConnection.localSockAddr.isNull() || nodeConnection.publicSockAddr.isNull()) {
         qDebug() << "Unexpected data received for node local socket or public socket. Will not allow connection.";
@@ -111,9 +105,7 @@ void DomainGatekeeper::processConnectRequestPacket(QSharedPointer<ReceivedMessag
             }
         }
         
-        //qDebug() << __FUNCTION__ << " about to processAgentConnectRequest() ---------------------";
         node = processAgentConnectRequest(nodeConnection, username, usernameSignature);
-        //qDebug() << __FUNCTION__ << " AFTER processAgentConnectRequest() node: " << node << " ---------------------";
     }
     
     if (node) {
@@ -125,9 +117,6 @@ void DomainGatekeeper::processConnectRequestPacket(QSharedPointer<ReceivedMessag
         
         // signal that we just connected a node so the DomainServer can get it a list
         // and broadcast its presence right away
-
-        //qDebug() << __FUNCTION__ << " about to connectedNode(node) ---------------------";
-
         emit connectedNode(node);
     } else {
         qDebug() << "Refusing connection from node at" << message->getSenderSockAddr();
@@ -548,27 +537,14 @@ void DomainGatekeeper::sendConnectionDeniedPacket(const QString& reason, const H
     quint16 payloadSize = utfString.size();
     
     // setup the DomainConnectionDenied packet
-    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied); // , payloadSize + sizeof(payloadSize)
+    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied);
     
     // pack in the reason the connection was denied (the client displays this)
     if (payloadSize > 0) {
-        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
-        qDebug() << __FUNCTION__ << "about to write reasonCode:" << (int)reasonCode;
         uint8_t reasonCodeWire = (uint8_t)reasonCode;
-        qDebug() << __FUNCTION__ << "about to write reasonCodeWire:" << (int)reasonCodeWire;
-        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
         connectionDeniedPacket->writePrimitive(reasonCodeWire);
-        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
-        qDebug() << __FUNCTION__ << "about to write payloadSize:" << payloadSize;
-        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
         connectionDeniedPacket->writePrimitive(payloadSize);
-        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
-        qDebug() << __FUNCTION__ << "about to write utfString:" << utfString;
-        qDebug() << __FUNCTION__ << "about to write utfString.size():" << utfString.size();
-        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
         connectionDeniedPacket->write(utfString);
-        qDebug() << __FUNCTION__ << "line:" << __LINE__ << "connectionDeniedPacket->getDataSize():" << connectionDeniedPacket->getDataSize();
-
     }
     
     // send the packet off
diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index 18ca7e2941..f6fbb3f470 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -309,8 +309,6 @@ bool DomainServer::packetVersionMatch(const udt::Packet& packet) {
     PacketType headerType = NLPacket::typeInHeader(packet);
     PacketVersion headerVersion = NLPacket::versionInHeader(packet);
 
-    //qDebug() << __FUNCTION__ << "type:" << headerType << "version:" << (int)headerVersion;
-
     auto nodeList = DependencyManager::get<LimitedNodeList>();
 
     // This implements a special case that handles OLD clients which don't know how to negotiate matching
@@ -320,9 +318,6 @@ bool DomainServer::packetVersionMatch(const udt::Packet& packet) {
     // warn the user that the protocol is not compatible
     if (headerType == PacketType::DomainConnectRequest &&
         headerVersion < static_cast<PacketVersion>(DomainConnectRequestVersion::HasProtocolVersions)) {
-
-        //qDebug() << __FUNCTION__ << "OLD VERSION checkin sending an intentional bad packet -------------------------------";
-
         auto packetWithBadVersion = NLPacket::create(PacketType::EntityData);
         nodeList->sendPacket(std::move(packetWithBadVersion), packet.getSenderSockAddr());
         return false;
@@ -407,8 +402,7 @@ void DomainServer::setupNodeListAndAssignments(const QUuid& sessionUUID) {
     // add whatever static assignments that have been parsed to the queue
     addStaticAssignmentsToQueue();
 
-    // set packetVersionMatch as the verify packet operator for the udt::Socket
-    //using std::placeholders::_1;
+    // set a custum packetVersionMatch as the verify packet operator for the udt::Socket
     nodeList->setPacketFilterOperator(&DomainServer::packetVersionMatch);
 }
 
@@ -701,8 +695,6 @@ void DomainServer::populateDefaultStaticAssignmentsExcludingTypes(const QSet<Ass
 
 void DomainServer::processListRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
 
-    //qDebug() << __FUNCTION__ << "---------------";
-    
     QDataStream packetStream(message->getMessage());
     NodeConnectionData nodeRequestData = NodeConnectionData::fromDataStream(packetStream, message->getSenderSockAddr(), false);
 
@@ -782,9 +774,6 @@ void DomainServer::handleConnectedNode(SharedNodePointer newNode) {
 }
 
 void DomainServer::sendDomainListToNode(const SharedNodePointer& node, const HifiSockAddr &senderSockAddr) {
-
-    //qDebug() << __FUNCTION__ << "---------------";
-
     const int NUM_DOMAIN_LIST_EXTENDED_HEADER_BYTES = NUM_BYTES_RFC4122_UUID + NUM_BYTES_RFC4122_UUID + 2;
     
     // setup the extended header for the domain list packets
diff --git a/domain-server/src/NodeConnectionData.cpp b/domain-server/src/NodeConnectionData.cpp
index 5ddcbf1792..13bb9123d8 100644
--- a/domain-server/src/NodeConnectionData.cpp
+++ b/domain-server/src/NodeConnectionData.cpp
@@ -24,10 +24,11 @@ NodeConnectionData NodeConnectionData::fromDataStream(QDataStream& dataStream, c
         char* rawBytes;
         uint length;
 
-        // FIXME -- do we need to delete the rawBytes after it's been copied into the QByteArray?
         dataStream.readBytes(rawBytes, length);
         newHeader.protocolVersion = QByteArray(rawBytes, length);
-        //qDebug() << __FUNCTION__ << "...got protocol version from node... version:" << newHeader.protocolVersion;
+
+        // NOTE: QDataStream::readBytes() - The buffer is allocated using new []. Destroy it with the delete [] operator.
+        delete[] rawBytes;
     }
     
     dataStream >> newHeader.nodeType
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 58a273737c..bf897015f8 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -654,11 +654,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     connect(nodeList.data(), &NodeList::nodeActivated, this, &Application::nodeActivated);
     connect(nodeList.data(), &NodeList::uuidChanged, getMyAvatar(), &MyAvatar::setSessionUUID);
     connect(nodeList.data(), &NodeList::uuidChanged, this, &Application::setSessionUUID);
-
     connect(nodeList.data(), &NodeList::limitOfSilentDomainCheckInsReached, this, &Application::limitOfSilentDomainCheckInsReached);
-    //connect(nodeList.data(), &NodeList::limitOfSilentDomainCheckInsReached, nodeList.data(), &NodeList::reset);
-
-
     connect(nodeList.data(), &NodeList::packetVersionMismatch, this, &Application::notifyPacketVersionMismatch);
 
     // connect to appropriate slots on AccountManager
@@ -1069,16 +1065,11 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
 }
 
 void Application::domainConnectionRefused(const QString& reasonMessage, int reasonCode) {
-    qDebug() << __FUNCTION__ << "message:" << reasonMessage << "code:" << reasonCode;
-    qDebug() << __FUNCTION__ << "DomainHandler::ConnectionRefusedReason::ProtocolMismatch:" << (int)DomainHandler::ConnectionRefusedReason::ProtocolMismatch;
-
     if (static_cast<DomainHandler::ConnectionRefusedReason>(reasonCode) == DomainHandler::ConnectionRefusedReason::ProtocolMismatch) {
-        qDebug() << __FUNCTION__ << " PROTOCOL MISMATCH!!!";
         notifyPacketVersionMismatch();
     }
 }
 
-
 QString Application::getUserAgent() {
     if (QThread::currentThread() != thread()) {
         QString userAgent;
@@ -4595,12 +4586,8 @@ void Application::setSessionUUID(const QUuid& sessionUUID) const {
 // We won't actually complete the connection, but if the server responds, we know that it needs to be upgraded (or we
 // need to be downgraded to talk to it).
 void Application::limitOfSilentDomainCheckInsReached() {
-    //qDebug() << __FUNCTION__;
-
     auto nodeList = DependencyManager::get<NodeList>();
-
     nodeList->downgradeDomainServerCheckInVersion(); // attempt to use an older domain checkin version
-
     nodeList->reset();
 }
 
diff --git a/interface/src/Application.h b/interface/src/Application.h
index 69f48e9541..a17250a58e 100644
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@@ -262,9 +262,7 @@ public slots:
     void setActiveFaceTracker() const;
 
 #if (PR_BUILD || DEV_BUILD)
-    void sendWrongProtocolVersionsSignature(bool checked) {
-        ::sendWrongProtocolVersionsSignature(checked);
-    }
+    void sendWrongProtocolVersionsSignature(bool checked) { ::sendWrongProtocolVersionsSignature(checked); }
 #endif
 
 #ifdef HAVE_IVIEWHMD
diff --git a/interface/src/scripting/WindowScriptingInterface.h b/interface/src/scripting/WindowScriptingInterface.h
index 72f4ccd866..dfe02a5064 100644
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@@ -16,8 +16,6 @@
 #include <QtCore/QString>
 #include <QtScript/QScriptValue>
 
-#include <DomainHandler.h>
-
 class WebWindowClass;
 
 class WindowScriptingInterface : public QObject, public Dependency {
@@ -47,7 +45,7 @@ public slots:
 signals:
     void domainChanged(const QString& domainHostname);
     void svoImportRequested(const QString& url);
-    void domainConnectionRefused(const QString& reasonMessage, int reason);
+    void domainConnectionRefused(const QString& reasonMessage, int reasonCode);
 
 private slots:
     WebWindowClass* doCreateWebWindow(const QString& title, const QString& url, int width, int height);
diff --git a/libraries/networking/src/DomainHandler.cpp b/libraries/networking/src/DomainHandler.cpp
index 67a41c866a..1efcfc7f27 100644
--- a/libraries/networking/src/DomainHandler.cpp
+++ b/libraries/networking/src/DomainHandler.cpp
@@ -104,9 +104,6 @@ void DomainHandler::hardReset() {
 
     _hasCheckedForAccessToken = false;
 
-    //qDebug() << __FUNCTION__ << "about to call _domainConnectionRefusals.clear();";
-    //_domainConnectionRefusals.clear();
-
     // clear any pending path we may have wanted to ask the previous DS about
     _pendingPath.clear();
 }
@@ -145,7 +142,6 @@ void DomainHandler::setSocketAndID(const QString& hostname, quint16 port, const
             _hostname = hostname;
 
             // FIXME - is this the right place???
-            qDebug() << __FUNCTION__ << "about to call _domainConnectionRefusals.clear();";
             _domainConnectionRefusals.clear();
 
             qCDebug(networking) << "Updated domain hostname to" << _hostname;
@@ -374,40 +370,20 @@ void DomainHandler::processDomainServerConnectionDeniedPacket(QSharedPointer<Rec
     // Read deny reason from packet
     uint8_t reasonCodeWire;
 
-    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
     message->readPrimitive(&reasonCodeWire);
-    qDebug() << __FUNCTION__ << "reasonCodeWire:" << reasonCodeWire;
     ConnectionRefusedReason reasonCode = static_cast<ConnectionRefusedReason>(reasonCodeWire);
-    qDebug() << __FUNCTION__ << "reasonCode:" << (int)reasonCode;
-
-    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
-
     quint16 reasonSize;
     message->readPrimitive(&reasonSize);
-    qDebug() << __FUNCTION__ << "reasonSize:" << reasonSize;
-    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
     auto reasonText = message->readWithoutCopy(reasonSize);
-    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "reasonText:" << reasonText;
     QString reasonMessage = QString::fromUtf8(reasonText);
-    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "reasonMessage:" << reasonMessage;
-
-    qDebug() << __FUNCTION__ << "line:" << __LINE__ << "message->getPosition():" << message->getPosition();
 
     // output to the log so the user knows they got a denied connection request
     // and check and signal for an access token so that we can make sure they are logged in
     qCWarning(networking) << "The domain-server denied a connection request: " << reasonMessage;
 
-    qDebug(networking) << "_domainConnectionRefusals:" << _domainConnectionRefusals;
-
     if (!_domainConnectionRefusals.contains(reasonMessage)) {
-        qDebug(networking) << "about to call _domainConnectionRefusals.append(reasonMessage);";
         _domainConnectionRefusals.append(reasonMessage);
-        qDebug(networking) << "_domainConnectionRefusals:" << _domainConnectionRefusals;
-
-
         emit domainConnectionRefused(reasonMessage, (int)reasonCode);
-    } else {
-        qDebug(networking) << "ALREADY EMITTED domainConnectionRefused() ----------------------------";
     }
 
     auto accountManager = DependencyManager::get<AccountManager>();
diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp
index 714b69fd89..2c10d0627e 100644
--- a/libraries/networking/src/LimitedNodeList.cpp
+++ b/libraries/networking/src/LimitedNodeList.cpp
@@ -162,17 +162,13 @@ QUdpSocket& LimitedNodeList::getDTLSSocket() {
 }
 
 bool LimitedNodeList::isPacketVerified(const udt::Packet& packet) {
-    //qDebug() << __FUNCTION__;
     return packetVersionMatch(packet) && packetSourceAndHashMatch(packet);
 }
 
 bool LimitedNodeList::packetVersionMatch(const udt::Packet& packet) {
-
     PacketType headerType = NLPacket::typeInHeader(packet);
     PacketVersion headerVersion = NLPacket::versionInHeader(packet);
 
-    //qDebug() << __FUNCTION__ << "headerType:" << headerType << "version:" << (int)headerVersion;
-
     if (headerVersion != versionForPacketType(headerType)) {
 
         static QMultiHash<QUuid, PacketType> sourcedVersionDebugSuppressMap;
diff --git a/libraries/networking/src/NLPacket.cpp b/libraries/networking/src/NLPacket.cpp
index 93f8659663..34a159ae6c 100644
--- a/libraries/networking/src/NLPacket.cpp
+++ b/libraries/networking/src/NLPacket.cpp
@@ -67,6 +67,7 @@ NLPacket::NLPacket(PacketType type, qint64 size, bool isReliable, bool isPartOfM
     _version((version == 0) ? versionForPacketType(type) : version)
 {
     adjustPayloadStartAndCapacity(NLPacket::localHeaderSize(_type));
+
     writeTypeAndVersion();
 }
 
diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp
index 5f3f34dafb..082200fccc 100644
--- a/libraries/networking/src/NodeList.cpp
+++ b/libraries/networking/src/NodeList.cpp
@@ -293,7 +293,6 @@ void NodeList::sendDomainServerCheckIn() {
         }
 
         auto packetVersion = (domainPacketType == PacketType::DomainConnectRequest) ? _domainConnectRequestVersion : 0;
-        //qDebug() << __FUNCTION__ << " NLPacket::create() version:" << (int)packetVersion;
         auto domainPacket = NLPacket::create(domainPacketType, -1, false, false, packetVersion);
         
         QDataStream packetStream(domainPacket.get());
@@ -319,12 +318,7 @@ void NodeList::sendDomainServerCheckIn() {
             if (_domainConnectRequestVersion >= static_cast<PacketVersion>(DomainConnectRequestVersion::HasProtocolVersions)) {
                 QByteArray protocolVersionSig = protocolVersionsSignature();
                 packetStream.writeBytes(protocolVersionSig.constData(), protocolVersionSig.size());
-                //qDebug() << __FUNCTION__ << " including protocol version --------------------------";
-            } else {
-                //qDebug() << __FUNCTION__ << "_domainConnectRequestVersion less than HasProtocolVersions - not including protocol version";
             }
-        } else {
-            //qDebug() << __FUNCTION__ << "NOT a DomainConnnectRequest ----------- not including checkin details -------";
         }
 
         // pack our data to send to the domain-server including
@@ -332,9 +326,6 @@ void NodeList::sendDomainServerCheckIn() {
         packetStream << _ownerType << _publicSockAddr << _localSockAddr << _nodeTypesOfInterest.toList();
         if (_domainConnectRequestVersion >= static_cast<PacketVersion>(DomainConnectRequestVersion::HasHostname)) {
             packetStream << DependencyManager::get<AddressManager>()->getPlaceName();
-            //qDebug() << __FUNCTION__ << " including host name --------------------------";
-        } else {
-            //qDebug() << __FUNCTION__ << "_domainConnectRequestVersion less than HasHostname - not including host name";
         }
 
         if (!_domainHandler.isConnected()) {
@@ -363,7 +354,6 @@ void NodeList::sendDomainServerCheckIn() {
 
         // increment the count of un-replied check-ins
         _numNoReplyDomainCheckIns++;
-        //qDebug() << __FUNCTION__ << " _numNoReplyDomainCheckIns:" << _numNoReplyDomainCheckIns << " --------------------------";
     }
 
     if (!_publicSockAddr.isNull() && !_domainHandler.isConnected() && !_domainHandler.getPendingDomainID().isNull()) {
@@ -531,22 +521,15 @@ void NodeList::processDomainServerConnectionTokenPacket(QSharedPointer<ReceivedM
 }
 
 void NodeList::processDomainServerList(QSharedPointer<ReceivedMessage> message) {
-    //qDebug() << __FUNCTION__;
-
     if (_domainHandler.getSockAddr().isNull()) {
         // refuse to process this packet if we aren't currently connected to the DS
         return;
     }
 
-    //qDebug() << __FUNCTION__ << "_numNoReplyDomainCheckIns:" << _numNoReplyDomainCheckIns;
-
     // this is a packet from the domain server, reset the count of un-replied check-ins
     _numNoReplyDomainCheckIns = 0;
 
-    //qDebug() << __FUNCTION__ << "RESET.... _numNoReplyDomainCheckIns:" << _numNoReplyDomainCheckIns;
-
     // emit our signal so listeners know we just heard from the DS
-    //qDebug() << __FUNCTION__ << "about to emit receivedDomainServerList() -----------------------------------------------";
     emit receivedDomainServerList();
 
     DependencyManager::get<NodeList>()->flagTimeForConnectionStep(LimitedNodeList::ConnectionStep::ReceiveDSList);
diff --git a/libraries/networking/src/NodeList.h b/libraries/networking/src/NodeList.h
index 3158262c87..b269554e77 100644
--- a/libraries/networking/src/NodeList.h
+++ b/libraries/networking/src/NodeList.h
@@ -69,11 +69,7 @@ public:
     void setIsShuttingDown(bool isShuttingDown) { _isShuttingDown = isShuttingDown; }
 
     /// downgrades the DomainConnnectRequest PacketVersion to attempt to probe for older domain servers
-    void downgradeDomainServerCheckInVersion() { 
-        qDebug() << __FUNCTION__ << "----------------------------------------------------------";
-        _domainConnectRequestVersion--;
-        
-    }
+    void downgradeDomainServerCheckInVersion() { _domainConnectRequestVersion--; }
 
 public slots:
     void reset();
@@ -92,11 +88,8 @@ public slots:
 
     void processICEPingPacket(QSharedPointer<ReceivedMessage> message);
 
-    void resetDomainServerCheckInVersion()
-    { 
-        qDebug() << __FUNCTION__ << "----------------------------------------------------------";
-        _domainConnectRequestVersion = versionForPacketType(PacketType::DomainConnectRequest); 
-    }
+    void resetDomainServerCheckInVersion() 
+            { _domainConnectRequestVersion = versionForPacketType(PacketType::DomainConnectRequest); }
 
 signals:
     void limitOfSilentDomainCheckInsReached();
diff --git a/libraries/networking/src/PacketReceiver.cpp b/libraries/networking/src/PacketReceiver.cpp
index 8df9a1038a..9cbff8abbd 100644
--- a/libraries/networking/src/PacketReceiver.cpp
+++ b/libraries/networking/src/PacketReceiver.cpp
@@ -309,29 +309,20 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(SharedNodePointer, matchingNode));
-
-                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
-
                     } else if (metaMethod.parameterTypes().contains(QSHAREDPOINTER_NODE_NORMALIZED)) {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(QSharedPointer<Node>, matchingNode));
-
-                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
-
                     } else {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
-                        //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                     }
                 } else {
                     listenerIsDead = true;
                 }
             } else {
-                //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "Got verified unsourced packet list." << "packetType:" << packetType;
-
                 // qDebug() << "Got verified unsourced packet list: " << QString(nlPacketList->getMessage());
                 emit dataReceived(NodeType::Unassigned, receivedMessage->getSize());
                 
@@ -339,8 +330,6 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                 if (listener.object) {
                     success = listener.method.invoke(listener.object,
                                                      Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage));
-
-                    //qDebug() << __FUNCTION__ << "line:" << __LINE__ << "success:" << success << "packetType:" << packetType;
                 } else {
                     listenerIsDead = true;
                 }

From 0553ff5f9fc0c7edcbd24e0e4e1c6f14b6a7b561 Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 15:41:11 -0700
Subject: [PATCH 05/14] cleanup and dead code removal

---
 libraries/networking/src/PacketReceiver.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libraries/networking/src/PacketReceiver.cpp b/libraries/networking/src/PacketReceiver.cpp
index 9cbff8abbd..423e753ae0 100644
--- a/libraries/networking/src/PacketReceiver.cpp
+++ b/libraries/networking/src/PacketReceiver.cpp
@@ -309,11 +309,13 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(SharedNodePointer, matchingNode));
+
                     } else if (metaMethod.parameterTypes().contains(QSHAREDPOINTER_NODE_NORMALIZED)) {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(QSharedPointer<Node>, matchingNode));
+
                     } else {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,

From 3b0081fbbba9276029f5b37a8efc11ecfd03eaea Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 15:42:55 -0700
Subject: [PATCH 06/14] cleanup and dead code removal

---
 libraries/networking/src/PacketReceiver.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/networking/src/PacketReceiver.cpp b/libraries/networking/src/PacketReceiver.cpp
index 423e753ae0..87c77967a5 100644
--- a/libraries/networking/src/PacketReceiver.cpp
+++ b/libraries/networking/src/PacketReceiver.cpp
@@ -315,7 +315,7 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(QSharedPointer<Node>, matchingNode));
-
+                        
                     } else {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,

From 5668db9e4a6f54e4971fe34f9abce516f365b867 Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 15:43:30 -0700
Subject: [PATCH 07/14] cleanup and dead code removal

---
 libraries/networking/src/PacketReceiver.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/networking/src/PacketReceiver.cpp b/libraries/networking/src/PacketReceiver.cpp
index 87c77967a5..530efc5fb3 100644
--- a/libraries/networking/src/PacketReceiver.cpp
+++ b/libraries/networking/src/PacketReceiver.cpp
@@ -309,7 +309,7 @@ void PacketReceiver::handleVerifiedMessage(QSharedPointer<ReceivedMessage> recei
                                                     connectionType,
                                                     Q_ARG(QSharedPointer<ReceivedMessage>, receivedMessage),
                                                     Q_ARG(SharedNodePointer, matchingNode));
-
+                        
                     } else if (metaMethod.parameterTypes().contains(QSHAREDPOINTER_NODE_NORMALIZED)) {
                         success = metaMethod.invoke(listener.object,
                                                     connectionType,

From 183f38e4f06c28fa69bcd4dfba5bcc4b669c3d65 Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 16:07:57 -0700
Subject: [PATCH 08/14] pop up warning if domain over capacity

---
 domain-server/src/DomainGatekeeper.cpp |  4 ++--
 interface/src/Application.cpp          | 16 ++++++++++++++--
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/domain-server/src/DomainGatekeeper.cpp b/domain-server/src/DomainGatekeeper.cpp
index bc89b99e8a..9023510214 100644
--- a/domain-server/src/DomainGatekeeper.cpp
+++ b/domain-server/src/DomainGatekeeper.cpp
@@ -443,10 +443,10 @@ bool DomainGatekeeper::isWithinMaxCapacity(const QString& username, const QByteA
     // find out what our maximum capacity is
     const QVariant* maximumUserCapacityVariant = valueForKeyPath(_server->_settingsManager.getSettingsMap(), MAXIMUM_USER_CAPACITY);
     unsigned int maximumUserCapacity = maximumUserCapacityVariant ? maximumUserCapacityVariant->toUInt() : 0;
-    
+
     if (maximumUserCapacity > 0) {
         unsigned int connectedUsers = _server->countConnectedUsers();
-        
+
         if (connectedUsers >= maximumUserCapacity) {
             // too many users, deny the new connection unless this user is an allowed editor
             
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index bf897015f8..f3322caffb 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -1065,8 +1065,20 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
 }
 
 void Application::domainConnectionRefused(const QString& reasonMessage, int reasonCode) {
-    if (static_cast<DomainHandler::ConnectionRefusedReason>(reasonCode) == DomainHandler::ConnectionRefusedReason::ProtocolMismatch) {
-        notifyPacketVersionMismatch();
+    switch (static_cast<DomainHandler::ConnectionRefusedReason>(reasonCode)) {
+        case DomainHandler::ConnectionRefusedReason::ProtocolMismatch:
+            notifyPacketVersionMismatch();
+            break;
+        case DomainHandler::ConnectionRefusedReason::TooManyUsers:
+        case DomainHandler::ConnectionRefusedReason::Unknown: {
+            QString message = "Unable to connect to the location you are visiting.\n";
+            message += reasonMessage;
+            OffscreenUi::warning("", message);
+            break;
+        }
+        default:
+            // nothing to do.
+            break;
     }
 }
 

From a3f1ece978987b203b50e438628b417fdfa1823e Mon Sep 17 00:00:00 2001
From: howard-stearns <howard.stearns@gmail.com>
Date: Tue, 24 May 2016 16:10:12 -0700
Subject: [PATCH 09/14] Do button mapping in C++ and simplify vive.json
 accordingly. Vive and Hydra now use PrimaryThumb and SecondaryThumb. Fix
 warnings for Neuron.

---
 interface/resources/controllers/hydra.json    | 10 +++----
 interface/resources/controllers/neuron.json   |  4 +--
 interface/resources/controllers/vive.json     | 10 ++++---
 .../src/controllers/StandardControls.h        |  4 +++
 plugins/openvr/src/ViveControllerManager.cpp  | 22 ++++++++++++++-
 plugins/openvr/src/ViveControllerManager.h    |  1 +
 .../controllers/handControllerPointer.js      | 28 +++----------------
 7 files changed, 42 insertions(+), 37 deletions(-)

diff --git a/interface/resources/controllers/hydra.json b/interface/resources/controllers/hydra.json
index 8233685763..066676140c 100644
--- a/interface/resources/controllers/hydra.json
+++ b/interface/resources/controllers/hydra.json
@@ -16,12 +16,10 @@
         { "from": "Hydra.L0", "to": "Standard.Back" },
         { "from": "Hydra.R0", "to": "Standard.Start" },
 
-        { "from": [ "Hydra.L1", "Hydra.L2" ], "to": "Standard.LeftPrimaryThumb" },
-        { "from": [ "Hydra.R1", "Hydra.R2" ], "to": "Standard.RightPrimaryThumb" },
-        { "from": [ "Hydra.L3" ], "to": "Standard.L3" },
-        { "from": [ "Hydra.R3" ], "to": "Standard.R3" },
-        { "from": [ "Hydra.R4" ], "to": "Standard.RightSecondaryThumb" },
-        { "from": [ "Hydra.L4" ], "to": "Standard.LeftSecondaryThumb" },
+        { "from": [ "Hydra.L1", "Hydra.L3" ], "to": "Standard.LeftPrimaryThumb" },
+        { "from": [ "Hydra.R1", "Hydra.R3" ], "to": "Standard.RightPrimaryThumb" },
+        { "from": [ "Hydra.R2", "Hydra.R4" ], "to": "Standard.RightSecondaryThumb" },
+        { "from": [ "Hydra.L2", "Hydra.L4" ], "to": "Standard.LeftSecondaryThumb" },
 
         { "from": "Hydra.LeftHand", "to": "Standard.LeftHand" }, 
         { "from": "Hydra.RightHand", "to": "Standard.RightHand" }
diff --git a/interface/resources/controllers/neuron.json b/interface/resources/controllers/neuron.json
index 2d61f80c35..d0962c72db 100644
--- a/interface/resources/controllers/neuron.json
+++ b/interface/resources/controllers/neuron.json
@@ -1,7 +1,7 @@
 {
     "name": "Neuron to Standard",
     "channels": [
-        { "from": "Hydra.LeftHand", "to": "Standard.LeftHand" },
-        { "from": "Hydra.RightHand", "to": "Standard.RightHand" }
+        { "from": "Neuron.LeftHand", "to": "Standard.LeftHand" },
+        { "from": "Neuron.RightHand", "to": "Standard.RightHand" }
     ]
 }
diff --git a/interface/resources/controllers/vive.json b/interface/resources/controllers/vive.json
index fec93c9132..60a46ba3ce 100644
--- a/interface/resources/controllers/vive.json
+++ b/interface/resources/controllers/vive.json
@@ -1,23 +1,25 @@
 {
     "name": "Vive to Standard",
     "channels": [
-        { "from": "Vive.LY",  "when": "Vive.LS", "filters": ["invert" ,{ "type": "deadZone", "min": 0.6 }], "to": "Standard.LY" },
-        { "from": "Vive.LX",  "when": "Vive.LS", "filters": [{ "type": "deadZone", "min": 0.6 }], "to": "Standard.LX" },
+        { "from": "Vive.LY", "when": "Vive.LSOuter", "filters": ["invert"], "to": "Standard.LY" },
+        { "from": "Vive.LX", "when": "Vive.LSOuter", "to": "Standard.LX" },
 
         { "from": "Vive.LT", "to": "Standard.LT" },
         { "from": "Vive.LeftGrip", "to": "Standard.LB" },
         { "from": "Vive.LS", "to": "Standard.LS" },
         { "from": "Vive.LSTouch", "to": "Standard.LSTouch" },
 
-        { "from": "Vive.RY",  "when": "Vive.RS", "filters": ["invert", { "type": "deadZone", "min": 0.6 }], "to": "Standard.RY" },
-        { "from": "Vive.RX",  "when": "Vive.RS", "filters": [{ "type": "deadZone", "min": 0.6 }], "to": "Standard.RX" },
+        { "from": "Vive.RY", "when": "Vive.RSOuter", "filters": ["invert"], "to": "Standard.RY" },
+        { "from": "Vive.RX", "when": "Vive.RSOuter", "to": "Standard.RX" },
 
         { "from": "Vive.RT", "to": "Standard.RT" },
         { "from": "Vive.RightGrip", "to": "Standard.RB" },
         { "from": "Vive.RS", "to": "Standard.RS" },
         { "from": "Vive.RSTouch", "to": "Standard.RSTouch" },
 
+        { "from": "Vive.LSCenter", "to": "Standard.LeftPrimaryThumb" },
         { "from": "Vive.LeftApplicationMenu", "to": "Standard.LeftSecondaryThumb" },
+        { "from": "Vive.RSCenter", "to": "Standard.RightPrimaryThumb" },
         { "from": "Vive.RightApplicationMenu", "to": "Standard.RightSecondaryThumb" },
 
         { "from": "Vive.LeftHand", "to": "Standard.LeftHand" },
diff --git a/libraries/controllers/src/controllers/StandardControls.h b/libraries/controllers/src/controllers/StandardControls.h
index f101ba6c51..79c23bc6ee 100644
--- a/libraries/controllers/src/controllers/StandardControls.h
+++ b/libraries/controllers/src/controllers/StandardControls.h
@@ -43,6 +43,8 @@ namespace controller {
         LEFT_SECONDARY_THUMB_TOUCH,
         LS_TOUCH,
         LEFT_THUMB_UP,
+        LS_CENTER,
+        LS_OUTER,
 
         RIGHT_PRIMARY_THUMB,
         RIGHT_SECONDARY_THUMB,
@@ -50,6 +52,8 @@ namespace controller {
         RIGHT_SECONDARY_THUMB_TOUCH,
         RS_TOUCH,
         RIGHT_THUMB_UP,
+        RS_CENTER,
+        RS_OUTER,
 
         LEFT_PRIMARY_INDEX,
         LEFT_SECONDARY_INDEX,
diff --git a/plugins/openvr/src/ViveControllerManager.cpp b/plugins/openvr/src/ViveControllerManager.cpp
index 12567b10d1..6e75454b5f 100644
--- a/plugins/openvr/src/ViveControllerManager.cpp
+++ b/plugins/openvr/src/ViveControllerManager.cpp
@@ -282,7 +282,22 @@ void ViveControllerManager::InputDevice::handleHandController(float deltaTime, u
             for (uint32_t i = 0; i < vr::k_unControllerStateAxisCount; i++) {
                 handleAxisEvent(deltaTime, i, controllerState.rAxis[i].x, controllerState.rAxis[i].y, isLeftHand);
             }
-        }
+
+            // pseudo buttons the depend on both of the above for-loops
+            partitionTouchpad(controller::LS, controller::LX, controller::LY, controller::LS_CENTER, controller::LS_OUTER);
+            partitionTouchpad(controller::RS, controller::RX, controller::RY, controller::RS_CENTER, controller::RS_OUTER);
+         }
+    }
+}
+
+void ViveControllerManager::InputDevice::partitionTouchpad(int sButton, int xAxis, int yAxis, int centerPseudoButton, int outerPseudoButton) {
+    // Populate the L/RS_CENTER/OUTER pseudo buttons, corresponding to a partition of the L/RS space based on the X/Y values.
+    const float CENTER_DEADBAND = 0.6f;
+    if (_buttonPressedMap.find(sButton) != _buttonPressedMap.end()) {
+        float absX = abs(_axisStateMap[xAxis]);
+        float absY = abs(_axisStateMap[yAxis]);
+        bool isCenter = (absX < CENTER_DEADBAND) && (absY < CENTER_DEADBAND); // square deadband
+        _buttonPressedMap.insert(isCenter ? centerPseudoButton : outerPseudoButton);
     }
 }
 
@@ -443,6 +458,11 @@ controller::Input::NamedVector ViveControllerManager::InputDevice::getAvailableI
         // touch pad press
         makePair(LS, "LS"),
         makePair(RS, "RS"),
+        // Differentiate where we are in the touch pad click
+        makePair(LS_CENTER, "LSCenter"),
+        makePair(LS_OUTER, "LSOuter"),
+        makePair(RS_CENTER, "RSCenter"),
+        makePair(RS_OUTER, "RSOuter"),
 
         // triggers
         makePair(LT, "LT"),
diff --git a/plugins/openvr/src/ViveControllerManager.h b/plugins/openvr/src/ViveControllerManager.h
index 672ad59cfe..bd5d4a39f4 100644
--- a/plugins/openvr/src/ViveControllerManager.h
+++ b/plugins/openvr/src/ViveControllerManager.h
@@ -61,6 +61,7 @@ private:
         void handleAxisEvent(float deltaTime, uint32_t axis, float x, float y, bool isLeftHand);
         void handlePoseEvent(float deltaTime, const controller::InputCalibrationData& inputCalibrationData, const mat4& mat,
                              const vec3& linearVelocity, const vec3& angularVelocity, bool isLeftHand);
+        void ViveControllerManager::InputDevice::partitionTouchpad(int sButton, int xAxis, int yAxis, int centerPsuedoButton, int outerPseudoButton);
 
         class FilteredStick {
         public:
diff --git a/scripts/system/controllers/handControllerPointer.js b/scripts/system/controllers/handControllerPointer.js
index e7be3af5dd..ca3b5e8cf2 100644
--- a/scripts/system/controllers/handControllerPointer.js
+++ b/scripts/system/controllers/handControllerPointer.js
@@ -266,39 +266,19 @@ function toggleHand() {
     }
 }
 
-// Create clickMappings as needed, on demand.
 var clickMapping = Controller.newMapping(Script.resolvePath('') + '-click');
 Script.scriptEnding.connect(clickMapping.disable);
 
-// Move these to vive.json
-function makeCenterClickWhen(click, x, y) {
-    var clickKey = Controller.Standard[click],
-        xKey = Controller.Standard[x],  // Standard after filtering by mapping
-        yKey = Controller.Standard[y];
-    return function () {
-        var clickValue = Controller.getValue(clickKey);
-        var xValue = Controller.getValue(xKey);
-        var yValue = Controller.getValue(yKey);
-        var answer = clickValue && !xValue && !yValue;
-        return answer;
-    };
-}
-if (Controller.Hardware.Vive) {
-    clickMapping.from(Controller.Hardware.Vive.RS).when(makeCenterClickWhen('RS', 'RX', 'RY')).to(Controller.Standard.R3);
-    clickMapping.from(Controller.Hardware.Vive.LS).when(makeCenterClickWhen('LS', 'LX', 'LY')).to(Controller.Standard.L3);
-}
-
-
-clickMapping.from(Controller.Standard.R3).peek().to(Controller.Actions.ReticleClick);
-clickMapping.from(Controller.Standard.L3).peek().to(Controller.Actions.ReticleClick);
+clickMapping.from(Controller.Standard.RightPrimaryThumb).peek().to(Controller.Actions.ReticleClick);
+clickMapping.from(Controller.Standard.LeftPrimaryThumb).peek().to(Controller.Actions.ReticleClick);
 clickMapping.from(Controller.Standard.RightSecondaryThumb).peek().to(Controller.Actions.ContextMenu);
 clickMapping.from(Controller.Standard.LeftSecondaryThumb).peek().to(Controller.Actions.ContextMenu);
-clickMapping.from(Controller.Standard.R3).peek().to(function (on) {
+clickMapping.from(Controller.Standard.RightPrimaryThumb).peek().to(function (on) {
     if (on && (activeHand !== Controller.Standard.RightHand)) {
         toggleHand();
     }
 });
-clickMapping.from(Controller.Standard.L3).peek().to(function (on) {
+clickMapping.from(Controller.Standard.LeftPrimaryThumb).peek().to(function (on) {
     if (on && (activeHand !== Controller.Standard.LeftHand)) {
         toggleHand();
     }

From fb9f6185db724c0fc3f30ec46ad70353e3a848de Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 17:19:53 -0700
Subject: [PATCH 10/14] CR feedback

---
 domain-server/src/DomainGatekeeper.cpp | 5 +++--
 interface/src/Application.cpp          | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/domain-server/src/DomainGatekeeper.cpp b/domain-server/src/DomainGatekeeper.cpp
index 9023510214..b940d46849 100644
--- a/domain-server/src/DomainGatekeeper.cpp
+++ b/domain-server/src/DomainGatekeeper.cpp
@@ -535,9 +535,10 @@ void DomainGatekeeper::sendConnectionDeniedPacket(const QString& reason, const H
     // this is an agent and we've decided we won't let them connect - send them a packet to deny connection
     QByteArray utfString = reason.toUtf8();
     quint16 payloadSize = utfString.size();
-    
+   
     // setup the DomainConnectionDenied packet
-    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied);
+    auto connectionDeniedPacket = NLPacket::create(PacketType::DomainConnectionDenied, 
+                                                payloadSize + sizeof(payloadSize) + sizeof(uint8_t));
     
     // pack in the reason the connection was denied (the client displays this)
     if (payloadSize > 0) {
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index f3322caffb..48b418b93c 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -4594,7 +4594,7 @@ void Application::setSessionUUID(const QUuid& sessionUUID) const {
 
 
 // If we're not getting anything back from the domain server checkin, it might be that the domain speaks an 
-// older version of the DomainConnectRequest protocal. We will attempt to send and older version of DomainConnectRequest.
+// older version of the DomainConnectRequest protocol. We will attempt to send and older version of DomainConnectRequest.
 // We won't actually complete the connection, but if the server responds, we know that it needs to be upgraded (or we
 // need to be downgraded to talk to it).
 void Application::limitOfSilentDomainCheckInsReached() {

From ff45633c21ca3f9a496fa620e5fb7490968af874 Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Tue, 24 May 2016 17:36:52 -0700
Subject: [PATCH 11/14] bump entities version/CR feedback

---
 libraries/networking/src/udt/PacketHeaders.cpp | 2 +-
 libraries/networking/src/udt/PacketHeaders.h   | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/libraries/networking/src/udt/PacketHeaders.cpp b/libraries/networking/src/udt/PacketHeaders.cpp
index 9de149d32d..a960edbdc8 100644
--- a/libraries/networking/src/udt/PacketHeaders.cpp
+++ b/libraries/networking/src/udt/PacketHeaders.cpp
@@ -49,7 +49,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
         case PacketType::EntityAdd:
         case PacketType::EntityEdit:
         case PacketType::EntityData:
-            return VERSION_ENTITIES_NO_FLY_ZONES;
+            return VERSION_ENTITIES_MORE_SHAPES;
         case PacketType::AvatarData:
         case PacketType::BulkAvatarData:
             return static_cast<PacketVersion>(AvatarMixerPacketVersion::AvatarEntities);
diff --git a/libraries/networking/src/udt/PacketHeaders.h b/libraries/networking/src/udt/PacketHeaders.h
index b6237e74d6..a04a737c41 100644
--- a/libraries/networking/src/udt/PacketHeaders.h
+++ b/libraries/networking/src/udt/PacketHeaders.h
@@ -178,6 +178,7 @@ const PacketVersion VERSION_ENTITITES_HAVE_COLLISION_MASK = 55;
 const PacketVersion VERSION_ATMOSPHERE_REMOVED = 56;
 const PacketVersion VERSION_LIGHT_HAS_FALLOFF_RADIUS = 57;
 const PacketVersion VERSION_ENTITIES_NO_FLY_ZONES = 58;
+const PacketVersion VERSION_ENTITIES_MORE_SHAPES = 59;
 
 enum class AvatarMixerPacketVersion : PacketVersion {
     TranslationSupport = 17,

From ba77aaf7efdb0607001d9f2f6a16b8d03460f6e9 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Wed, 25 May 2016 11:06:08 -0700
Subject: [PATCH 12/14] remove collision of isPlaying property and slot

---
 libraries/script-engine/src/ScriptAudioInjector.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/script-engine/src/ScriptAudioInjector.h b/libraries/script-engine/src/ScriptAudioInjector.h
index 0d16b26fdf..4de12af62c 100644
--- a/libraries/script-engine/src/ScriptAudioInjector.h
+++ b/libraries/script-engine/src/ScriptAudioInjector.h
@@ -19,7 +19,7 @@
 class ScriptAudioInjector : public QObject {
     Q_OBJECT
     
-    Q_PROPERTY(bool isPlaying READ isPlaying)
+    Q_PROPERTY(bool playing READ isPlaying)
     Q_PROPERTY(float loudness READ getLoudness)
     Q_PROPERTY(AudioInjectorOptions options WRITE setOptions READ getOptions)
 public:

From 64720444cf4527f10eebb360018269af366cb72c Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Wed, 25 May 2016 11:11:06 -0700
Subject: [PATCH 13/14] correct existing uses of the isPlaying property

---
 script-archive/FlockOfbirds.js                | 84 +++++++++----------
 .../ACAudioSearchAndInject.js                 |  6 +-
 script-archive/avatarSelector.js              |  4 +-
 script-archive/baseball/baseballCrowd.js      |  4 +-
 script-archive/controllers/hydra/airGuitar.js | 17 ++--
 script-archive/drylake/ratCreator.js          |  2 +-
 script-archive/entityScripts/movable.js       | 58 ++++++-------
 script-archive/example/audio/birdSongs.js     | 40 ++++-----
 script-archive/lobby.js                       | 72 ++++++++--------
 script-archive/playTestSound.js               | 25 +++---
 10 files changed, 155 insertions(+), 157 deletions(-)

diff --git a/script-archive/FlockOfbirds.js b/script-archive/FlockOfbirds.js
index f466fa2909..c2fb54f0a6 100644
--- a/script-archive/FlockOfbirds.js
+++ b/script-archive/FlockOfbirds.js
@@ -3,8 +3,8 @@
 //  examples
 //
 //  Copyright 2014 High Fidelity, Inc.
-//  Creates a flock of birds that fly around and chirp, staying inside the corners of the box defined  
-//  at the start of the script. 
+//  Creates a flock of birds that fly around and chirp, staying inside the corners of the box defined
+//  at the start of the script.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -13,12 +13,12 @@
 //  The rectangular area in the domain where the flock will fly
 var lowerCorner = { x: 0, y: 0, z: 0 };
 var upperCorner = { x: 30, y: 10, z: 30  };
-var STARTING_FRACTION = 0.25;   
+var STARTING_FRACTION = 0.25;
 
 var NUM_BIRDS = 50;
 var UPDATE_INTERVAL = 0.016;
-var playSounds = true; 
-var SOUND_PROBABILITY = 0.001;  
+var playSounds = true;
+var SOUND_PROBABILITY = 0.001;
 var STARTING_LIFETIME = (1.0 / SOUND_PROBABILITY) * UPDATE_INTERVAL * 10;
 var numPlaying = 0;
 var BIRD_SIZE = 0.08;
@@ -36,17 +36,17 @@ var ALIGNMENT_FORCE = 1.5;
 var COHESION_FORCE = 1.0;
 var MAX_COHESION_VELOCITY = 0.5;
 
-var followBirds = false; 
+var followBirds = false;
 var AVATAR_FOLLOW_RATE = 0.001;
 var AVATAR_FOLLOW_VELOCITY_TIMESCALE = 2.0;
 var AVATAR_FOLLOW_ORIENTATION_RATE = 0.005;
-var floor = false; 
+var floor = false;
 var MAKE_FLOOR = false;
 
 var averageVelocity = { x: 0, y: 0, z: 0 };
 var averagePosition = { x: 0, y: 0, z: 0 };
 
-var birdsLoaded = false; 
+var birdsLoaded = false;
 
 var oldAvatarOrientation;
 var oldAvatarPosition;
@@ -79,10 +79,10 @@ function updateBirds(deltaTime) {
                 birds[i].entityId = false;
                 return;
             }
-            //  Sum up average position and velocity 
+            //  Sum up average position and velocity
             if (Vec3.length(properties.velocity) > MIN_ALIGNMENT_VELOCITY) {
                 sumVelocity = Vec3.sum(sumVelocity, properties.velocity);
-                birdVelocitiesCounted += 1;  
+                birdVelocitiesCounted += 1;
             }
             sumPosition = Vec3.sum(sumPosition, properties.position);
             birdPositionsCounted += 1;
@@ -93,10 +93,10 @@ function updateBirds(deltaTime) {
                 var randomVelocity = randomVector(RANDOM_FLAP_VELOCITY);
                 randomVelocity.y = FLAP_UP + Math.random() * FLAP_UP;
 
-                //  Alignment Velocity 
-                var alignmentVelocityMagnitude = Math.min(MAX_ALIGNMENT_VELOCITY, Vec3.length(Vec3.multiply(ALIGNMENT_FORCE, averageVelocity))); 
+                //  Alignment Velocity
+                var alignmentVelocityMagnitude = Math.min(MAX_ALIGNMENT_VELOCITY, Vec3.length(Vec3.multiply(ALIGNMENT_FORCE, averageVelocity)));
                 var alignmentVelocity = Vec3.multiply(alignmentVelocityMagnitude, Vec3.normalize(averageVelocity));
-                alignmentVelocity.y *= VERTICAL_ALIGNMENT_COUPLING; 
+                alignmentVelocity.y *= VERTICAL_ALIGNMENT_COUPLING;
 
                 //  Cohesion
                 var distanceFromCenter = Vec3.length(Vec3.subtract(averagePosition, properties.position));
@@ -107,10 +107,10 @@ function updateBirds(deltaTime) {
 
                 Entities.editEntity(birds[i].entityId, { velocity: Vec3.sum(properties.velocity, newVelocity) });
 
-            } 
+            }
 
             //  Check whether to play a chirp
-            if (playSounds && (!birds[i].audioId || !birds[i].audioId.isPlaying) && (Math.random() < ((numPlaying > 0) ? SOUND_PROBABILITY / numPlaying : SOUND_PROBABILITY))) {
+            if (playSounds && (!birds[i].audioId || !birds[i].audioId.playing) && (Math.random() < ((numPlaying > 0) ? SOUND_PROBABILITY / numPlaying : SOUND_PROBABILITY))) {
                 var options = {
                           position: properties.position,
                     volume: BIRD_MASTER_VOLUME
@@ -126,43 +126,43 @@ function updateBirds(deltaTime) {
                 // Change size, and update lifetime to keep bird alive
                 Entities.editEntity(birds[i].entityId, { dimensions: Vec3.multiply(1.5, properties.dimensions),
                                                          lifetime: properties.ageInSeconds + STARTING_LIFETIME});
-                
+
             } else if (birds[i].audioId) {
-                // If bird is playing a chirp 
-                if (!birds[i].audioId.isPlaying) {
+                // If bird is playing a chirp
+                if (!birds[i].audioId.playing) {
                     Entities.editEntity(birds[i].entityId, { dimensions: { x: BIRD_SIZE, y: BIRD_SIZE, z: BIRD_SIZE }});
                     numPlaying--;
-                } 
+                }
             }
 
             //  Keep birds in their 'cage'
             var bounce = false;
-            var newVelocity = properties.velocity;  
-            var newPosition = properties.position; 
+            var newVelocity = properties.velocity;
+            var newPosition = properties.position;
             if (properties.position.x < lowerCorner.x) {
-                newPosition.x = lowerCorner.x; 
+                newPosition.x = lowerCorner.x;
                 newVelocity.x *= -1.0;
                 bounce = true;
             } else if (properties.position.x > upperCorner.x) {
-                newPosition.x = upperCorner.x; 
+                newPosition.x = upperCorner.x;
                 newVelocity.x *= -1.0;
                 bounce = true;
             }
             if (properties.position.y < lowerCorner.y) {
-                newPosition.y = lowerCorner.y; 
+                newPosition.y = lowerCorner.y;
                 newVelocity.y *= -1.0;
                 bounce = true;
             } else if (properties.position.y > upperCorner.y) {
-                newPosition.y = upperCorner.y; 
+                newPosition.y = upperCorner.y;
                 newVelocity.y *= -1.0;
                 bounce = true;
-            } 
+            }
             if (properties.position.z < lowerCorner.z) {
-                newPosition.z = lowerCorner.z; 
+                newPosition.z = lowerCorner.z;
                 newVelocity.z *= -1.0;
                 bounce = true;
             } else if (properties.position.z > upperCorner.z) {
-                newPosition.z = upperCorner.z; 
+                newPosition.z = upperCorner.z;
                 newVelocity.z *= -1.0;
                 bounce = true;
             }
@@ -171,7 +171,7 @@ function updateBirds(deltaTime) {
             }
         }
     }
-    //  Update average velocity and position of flock 
+    //  Update average velocity and position of flock
     if (birdVelocitiesCounted > 0) {
         averageVelocity = Vec3.multiply(1.0 / birdVelocitiesCounted, sumVelocity);
         //print(Vec3.length(averageVelocity));
@@ -184,10 +184,10 @@ function updateBirds(deltaTime) {
                 MyAvatar.orientation = Quat.mix(MyAvatar.orientation, birdDirection, AVATAR_FOLLOW_ORIENTATION_RATE);
             }
         }
-    } 
+    }
     if (birdPositionsCounted > 0) {
         averagePosition = Vec3.multiply(1.0 / birdPositionsCounted, sumPosition);
-            //  If Following birds, update position 
+            //  If Following birds, update position
         if (followBirds) {
             MyAvatar.position = Vec3.sum(Vec3.multiply(AVATAR_FOLLOW_RATE, MyAvatar.position), Vec3.multiply(1.0 - AVATAR_FOLLOW_RATE, averagePosition));
         }
@@ -211,12 +211,12 @@ Script.scriptEnding.connect(function() {
 });
 
 function loadBirds(howMany) {
-    oldAvatarOrientation = MyAvatar.orientation; 
+    oldAvatarOrientation = MyAvatar.orientation;
     oldAvatarPosition = MyAvatar.position;
 
   var sound_filenames = ["bushtit_1.raw", "bushtit_2.raw", "bushtit_3.raw"];
   /* Here are more sounds/species you can use
-                        , "mexicanWhipoorwill.raw", 
+                        , "mexicanWhipoorwill.raw",
                            "rosyfacedlovebird.raw", "saysphoebe.raw", "westernscreechowl.raw", "bandtailedpigeon.wav", "bridledtitmouse.wav",
                            "browncrestedflycatcher.wav", "commonnighthawk.wav", "commonpoorwill.wav", "doublecrestedcormorant.wav",
                            "gambelsquail.wav", "goldcrownedkinglet.wav", "greaterroadrunner.wav","groovebilledani.wav","hairywoodpecker.wav",
@@ -252,19 +252,19 @@ function loadBirds(howMany) {
             { red: 216, green: 153, blue: 99 },
             { red: 242, green: 226, blue: 64 }
   ];
-  
+
   var SOUND_BASE_URL = "http://public.highfidelity.io/sounds/Animals/";
-  
+
   for (var i = 0; i < howMany; i++) {
     var whichBird = Math.floor(Math.random() * sound_filenames.length);
-    var position = { 
-        x: lowerCorner.x + (upperCorner.x - lowerCorner.x) / 2.0 + (Math.random() - 0.5) * (upperCorner.x - lowerCorner.x) * STARTING_FRACTION, 
-        y: lowerCorner.y + (upperCorner.y - lowerCorner.y) / 2.0 + (Math.random() - 0.5) * (upperCorner.y - lowerCorner.y) * STARTING_FRACTION, 
+    var position = {
+        x: lowerCorner.x + (upperCorner.x - lowerCorner.x) / 2.0 + (Math.random() - 0.5) * (upperCorner.x - lowerCorner.x) * STARTING_FRACTION,
+        y: lowerCorner.y + (upperCorner.y - lowerCorner.y) / 2.0 + (Math.random() - 0.5) * (upperCorner.y - lowerCorner.y) * STARTING_FRACTION,
         z: lowerCorner.z + (upperCorner.z - lowerCorner.x) / 2.0 + (Math.random() - 0.5) * (upperCorner.z - lowerCorner.z) * STARTING_FRACTION
-    }; 
+    };
 
     birds.push({
-        sound: SoundCache.getSound(SOUND_BASE_URL + sound_filenames[whichBird]), 
+        sound: SoundCache.getSound(SOUND_BASE_URL + sound_filenames[whichBird]),
         entityId: Entities.addEntity({
                     type: "Sphere",
                     position: position,
@@ -282,8 +282,8 @@ function loadBirds(howMany) {
     }
     if (MAKE_FLOOR) {
         var FLOOR_THICKNESS = 0.05;
-        floor = Entities.addEntity({ type: "Box", position: {   x: lowerCorner.x + (upperCorner.x - lowerCorner.x) / 2.0, 
-                                                                y: lowerCorner.y, 
+        floor = Entities.addEntity({ type: "Box", position: {   x: lowerCorner.x + (upperCorner.x - lowerCorner.x) / 2.0,
+                                                                y: lowerCorner.y,
                                                                 z: lowerCorner.z + (upperCorner.z - lowerCorner.z) / 2.0  },
                                                    dimensions: { x: (upperCorner.x - lowerCorner.x), y: FLOOR_THICKNESS, z: (upperCorner.z - lowerCorner.z)},
                                                    color: {red: 100, green: 100, blue: 100}
diff --git a/script-archive/audioExamples/acAudioSearching/ACAudioSearchAndInject.js b/script-archive/audioExamples/acAudioSearching/ACAudioSearchAndInject.js
index 381a7ee902..30567b4fc7 100644
--- a/script-archive/audioExamples/acAudioSearching/ACAudioSearchAndInject.js
+++ b/script-archive/audioExamples/acAudioSearching/ACAudioSearchAndInject.js
@@ -49,7 +49,7 @@ function debug() { // Display the arguments not just [Object object].
 EntityViewer.setCenterRadius(QUERY_RADIUS);
 
 // ENTITY DATA CACHE
-// 
+//
 var entityCache = {}; // A dictionary of unexpired EntityData objects.
 var examinationCount = 0;
 function EntityDatum(entityIdentifier) { // Just the data of an entity that we need to know about.
@@ -146,7 +146,7 @@ function EntityDatum(entityIdentifier) { // Just the data of an entity that we n
             return;
         }
         that.injector.setOptions(options);                                   // PLAYING => UPDATE POSITION ETC
-        if (!that.injector.isPlaying) { // Subtle: a looping sound will not check playbackGap.
+        if (!that.injector.playing) { // Subtle: a looping sound will not check playbackGap.
             if (repeat()) {                                                  // WAITING => PLAYING
                 // Setup next play just once, now. Changes won't be looked at while we wait.
                 that.playAfter = randomizedNextPlay();
@@ -208,7 +208,7 @@ function updateAllEntityData() { // A fast update of all entities we know about.
             stats.entities++;
             if (datum.url) {
                 stats.sounds++;
-                if (datum.injector && datum.injector.isPlaying) {
+                if (datum.injector && datum.injector.playing) {
                     stats.playing++;
                 }
             }
diff --git a/script-archive/avatarSelector.js b/script-archive/avatarSelector.js
index dc2916a1a8..47740ef0b3 100644
--- a/script-archive/avatarSelector.js
+++ b/script-archive/avatarSelector.js
@@ -283,7 +283,7 @@ function actionStartEvent(event) {
                 if (avatarIndex < avatars.length) {
                     var actionPlace = avatars[avatarIndex];
 
-                    print("Changing avatar to " + actionPlace.name 
+                    print("Changing avatar to " + actionPlace.name
                       + " after click on panel " + panelIndex + " with avatar index " + avatarIndex);
 
                     MyAvatar.useFullAvatarURL(actionPlace.content_url);
@@ -395,7 +395,7 @@ function update(deltaTime) {
         Overlays.editOverlay(descriptionText, { position: textOverlayPosition() });
 
         // if the reticle is up then we may need to play the next muzak
-        if (currentMuzakInjector && !currentMuzakInjector.isPlaying) {
+        if (currentMuzakInjector && !currentMuzakInjector.playing) {
             playNextMuzak();
         }
     }
diff --git a/script-archive/baseball/baseballCrowd.js b/script-archive/baseball/baseballCrowd.js
index de9b53f9ec..1459ce6e67 100644
--- a/script-archive/baseball/baseballCrowd.js
+++ b/script-archive/baseball/baseballCrowd.js
@@ -21,7 +21,7 @@ var CHATTER_VOLUME = 0.20
 var EXTRA_VOLUME = 0.25
 
 function playChatter() {
-    if (chatter.downloaded && !chatter.isPlaying) {
+    if (chatter.downloaded && !chatter.playing) {
         Audio.playSound(chatter, { loop: true, volume: CHATTER_VOLUME });
     }
 }
@@ -31,7 +31,7 @@ chatter.ready.connect(playChatter);
 var currentInjector = null;
 
 function playRandomExtras() {
-    if ((!currentInjector || !currentInjector.isPlaying) && (Math.random() < (1.0 / 1800.0))) {
+    if ((!currentInjector || !currentInjector.playing) && (Math.random() < (1.0 / 1800.0))) {
         // play a random extra sound about every 30s
         currentInjector = Audio.playSound(
             extras[Math.floor(Math.random() * extras.length)],
diff --git a/script-archive/controllers/hydra/airGuitar.js b/script-archive/controllers/hydra/airGuitar.js
index f8606808c1..73c7099eed 100644
--- a/script-archive/controllers/hydra/airGuitar.js
+++ b/script-archive/controllers/hydra/airGuitar.js
@@ -22,12 +22,12 @@ function printVector(v) {
     return;
 }
 
-function vMinus(a, b) { 
+function vMinus(a, b) {
     var rval = { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
     return rval;
 }
 
-//  The model file to be used for the guitar 
+//  The model file to be used for the guitar
 var guitarModel = HIFI_PUBLIC_BUCKET + "models/attachments/guitar.fst";
 
 //  Load sounds that will be played
@@ -47,7 +47,7 @@ chords[6] = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guitars/Guitar+-+Me
 chords[7] = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guitars/Guitar+-+Metal+E+short.raw");
 chords[8] = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guitars/Guitar+-+Metal+G+short.raw");
 
-//  Steel Guitar 
+//  Steel Guitar
 chords[9] = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guitars/Guitar+-+Steel+A.raw");
 chords[10] = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guitars/Guitar+-+Steel+B.raw");
 chords[11] = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guitars/Guitar+-+Steel+E.raw");
@@ -83,8 +83,8 @@ if (leftHanded) {
 }
 
 var lastPosition = { x: 0.0,
-                 y: 0.0, 
-                 z: 0.0 }; 
+                 y: 0.0,
+                 z: 0.0 };
 
 var audioInjector = null;
 var selectorPressed = false;
@@ -106,7 +106,7 @@ function checkHands(deltaTime) {
     var chord = Controller.getValue(chordTrigger);
 
     if (volume > 1.0) volume = 1.0;
-    if ((chord > 0.1) && audioInjector && audioInjector.isPlaying) {
+    if ((chord > 0.1) && audioInjector && audioInjector.playing) {
         // If chord finger trigger pulled, stop current chord
         print("stopping chord because cord trigger pulled");
         audioInjector.stop();
@@ -119,7 +119,7 @@ function checkHands(deltaTime) {
             guitarSelector += NUM_CHORDS;
             if (guitarSelector >= NUM_CHORDS * NUM_GUITARS) {
                 guitarSelector = 0;
-            } 
+            }
             print("new guitarBase: " + guitarSelector);
             stopAudio(true);
             selectorPressed = true;
@@ -160,7 +160,7 @@ function checkHands(deltaTime) {
 }
 
 function stopAudio(killInjector) {
-    if (audioInjector && audioInjector.isPlaying) {
+    if (audioInjector && audioInjector.playing) {
         print("stopped sound");
         audioInjector.stop();
     }
@@ -212,4 +212,3 @@ function scriptEnding() {
 Script.update.connect(checkHands);
 Script.scriptEnding.connect(scriptEnding);
 Controller.keyPressEvent.connect(keyPressEvent);
-
diff --git a/script-archive/drylake/ratCreator.js b/script-archive/drylake/ratCreator.js
index 60ccf1a1a3..6f6b322f84 100644
--- a/script-archive/drylake/ratCreator.js
+++ b/script-archive/drylake/ratCreator.js
@@ -340,7 +340,7 @@ function moveRats() {
         var metaRat = getMetaRatByRat(rat);
         if (metaRat !== undefined) {
             if (metaRat.injector !== undefined) {
-                if (metaRat.injector.isPlaying === true) {
+                if (metaRat.injector.playing === true) {
                     metaRat.injector.options = {
                         loop: true,
                         position: ratPosition
diff --git a/script-archive/entityScripts/movable.js b/script-archive/entityScripts/movable.js
index b7ecfbbc8e..06b30ce15e 100644
--- a/script-archive/entityScripts/movable.js
+++ b/script-archive/entityScripts/movable.js
@@ -8,7 +8,7 @@
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
-(function(){ 
+(function(){
 
     this.entityID = null;
     this.properties = null;
@@ -30,13 +30,13 @@
         "http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove2.wav",
         "http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove3.wav"
     ];
-    
+
     this.turnSoundURLS = [
 
         "http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove1.wav",
         "http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove2.wav",
         "http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove3.wav"
-    
+
         // TODO: determine if these or other turn sounds work better than move sounds.
         //"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureTurn1.wav",
         //"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureTurn2.wav",
@@ -50,7 +50,7 @@
     this.turnSound = null;
     this.moveInjector = null;
     this.turnInjector = null;
-    
+
     var debug = false;
     var displayRotateTargets = true; // change to false if you don't want the rotate targets
     var rotateOverlayTargetSize = 10000; // really big target
@@ -61,12 +61,12 @@
     var yawZero;
     var rotationNormal;
     var yawNormal;
-    var stopSoundDelay = 100; // number of msecs of not moving to have sound stop    
-    
+    var stopSoundDelay = 100; // number of msecs of not moving to have sound stop
+
     this.getRandomInt = function(min, max) {
         return Math.floor(Math.random() * (max - min + 1)) + min;
-    }    
-    
+    }
+
     this.downloadSounds = function() {
         for (var i = 0; i < this.moveSoundURLS.length; i++) {
             this.moveSounds[i] = SoundCache.getSound(this.moveSoundURLS[i]);
@@ -95,7 +95,7 @@
             if (debug) {
                 print("playMoveSound() --- calling this.moveInjector = Audio.playSound(this.moveSound...)");
             }
-            
+
             if (!this.moveInjector) {
                 this.moveInjector = Audio.playSound(this.moveSound, { position: this.properties.position, loop: true, volume: 0.1 });
             } else {
@@ -148,7 +148,7 @@
         var upVector = { x: 0, y: 1, z: 0 };
         var intersection = this.rayPlaneIntersection(pickRay.origin, pickRay.direction,
                                                      this.properties.position, upVector);
-                                                     
+
         var newPosition = Vec3.sum(intersection, this.graboffset);
         Entities.editEntity(this.entityID, { position: newPosition });
     };
@@ -158,7 +158,7 @@
         var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
         var upVector = { x: 0, y: 1, z: 0 };
         var intersection = this.rayPlaneIntersection(pickRay.origin, pickRay.direction,
-                                                     this.properties.position, upVector);                                 
+                                                     this.properties.position, upVector);
         this.graboffset = Vec3.subtract(this.properties.position, intersection);
     };
 
@@ -183,18 +183,18 @@
             this.lastMovedPosition.y = mouseEvent.y;
         }
     }
-        
+
     this.move = function(mouseEvent) {
         this.updatePosition(mouseEvent);
-        if (this.moveInjector === null || !this.moveInjector.isPlaying) {
+        if (this.moveInjector === null || !this.moveInjector.playing) {
             this.playMoveSound();
         }
     };
-    
+
     this.release = function(mouseEvent) {
         this.updatePosition(mouseEvent);
     };
-    
+
     this.rotate = function(mouseEvent) {
         var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
         var result = Overlays.findRayIntersection(pickRay);
@@ -205,7 +205,7 @@
             var centerToZero = Vec3.subtract(center, zero);
             var centerToIntersect = Vec3.subtract(center, result.intersection);
             var angleFromZero = Vec3.orientedAngle(centerToZero, centerToIntersect, rotationNormal);
-            
+
             var distanceFromCenter = Vec3.distance(center, result.intersection);
             var snapToInner = false;
             // var innerRadius = (Vec3.length(selectionManager.worldDimensions) / 2) * 1.1;
@@ -213,10 +213,10 @@
                 angleFromZero = Math.floor(angleFromZero/innerSnapAngle) * innerSnapAngle;
                 snapToInner = true;
             }
-            
+
             var yawChange = Quat.fromVec3Degrees({ x: 0, y: angleFromZero, z: 0 });
             Entities.editEntity(this.entityID, { rotation: Quat.multiply(yawChange, this.originalRotation) });
-            
+
 
             // update the rotation display accordingly...
             var startAtCurrent = 360-angleFromZero;
@@ -245,7 +245,7 @@
             }
         }
 
-        if (this.turnInjector === null || !this.turnInjector.isPlaying) {
+        if (this.turnInjector === null || !this.turnInjector.playing) {
             this.playTurnSound();
         }
     };
@@ -267,7 +267,7 @@
         this.rotateOverlayOuter = null;
         this.rotateOverlayCurrent = null;
     }
-    
+
     this.displayRotateOverlay = function(mouseEvent) {
         var yawOverlayAngles = { x: 90, y: 0, z: 0 };
         var yawOverlayRotation = Quat.fromVec3Degrees(yawOverlayAngles);
@@ -356,14 +356,14 @@
         var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
         var result = Overlays.findRayIntersection(pickRay);
         yawZero = result.intersection;
-                
+
     };
-    
+
     this.preload = function(entityID) {
         this.updateProperties(entityID); // All callbacks start by updating the properties
         this.downloadSounds();
     };
-    
+
     this.clickDownOnEntity = function(entityID, mouseEvent) {
         this.updateProperties(entityID); // All callbacks start by updating the properties
         this.grab(mouseEvent);
@@ -372,13 +372,13 @@
         var nowMSecs = nowDate.getTime();
         this.clickedAt = nowMSecs;
         this.firstHolding = true;
-        
+
         this.clicked.x = mouseEvent.x;
         this.clicked.y = mouseEvent.y;
         this.lastMovedPosition.x = mouseEvent.x;
         this.lastMovedPosition.y = mouseEvent.y;
         this.lastMovedMSecs = nowMSecs;
-        
+
         this.pickRandomSounds();
     };
 
@@ -391,7 +391,7 @@
             if (this.clicked.x == mouseEvent.x && this.clicked.y == mouseEvent.y) {
                 var d = new Date();
                 var now = d.getTime();
-        
+
                 if (now - this.clickedAt > 500) {
                     this.displayRotateOverlay(mouseEvent);
                     this.firstHolding = false;
@@ -402,13 +402,13 @@
                 this.firstHolding = false;
             }
         }
-        
+
         if (this.rotateMode) {
             this.rotate(mouseEvent);
         } else {
             this.move(mouseEvent);
         }
-        
+
         this.stopSoundIfNotMoving(mouseEvent);
     };
     this.clickReleaseOnEntity = function(entityID, mouseEvent) {
@@ -418,7 +418,7 @@
         } else {
             this.release(mouseEvent);
         }
-        
+
         if (this.rotateOverlayTarget != null) {
             this.cleanupRotateOverlay();
             this.rotateMode = false;
diff --git a/script-archive/example/audio/birdSongs.js b/script-archive/example/audio/birdSongs.js
index 557fc81f5b..9e949a19ed 100644
--- a/script-archive/example/audio/birdSongs.js
+++ b/script-archive/example/audio/birdSongs.js
@@ -22,7 +22,7 @@ var BIRD_VELOCITY = 2.0;
 var LIGHT_RADIUS = 10.0;
 var BIRD_MASTER_VOLUME = 0.5;
 
-var useLights = true; 
+var useLights = true;
 
 function randomVector(scale) {
     return { x: Math.random() * scale - scale / 2.0, y: Math.random() * scale - scale / 2.0, z: Math.random() * scale - scale / 2.0 };
@@ -33,11 +33,11 @@ function maybePlaySound(deltaTime) {
         //  Set the location and other info for the sound to play
         var whichBird = Math.floor(Math.random() * birds.length);
         //print("playing sound # " + whichBird);
-        var position = { 
-      x: lowerCorner.x + Math.random() * (upperCorner.x - lowerCorner.x), 
-        y: lowerCorner.y + Math.random() * (upperCorner.y - lowerCorner.y), 
-      z: lowerCorner.z + Math.random() * (upperCorner.z - lowerCorner.z) 
-    }; 
+        var position = {
+      x: lowerCorner.x + Math.random() * (upperCorner.x - lowerCorner.x),
+        y: lowerCorner.y + Math.random() * (upperCorner.y - lowerCorner.y),
+      z: lowerCorner.z + Math.random() * (upperCorner.z - lowerCorner.z)
+    };
         var options = {
           position: position,
       volume: BIRD_MASTER_VOLUME
@@ -63,31 +63,31 @@ function maybePlaySound(deltaTime) {
 
                 constantAttenuation: 0,
                 linearAttenuation: 4.0,
-                quadraticAttenuation: 2.0, 
+                quadraticAttenuation: 2.0,
                 lifetime: 10
             });
         }
-    
+
         playing.push({ audioId: Audio.playSound(birds[whichBird].sound, options), entityId: entityId, lightId: lightId, color: birds[whichBird].color });
     }
     if (playing.length != numPlaying) {
         numPlaying = playing.length;
         //print("number playing = " + numPlaying);
-    }     
+    }
     for (var i = 0; i < playing.length; i++) {
-        if (!playing[i].audioId.isPlaying) {
+        if (!playing[i].audioId.playing) {
             Entities.deleteEntity(playing[i].entityId);
             if (useLights) {
                 Entities.deleteEntity(playing[i].lightId);
-            }    
+            }
             playing.splice(i, 1);
         } else {
             var loudness = playing[i].audioId.loudness;
             var newColor = { red: playing[i].color.red, green: playing[i].color.green, blue: playing[i].color.blue };
             if (loudness > 0.05) {
-                newColor.red *= (1.0 - loudness); 
-                newColor.green *= (1.0 - loudness);  
-                newColor.blue *= (1.0 - loudness); 
+                newColor.red *= (1.0 - loudness);
+                newColor.green *= (1.0 - loudness);
+                newColor.blue *= (1.0 - loudness);
             }
             var properties = Entities.getEntityProperties(playing[i].entityId);
             var newPosition = Vec3.sum(properties.position, randomVector(BIRD_VELOCITY * deltaTime));
@@ -120,7 +120,7 @@ Script.scriptEnding.connect(function() {
 });
 
 function loadBirds() {
-  var sound_filenames = ["bushtit_1.raw", "bushtit_2.raw", "bushtit_3.raw", "mexicanWhipoorwill.raw", 
+  var sound_filenames = ["bushtit_1.raw", "bushtit_2.raw", "bushtit_3.raw", "mexicanWhipoorwill.raw",
                            "rosyfacedlovebird.raw", "saysphoebe.raw", "westernscreechowl.raw", "bandtailedpigeon.wav", "bridledtitmouse.wav",
                            "browncrestedflycatcher.wav", "commonnighthawk.wav", "commonpoorwill.wav", "doublecrestedcormorant.wav",
                            "gambelsquail.wav", "goldcrownedkinglet.wav", "greaterroadrunner.wav","groovebilledani.wav","hairywoodpecker.wav",
@@ -155,13 +155,13 @@ function loadBirds() {
             { red: 216, green: 153, blue: 99 },
             { red: 242, green: 226, blue: 64 }
   ];
-  
+
   var SOUND_BASE_URL = "http://public.highfidelity.io/sounds/Animals/";
-  
+
   for (var i = 0; i < sound_filenames.length; i++) {
       birds.push({
-        sound: SoundCache.getSound(SOUND_BASE_URL + sound_filenames[i]), 
-        color: colors[i] 
+        sound: SoundCache.getSound(SOUND_BASE_URL + sound_filenames[i]),
+        color: colors[i]
       });
   }
-}
\ No newline at end of file
+}
diff --git a/script-archive/lobby.js b/script-archive/lobby.js
index 3095740c93..6fa4a42cb6 100644
--- a/script-archive/lobby.js
+++ b/script-archive/lobby.js
@@ -88,19 +88,19 @@ var DRONE_VOLUME = 0.3;
 function drawLobby() {
   if (!panelWall) {
     print("Adding overlays for the lobby panel wall and orb shell.");
-    
+
     var cameraEuler = Quat.safeEulerAngles(Camera.orientation);
     var towardsMe = Quat.angleAxis(cameraEuler.y + 180, { x: 0, y: 1, z: 0});
-    
+
     var orbPosition = Vec3.sum(Camera.position, Vec3.multiplyQbyV(towardsMe, ORB_SHIFT));
-    
+
     var panelWallProps = {
       url: LOBBY_PANEL_WALL_URL,
       position: Vec3.sum(orbPosition, Vec3.multiplyQbyV(towardsMe, panelsCenterShift)),
       rotation: towardsMe,
       dimensions: panelsDimensions
     };
-    
+
     var orbShellProps = {
       url: LOBBY_SHELL_URL,
       position: orbPosition,
@@ -128,13 +128,13 @@ function drawLobby() {
         visible: false,
         isFacingAvatar: true
     };
-    
+
     avatarStickPosition = MyAvatar.position;
 
-    panelWall = Overlays.addOverlay("model", panelWallProps);    
+    panelWall = Overlays.addOverlay("model", panelWallProps);
     orbShell = Overlays.addOverlay("model", orbShellProps);
     descriptionText = Overlays.addOverlay("text3d", descriptionTextProps);
-    
+
     if (droneSound.downloaded) {
       // start the drone sound
       if (!currentDrone) {
@@ -143,7 +143,7 @@ function drawLobby() {
         currentDrone.restart();
       }
     }
-    
+
     // start one of our muzak sounds
     playRandomMuzak();
   }
@@ -157,31 +157,31 @@ function changeLobbyTextures() {
   req.send();
 
   places = JSON.parse(req.responseText).data.places;
-  
+
   var NUM_PANELS = places.length;
 
-  var textureProp = { 
+  var textureProp = {
     textures: {}
   };
-  
+
   for (var j = 0; j < NUM_PANELS; j++) {
     var panelIndex = placeIndexToPanelIndex(j);
     textureProp["textures"]["file" + panelIndex] = places[j].previews.lobby;
   };
-  
+
   Overlays.editOverlay(panelWall, textureProp);
 }
 
 var MUZAK_VOLUME = 0.1;
 
-function playCurrentSound(secondOffset) {  
+function playCurrentSound(secondOffset) {
   if (currentSound == latinSound) {
     if (!latinInjector) {
       latinInjector = Audio.playSound(latinSound, { localOnly: true, secondOffset: secondOffset, volume: MUZAK_VOLUME });
     } else {
       latinInjector.restart();
     }
-    
+
     currentMuzakInjector = latinInjector;
   } else if (currentSound == elevatorSound) {
     if (!elevatorInjector) {
@@ -189,7 +189,7 @@ function playCurrentSound(secondOffset) {
     } else {
       elevatorInjector.restart();
     }
-    
+
     currentMuzakInjector = elevatorInjector;
   }
 }
@@ -205,14 +205,14 @@ function playNextMuzak() {
         currentSound = latinSound;
       }
     }
-    
+
     playCurrentSound(0);
   }
 }
 
 function playRandomMuzak() {
   currentSound = null;
-  
+
   if (latinSound.downloaded && elevatorSound.downloaded) {
     currentSound = Math.random() < 0.5 ? latinSound : elevatorSound;
   } else if (latinSound.downloaded) {
@@ -220,11 +220,11 @@ function playRandomMuzak() {
   } else if (elevatorSound.downloaded) {
     currentSound = elevatorSound;
   }
-  
+
   if (currentSound) {
     // pick a random number of seconds from 0-10 to offset the muzak
     var secondOffset = Math.random() * 10;
-    
+
     playCurrentSound(secondOffset);
   } else {
     currentMuzakInjector = null;
@@ -233,36 +233,36 @@ function playRandomMuzak() {
 
 function cleanupLobby() {
   toggleEnvironmentRendering(true);
-  
+
   // for each of the 21 placeholder textures, set them back to default so the cached model doesn't have changed textures
   var panelTexturesReset = {};
   panelTexturesReset["textures"] = {};
-      
-  for (var j = 0; j < MAX_NUM_PANELS; j++) { 
+
+  for (var j = 0; j < MAX_NUM_PANELS; j++) {
     panelTexturesReset["textures"]["file" + (j + 1)] = LOBBY_BLANK_PANEL_TEXTURE_URL;
   };
-  
+
   Overlays.editOverlay(panelWall, panelTexturesReset);
-  
+
   Overlays.deleteOverlay(panelWall);
   Overlays.deleteOverlay(orbShell);
   Overlays.deleteOverlay(descriptionText);
-  
+
   panelWall = false;
   orbShell = false;
-  
+
   if (currentDrone) {
     currentDrone.stop();
     currentDrone = null
   }
-  
+
   if (currentMuzakInjector) {
     currentMuzakInjector.stop();
     currentMuzakInjector = null;
   }
-  
+
   places = {};
-  
+
 }
 
 function actionStartEvent(event) {
@@ -271,19 +271,19 @@ function actionStartEvent(event) {
     // check if we hit a panel and if we should jump there
     var result = Overlays.findRayIntersection(event.actionRay);
     if (result.intersects && result.overlayID == panelWall) {
-    
+
       var panelName = result.extraInfo;
-      
+
       var panelStringIndex = panelName.indexOf("Panel");
       if (panelStringIndex != -1) {
         var panelIndex = parseInt(panelName.slice(5));
         var placeIndex = panelIndexToPlaceIndex(panelIndex);
         if (placeIndex < places.length) {
           var actionPlace = places[placeIndex];
-          
-          print("Jumping to " + actionPlace.name + " at " + actionPlace.address 
+
+          print("Jumping to " + actionPlace.name + " at " + actionPlace.address
             + " after click on panel " + panelIndex + " with place index " + placeIndex);
-          
+
           Window.location = actionPlace.address;
           maybeCleanupLobby();
         }
@@ -328,7 +328,7 @@ function handleLookAt(pickRay) {
         var placeIndex = panelIndexToPlaceIndex(panelIndex);
         if (placeIndex < places.length) {
           var actionPlace = places[placeIndex];
-          
+
           if (actionPlace.description == "") {
               Overlays.editOverlay(descriptionText, { text: actionPlace.name, visible: showText });
           } else {
@@ -378,7 +378,7 @@ function update(deltaTime) {
     Overlays.editOverlay(descriptionText, { position: textOverlayPosition() });
 
     // if the reticle is up then we may need to play the next muzak
-    if (currentMuzakInjector && !currentMuzakInjector.isPlaying) {
+    if (currentMuzakInjector && !currentMuzakInjector.playing) {
       playNextMuzak();
     }
   }
diff --git a/script-archive/playTestSound.js b/script-archive/playTestSound.js
index 318df6a257..573c8879c4 100644
--- a/script-archive/playTestSound.js
+++ b/script-archive/playTestSound.js
@@ -2,12 +2,12 @@
 //  playTestSound.js
 //  examples
 //
-//  Created by Philip Rosedale 
+//  Created by Philip Rosedale
 //  Copyright 2014 High Fidelity, Inc.
 //
-//  Creates an object in front of you that changes color and plays a light 
-//  at the start of a drum clip that loops.   As you move away it will tell you in the 
-//  log how many meters you are from the source. 
+//  Creates an object in front of you that changes color and plays a light
+//  at the start of a drum clip that loops.   As you move away it will tell you in the
+//  log how many meters you are from the source.
 //
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
@@ -17,7 +17,7 @@ var sound = SoundCache.getSound("https://s3.amazonaws.com/hifi-public/sounds/Dru
 
 var position = Vec3.sum(Vec3.sum(MyAvatar.position, { x: 0, y: 0.5, z: 0 }), Quat.getFront(MyAvatar.orientation));
 
-var time; 
+var time;
 var soundPlaying = null;
 
 var baseColor = { red: 100, green: 100, blue: 100 };
@@ -38,8 +38,8 @@ var box = Entities.addEntity({
 
 function checkSound(deltaTime) {
   var started = false;
-    if (!sound.downloaded) { 
-      return; 
+    if (!sound.downloaded) {
+      return;
     }
     if (soundPlaying == null) {
         soundPlaying = Audio.playSound(sound, {
@@ -47,9 +47,9 @@ function checkSound(deltaTime) {
                                         volume: 1.0,
                                         loop: false } );
         started = true;
-    } else if (!soundPlaying.isPlaying) {
+    } else if (!soundPlaying.playing) {
         soundPlaying.restart();
-        started = true; 
+        started = true;
     }
     if (started) {
       Entities.editEntity(box, { color: litColor });
@@ -67,19 +67,19 @@ function checkSound(deltaTime) {
                     lifetime:  lightTime / 1000
                 });
       Script.setTimeout(resetColor, lightTime);
-    }  
+    }
     var currentDistance = Vec3.distance(MyAvatar.position, position);
     if (Math.abs(currentDistance - distance) > 1.0) {
       print("Distance from source: " + currentDistance);
       distance = currentDistance;
-    }   
+    }
 }
 
 function resetColor() {
    Entities.editEntity(box, { color: baseColor });
 }
 
-        
+
 function scriptEnding() {
   Entities.deleteEntity(box);
   if (soundPlaying) {
@@ -93,4 +93,3 @@ function scriptEnding() {
 // Connect a call back that happens every frame
 Script.scriptEnding.connect(scriptEnding);
 Script.update.connect(checkSound);
-

From 991da9e248338898b7ac582a5acaa81fd9d9e83e Mon Sep 17 00:00:00 2001
From: howard-stearns <howard.stearns@gmail.com>
Date: Thu, 26 May 2016 09:51:55 -0700
Subject: [PATCH 14/14] fix cut-paste error in settings.

---
 interface/src/avatar/MyAvatar.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 358b3d72ba..babbcfadbe 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -859,7 +859,7 @@ void MyAvatar::loadData() {
     setDisplayName(settings.value("displayName").toString());
     setCollisionSoundURL(settings.value("collisionSoundURL", DEFAULT_AVATAR_COLLISION_SOUND_URL).toString());
     setSnapTurn(settings.value("useSnapTurn", _useSnapTurn).toBool());
-    setSnapTurn(settings.value("clearOverlayWhenDriving", _clearOverlayWhenDriving).toBool());
+    setClearOverlayWhenDriving(settings.value("clearOverlayWhenDriving", _clearOverlayWhenDriving).toBool());
 
     settings.endGroup();