From 709ad849338bb764a8909b91b20c403c629d68ca Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Wed, 5 Nov 2014 23:44:59 +0100
Subject: [PATCH 01/38] added clone functionality to Overlays:
 Overlays.cloneOverlay(OverlayID)

---
 interface/src/ui/overlays/Base3DOverlay.cpp      | 11 +++++++++--
 interface/src/ui/overlays/Base3DOverlay.h        |  1 +
 interface/src/ui/overlays/BillboardOverlay.cpp   | 14 ++++++++++++++
 interface/src/ui/overlays/BillboardOverlay.h     |  4 ++++
 interface/src/ui/overlays/Circle3DOverlay.cpp    | 13 ++++++++-----
 interface/src/ui/overlays/Circle3DOverlay.h      |  4 ++++
 interface/src/ui/overlays/Cube3DOverlay.cpp      |  6 ++++++
 interface/src/ui/overlays/Cube3DOverlay.h        |  2 ++
 interface/src/ui/overlays/ImageOverlay.cpp       | 11 +++++++++++
 interface/src/ui/overlays/ImageOverlay.h         |  3 +++
 interface/src/ui/overlays/Line3DOverlay.cpp      | 11 +++++++++++
 interface/src/ui/overlays/Line3DOverlay.h        |  4 ++++
 interface/src/ui/overlays/LocalModelsOverlay.cpp |  6 ++++++
 interface/src/ui/overlays/LocalModelsOverlay.h   |  2 ++
 interface/src/ui/overlays/LocalVoxelsOverlay.cpp |  5 +++++
 interface/src/ui/overlays/LocalVoxelsOverlay.h   |  1 +
 interface/src/ui/overlays/ModelOverlay.cpp       |  6 +++++-
 interface/src/ui/overlays/ModelOverlay.h         |  2 ++
 interface/src/ui/overlays/Overlay.cpp            | 16 ++++++++++++++++
 interface/src/ui/overlays/Overlay.h              |  2 ++
 interface/src/ui/overlays/Overlay2D.cpp          |  5 +++++
 interface/src/ui/overlays/Overlay2D.h            |  1 +
 interface/src/ui/overlays/Overlays.cpp           | 10 ++++++++++
 interface/src/ui/overlays/Overlays.h             |  3 +++
 interface/src/ui/overlays/Planar3DOverlay.cpp    |  4 ++++
 interface/src/ui/overlays/Planar3DOverlay.h      |  1 +
 interface/src/ui/overlays/Rectangle3DOverlay.cpp | 11 +++++------
 interface/src/ui/overlays/Rectangle3DOverlay.h   |  2 ++
 interface/src/ui/overlays/Sphere3DOverlay.cpp    |  6 ++++++
 interface/src/ui/overlays/Sphere3DOverlay.h      |  2 ++
 interface/src/ui/overlays/Text3DOverlay.cpp      |  8 ++++++++
 interface/src/ui/overlays/Text3DOverlay.h        |  3 +++
 interface/src/ui/overlays/TextOverlay.cpp        |  8 ++++++++
 interface/src/ui/overlays/TextOverlay.h          |  2 ++
 interface/src/ui/overlays/Volume3DOverlay.cpp    |  4 ++++
 interface/src/ui/overlays/Volume3DOverlay.h      |  1 +
 36 files changed, 181 insertions(+), 14 deletions(-)

diff --git a/interface/src/ui/overlays/Base3DOverlay.cpp b/interface/src/ui/overlays/Base3DOverlay.cpp
index 89dd4d4b01..23634ac88c 100644
--- a/interface/src/ui/overlays/Base3DOverlay.cpp
+++ b/interface/src/ui/overlays/Base3DOverlay.cpp
@@ -155,5 +155,12 @@ void Base3DOverlay::drawDashedLine(const glm::vec3& start, const glm::vec3& end)
 
 }
 
-
-
+void Base3DOverlay::writeToClone(Base3DOverlay* clone) {
+    Overlay::writeToClone(clone);
+    clone->setPosition(getPosition());
+    clone->setLineWidth(getLineWidth());
+    clone->setIsSolid(getIsSolid());
+    clone->setIsDashedLine(getIsDashedLine());
+    clone->setRotation(getRotation());
+    clone->setIgnoreRayIntersection(getIgnoreRayIntersection());
+}
diff --git a/interface/src/ui/overlays/Base3DOverlay.h b/interface/src/ui/overlays/Base3DOverlay.h
index 75ce6b303d..430b235381 100644
--- a/interface/src/ui/overlays/Base3DOverlay.h
+++ b/interface/src/ui/overlays/Base3DOverlay.h
@@ -54,6 +54,7 @@ public:
     }
 
 protected:
+    virtual void writeToClone(Base3DOverlay* clone);
     void drawDashedLine(const glm::vec3& start, const glm::vec3& end);
 
     glm::vec3 _position;
diff --git a/interface/src/ui/overlays/BillboardOverlay.cpp b/interface/src/ui/overlays/BillboardOverlay.cpp
index c8d4877bb5..aec5e993dd 100644
--- a/interface/src/ui/overlays/BillboardOverlay.cpp
+++ b/interface/src/ui/overlays/BillboardOverlay.cpp
@@ -198,3 +198,17 @@ bool BillboardOverlay::findRayIntersection(const glm::vec3& origin, const glm::v
     return false;
 }
 
+BillboardOverlay* BillboardOverlay::createClone() {
+    BillboardOverlay* clone = new BillboardOverlay();
+    writeToClone(clone);
+    return clone;
+}
+
+void BillboardOverlay::writeToClone(BillboardOverlay* clone) {
+    Base3DOverlay::writeToClone(clone);
+    clone->setScale(_scale);
+    clone->setIsFacingAvatar(_isFacingAvatar);
+    clone->setClipFromSource(_fromImage);
+    clone->_url = _url;
+    clone->_billboard = QByteArray::QByteArray(_billboard);
+}
diff --git a/interface/src/ui/overlays/BillboardOverlay.h b/interface/src/ui/overlays/BillboardOverlay.h
index 018ca5f5cf..e71234c1c2 100644
--- a/interface/src/ui/overlays/BillboardOverlay.h
+++ b/interface/src/ui/overlays/BillboardOverlay.h
@@ -35,10 +35,14 @@ public:
 
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
     
+    virtual BillboardOverlay* createClone();
+
 private slots:
     void replyFinished();
 
 private:
+    virtual void writeToClone(BillboardOverlay* clone);
+
     void setBillboardURL(const QString& url);
     
     QString _url;
diff --git a/interface/src/ui/overlays/Circle3DOverlay.cpp b/interface/src/ui/overlays/Circle3DOverlay.cpp
index 144119c450..1a025e5a6f 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Circle3DOverlay.cpp
@@ -319,9 +319,12 @@ bool Circle3DOverlay::findRayIntersection(const glm::vec3& origin,
     return intersects;
 }
 
+Circle3DOverlay* Circle3DOverlay::createClone() {
+    Circle3DOverlay* clone = new Circle3DOverlay();
+    writeToClone(clone);
+    return clone;
+}
 
-
-
-
-
-
+void Circle3DOverlay::writeToClone(Circle3DOverlay* clone) {
+    Planar3DOverlay::writeToClone(clone);
+}
diff --git a/interface/src/ui/overlays/Circle3DOverlay.h b/interface/src/ui/overlays/Circle3DOverlay.h
index 191a0d3100..8437bb0850 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.h
+++ b/interface/src/ui/overlays/Circle3DOverlay.h
@@ -47,8 +47,12 @@ public:
     void setMinorTickMarksColor(const xColor& value) { _minorTickMarksColor = value; }
 
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+
+    virtual Circle3DOverlay* createClone();
     
 protected:
+    virtual void writeToClone(Circle3DOverlay* clone);
+
     float _startAt;
     float _endAt;
     float _outerRadius;
diff --git a/interface/src/ui/overlays/Cube3DOverlay.cpp b/interface/src/ui/overlays/Cube3DOverlay.cpp
index 81a2dfd498..9bf3de90c0 100644
--- a/interface/src/ui/overlays/Cube3DOverlay.cpp
+++ b/interface/src/ui/overlays/Cube3DOverlay.cpp
@@ -102,3 +102,9 @@ void Cube3DOverlay::render(RenderArgs* args) {
         delete glower;
     }
 }
+
+Cube3DOverlay* Cube3DOverlay::createClone() {
+    Cube3DOverlay* clone = new Cube3DOverlay();
+    writeToClone(clone);
+    return clone;
+}
diff --git a/interface/src/ui/overlays/Cube3DOverlay.h b/interface/src/ui/overlays/Cube3DOverlay.h
index 272d68bb5e..0b7b9e14a3 100644
--- a/interface/src/ui/overlays/Cube3DOverlay.h
+++ b/interface/src/ui/overlays/Cube3DOverlay.h
@@ -20,6 +20,8 @@ public:
     Cube3DOverlay();
     ~Cube3DOverlay();
     virtual void render(RenderArgs* args);
+
+    virtual Cube3DOverlay* createClone();
 };
 
  
diff --git a/interface/src/ui/overlays/ImageOverlay.cpp b/interface/src/ui/overlays/ImageOverlay.cpp
index 3b9d95af2e..04038834c2 100644
--- a/interface/src/ui/overlays/ImageOverlay.cpp
+++ b/interface/src/ui/overlays/ImageOverlay.cpp
@@ -151,4 +151,15 @@ void ImageOverlay::setProperties(const QScriptValue& properties) {
     }
 }
 
+ImageOverlay* ImageOverlay::createClone() {
+    ImageOverlay* clone = new ImageOverlay();
+    writeToClone(clone);
+    return clone;
+}
 
+void ImageOverlay::writeToClone(ImageOverlay* clone) {
+    Overlay2D::writeToClone(clone);
+    clone->_imageURL = _imageURL;
+    clone->_textureImage = _textureImage;
+    clone->_renderImage = _renderImage;
+}
diff --git a/interface/src/ui/overlays/ImageOverlay.h b/interface/src/ui/overlays/ImageOverlay.h
index ef1ead8c02..a3b88893ae 100644
--- a/interface/src/ui/overlays/ImageOverlay.h
+++ b/interface/src/ui/overlays/ImageOverlay.h
@@ -45,10 +45,13 @@ public:
     void setImageURL(const QUrl& url);
     virtual void setProperties(const QScriptValue& properties);
 
+    virtual ImageOverlay* createClone();
+
 private slots:
     void replyFinished(); // we actually want to hide this...
 
 private:
+    virtual void writeToClone(ImageOverlay* clone);
 
     QUrl _imageURL;
     QImage _textureImage;
diff --git a/interface/src/ui/overlays/Line3DOverlay.cpp b/interface/src/ui/overlays/Line3DOverlay.cpp
index 18671ea074..4f40d07b5f 100644
--- a/interface/src/ui/overlays/Line3DOverlay.cpp
+++ b/interface/src/ui/overlays/Line3DOverlay.cpp
@@ -79,3 +79,14 @@ void Line3DOverlay::setProperties(const QScriptValue& properties) {
         }
     }
 }
+
+Line3DOverlay* Line3DOverlay::createClone() {
+    Line3DOverlay* clone = new Line3DOverlay();
+    writeToClone(clone);
+    return clone;
+}
+
+
+void Line3DOverlay::writeToClone(Line3DOverlay* clone) {
+    Base3DOverlay::writeToClone(clone);
+}
diff --git a/interface/src/ui/overlays/Line3DOverlay.h b/interface/src/ui/overlays/Line3DOverlay.h
index f9c4e0d6d6..ce7320ff80 100644
--- a/interface/src/ui/overlays/Line3DOverlay.h
+++ b/interface/src/ui/overlays/Line3DOverlay.h
@@ -29,7 +29,11 @@ public:
 
     virtual void setProperties(const QScriptValue& properties);
 
+    virtual Line3DOverlay* createClone();
+
 protected:
+    virtual void writeToClone(Line3DOverlay* clone);
+
     glm::vec3 _end;
 };
 
diff --git a/interface/src/ui/overlays/LocalModelsOverlay.cpp b/interface/src/ui/overlays/LocalModelsOverlay.cpp
index c1f16bf13e..7f1faf3a39 100644
--- a/interface/src/ui/overlays/LocalModelsOverlay.cpp
+++ b/interface/src/ui/overlays/LocalModelsOverlay.cpp
@@ -48,3 +48,9 @@ void LocalModelsOverlay::render(RenderArgs* args) {
 
     }
 }
+
+LocalModelsOverlay* LocalModelsOverlay::createClone() {
+    LocalModelsOverlay* clone = new LocalModelsOverlay(Application::getInstance()->getEntityClipboardRenderer());
+    writeToClone(clone);
+    return clone;
+}
diff --git a/interface/src/ui/overlays/LocalModelsOverlay.h b/interface/src/ui/overlays/LocalModelsOverlay.h
index 60f09b8666..0659de0ab1 100644
--- a/interface/src/ui/overlays/LocalModelsOverlay.h
+++ b/interface/src/ui/overlays/LocalModelsOverlay.h
@@ -25,6 +25,8 @@ public:
     virtual void update(float deltatime);
     virtual void render(RenderArgs* args);
 
+    virtual LocalModelsOverlay* createClone();
+
 private:
     EntityTreeRenderer* _entityTreeRenderer;
 };
diff --git a/interface/src/ui/overlays/LocalVoxelsOverlay.cpp b/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
index dcfc79f3b4..09b74916c3 100644
--- a/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
+++ b/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
@@ -103,3 +103,8 @@ void LocalVoxelsOverlay::setProperties(const QScriptValue &properties) {
     }
 }
 
+LocalVoxelsOverlay* LocalVoxelsOverlay::createClone() {
+    LocalVoxelsOverlay* clone = new LocalVoxelsOverlay();
+    writeToClone(clone);
+    return clone;
+}
diff --git a/interface/src/ui/overlays/LocalVoxelsOverlay.h b/interface/src/ui/overlays/LocalVoxelsOverlay.h
index 46a88407af..9bd27e16bc 100644
--- a/interface/src/ui/overlays/LocalVoxelsOverlay.h
+++ b/interface/src/ui/overlays/LocalVoxelsOverlay.h
@@ -39,6 +39,7 @@ public:
     
     virtual void setProperties(const QScriptValue& properties);
     
+    virtual LocalVoxelsOverlay* createClone();
 private:
     static QMap<QString, WeakVoxelSystemPointer> _voxelSystemMap; // treeName/voxelSystem
     
diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index 150d40f15a..dc7506cc9e 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -135,4 +135,8 @@ bool ModelOverlay::findRayIntersectionExtraInfo(const glm::vec3& origin, const g
     return _model.findRayIntersectionAgainstSubMeshes(origin, direction, distance, face, extraInfo);
 }
 
-
+ModelOverlay* ModelOverlay::createClone() {
+    ModelOverlay* clone = new ModelOverlay();
+    writeToClone(clone);
+    return clone;
+}
diff --git a/interface/src/ui/overlays/ModelOverlay.h b/interface/src/ui/overlays/ModelOverlay.h
index 26471a79e1..43f9acc004 100644
--- a/interface/src/ui/overlays/ModelOverlay.h
+++ b/interface/src/ui/overlays/ModelOverlay.h
@@ -28,6 +28,8 @@ public:
     virtual bool findRayIntersectionExtraInfo(const glm::vec3& origin, const glm::vec3& direction, 
                                                     float& distance, BoxFace& face, QString& extraInfo) const;
 
+    virtual ModelOverlay* createClone();
+
 private:
     
     Model _model;
diff --git a/interface/src/ui/overlays/Overlay.cpp b/interface/src/ui/overlays/Overlay.cpp
index 215119374e..1e4bce02d0 100644
--- a/interface/src/ui/overlays/Overlay.cpp
+++ b/interface/src/ui/overlays/Overlay.cpp
@@ -173,3 +173,19 @@ float Overlay::updatePulse() {
     
     return _pulse;
 }
+
+void Overlay::writeToClone(Overlay* clone) {
+    clone->setAlpha(getAlpha());
+    clone->setAlphaPulse(getAlphaPulse());
+    clone->setAnchor(getAnchor());
+    clone->setColor(getColor());
+    clone->setColorPulse(getColorPulse());
+    clone->setGlowLevel(getGlowLevel());
+    clone->setGlowLevelPulse(getGlowLevelPulse());
+    clone->setPulseDirection(getPulseDirection());
+    clone->setPulseMax(getPulseMax());
+    clone->setPulseMin(getPulseMin());
+    clone->setPulsePeriod(getPulsePeriod());
+    clone->setVisible(getVisible());
+    clone->_isLoaded = _isLoaded;
+}
diff --git a/interface/src/ui/overlays/Overlay.h b/interface/src/ui/overlays/Overlay.h
index 81ddaf1a91..3a4322bd1d 100644
--- a/interface/src/ui/overlays/Overlay.h
+++ b/interface/src/ui/overlays/Overlay.h
@@ -77,8 +77,10 @@ public:
     void setAlphaPulse(float value) { _alphaPulse = value; }
 
     virtual void setProperties(const QScriptValue& properties);
+    virtual Overlay* createClone() = 0;
 
 protected:
+    virtual void writeToClone(Overlay* clone);
     float updatePulse();
 
     QGLWidget* _parent;
diff --git a/interface/src/ui/overlays/Overlay2D.cpp b/interface/src/ui/overlays/Overlay2D.cpp
index 0bdb8790cc..f8ff2ad2fc 100644
--- a/interface/src/ui/overlays/Overlay2D.cpp
+++ b/interface/src/ui/overlays/Overlay2D.cpp
@@ -64,3 +64,8 @@ void Overlay2D::setProperties(const QScriptValue& properties) {
         //qDebug() << "set bounds to " << getBounds();
     }
 }
+
+void Overlay2D::writeToClone(Overlay2D* clone) {
+    Overlay::writeToClone(clone);
+    clone->setBounds(getBounds());
+}
diff --git a/interface/src/ui/overlays/Overlay2D.h b/interface/src/ui/overlays/Overlay2D.h
index 283e7b7b23..49f22f1c4f 100644
--- a/interface/src/ui/overlays/Overlay2D.h
+++ b/interface/src/ui/overlays/Overlay2D.h
@@ -49,6 +49,7 @@ public:
     virtual void setProperties(const QScriptValue& properties);
 
 protected:
+    virtual void writeToClone(Overlay2D* clone);
     QRect _bounds; // where on the screen to draw
 };
 
diff --git a/interface/src/ui/overlays/Overlays.cpp b/interface/src/ui/overlays/Overlays.cpp
index df7a5fbcea..85a28057a8 100644
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@@ -190,6 +190,16 @@ unsigned int Overlays::addOverlay(Overlay* overlay) {
     return thisID;
 }
 
+unsigned int Overlays::cloneOverlay(unsigned int id) {
+    Overlay* thisOverlay = NULL;
+    if (_overlays2D.contains(id)) {
+        thisOverlay = _overlays2D[id];
+    } else if (_overlays3D.contains(id)) {
+        thisOverlay = _overlays3D[id];
+    }
+    return addOverlay(thisOverlay->createClone());
+}
+
 bool Overlays::editOverlay(unsigned int id, const QScriptValue& properties) {
     Overlay* thisOverlay = NULL;
     QWriteLocker lock(&_lock);
diff --git a/interface/src/ui/overlays/Overlays.h b/interface/src/ui/overlays/Overlays.h
index 686b998267..c5db1dfc7e 100644
--- a/interface/src/ui/overlays/Overlays.h
+++ b/interface/src/ui/overlays/Overlays.h
@@ -49,6 +49,9 @@ public slots:
     /// adds an overlay that's already been created
     unsigned int addOverlay(Overlay* overlay);
 
+    /// clones an existing overlay
+    unsigned int cloneOverlay(unsigned int id);
+
     /// edits an overlay updating only the included properties, will return the identified OverlayID in case of
     /// successful edit, if the input id is for an unknown overlay this function will have no effect
     bool editOverlay(unsigned int id, const QScriptValue& properties);
diff --git a/interface/src/ui/overlays/Planar3DOverlay.cpp b/interface/src/ui/overlays/Planar3DOverlay.cpp
index 91a3a023f7..d2222f9051 100644
--- a/interface/src/ui/overlays/Planar3DOverlay.cpp
+++ b/interface/src/ui/overlays/Planar3DOverlay.cpp
@@ -102,3 +102,7 @@ bool Planar3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::ve
     }
     return intersects;
 }
+
+void Planar3DOverlay::writeToClone(Planar3DOverlay* clone) {
+    Base3DOverlay::writeToClone(clone);
+}
diff --git a/interface/src/ui/overlays/Planar3DOverlay.h b/interface/src/ui/overlays/Planar3DOverlay.h
index ee4bb3e05a..a938d6a4e5 100644
--- a/interface/src/ui/overlays/Planar3DOverlay.h
+++ b/interface/src/ui/overlays/Planar3DOverlay.h
@@ -40,6 +40,7 @@ public:
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
 
 protected:
+    virtual void writeToClone(Planar3DOverlay* clone);
     glm::vec2 _dimensions;
 };
 
diff --git a/interface/src/ui/overlays/Rectangle3DOverlay.cpp b/interface/src/ui/overlays/Rectangle3DOverlay.cpp
index c131a139ac..728accfad6 100644
--- a/interface/src/ui/overlays/Rectangle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Rectangle3DOverlay.cpp
@@ -106,9 +106,8 @@ void Rectangle3DOverlay::setProperties(const QScriptValue &properties) {
     Planar3DOverlay::setProperties(properties);
 }
 
-
-
-
-
-
-
+Rectangle3DOverlay* Rectangle3DOverlay::createClone() {
+    Rectangle3DOverlay* clone = new Rectangle3DOverlay();
+    writeToClone(clone);
+    return clone;
+}
diff --git a/interface/src/ui/overlays/Rectangle3DOverlay.h b/interface/src/ui/overlays/Rectangle3DOverlay.h
index 9cec6da7e7..0bb805200c 100644
--- a/interface/src/ui/overlays/Rectangle3DOverlay.h
+++ b/interface/src/ui/overlays/Rectangle3DOverlay.h
@@ -21,6 +21,8 @@ public:
     ~Rectangle3DOverlay();
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
+
+    virtual Rectangle3DOverlay* createClone();
 };
 
  
diff --git a/interface/src/ui/overlays/Sphere3DOverlay.cpp b/interface/src/ui/overlays/Sphere3DOverlay.cpp
index 63ed3e8d7e..ef4e2ba51b 100644
--- a/interface/src/ui/overlays/Sphere3DOverlay.cpp
+++ b/interface/src/ui/overlays/Sphere3DOverlay.cpp
@@ -70,3 +70,9 @@ void Sphere3DOverlay::render(RenderArgs* args) {
     }
 
 }
+
+Sphere3DOverlay* Sphere3DOverlay::createClone() {
+    Sphere3DOverlay* clone = new Sphere3DOverlay();
+    writeToClone(clone);
+    return clone;
+}
diff --git a/interface/src/ui/overlays/Sphere3DOverlay.h b/interface/src/ui/overlays/Sphere3DOverlay.h
index 98776a3f57..f9db6b99af 100644
--- a/interface/src/ui/overlays/Sphere3DOverlay.h
+++ b/interface/src/ui/overlays/Sphere3DOverlay.h
@@ -20,6 +20,8 @@ public:
     Sphere3DOverlay();
     ~Sphere3DOverlay();
     virtual void render(RenderArgs* args);
+
+    virtual Sphere3DOverlay* createClone();
 };
 
  
diff --git a/interface/src/ui/overlays/Text3DOverlay.cpp b/interface/src/ui/overlays/Text3DOverlay.cpp
index d8febbf0eb..a19bd097a4 100644
--- a/interface/src/ui/overlays/Text3DOverlay.cpp
+++ b/interface/src/ui/overlays/Text3DOverlay.cpp
@@ -179,4 +179,12 @@ void Text3DOverlay::setProperties(const QScriptValue& properties) {
 
 }
 
+Text3DOverlay* Text3DOverlay::createClone() {
+    Text3DOverlay* clone = new Text3DOverlay();
+    writeToClone(clone);
+    return clone;
+}
 
+void Text3DOverlay::writeToClone(Text3DOverlay* clone) {
+    Planar3DOverlay::writeToClone(clone);
+}
diff --git a/interface/src/ui/overlays/Text3DOverlay.h b/interface/src/ui/overlays/Text3DOverlay.h
index 45e311c554..00b7f0ebb6 100644
--- a/interface/src/ui/overlays/Text3DOverlay.h
+++ b/interface/src/ui/overlays/Text3DOverlay.h
@@ -48,7 +48,10 @@ public:
 
     virtual void setProperties(const QScriptValue& properties);
 
+    virtual Text3DOverlay* createClone();
+
 private:
+    virtual void writeToClone(Text3DOverlay* clone);
     void enableClipPlane(GLenum plane, float x, float y, float z, float w);
 
     QString _text;
diff --git a/interface/src/ui/overlays/TextOverlay.cpp b/interface/src/ui/overlays/TextOverlay.cpp
index 530b30a856..f09306c4fa 100644
--- a/interface/src/ui/overlays/TextOverlay.cpp
+++ b/interface/src/ui/overlays/TextOverlay.cpp
@@ -125,4 +125,12 @@ void TextOverlay::setProperties(const QScriptValue& properties) {
     }
 }
 
+TextOverlay* TextOverlay::createClone() {
+    TextOverlay* clone = new TextOverlay();
+    writeToClone(clone);
+    return clone;
+}
 
+void TextOverlay::writeToClone(TextOverlay* clone) {
+    Overlay2D::writeToClone(clone);
+}
diff --git a/interface/src/ui/overlays/TextOverlay.h b/interface/src/ui/overlays/TextOverlay.h
index f7ff83e542..cb519e3ffc 100644
--- a/interface/src/ui/overlays/TextOverlay.h
+++ b/interface/src/ui/overlays/TextOverlay.h
@@ -52,8 +52,10 @@ public:
     void setFontSize(int fontSize) { _fontSize = fontSize; }
 
     virtual void setProperties(const QScriptValue& properties);
+    virtual TextOverlay* createClone();
 
 private:
+    virtual void writeToClone(TextOverlay* clone);
 
     QString _text;
     xColor _backgroundColor;
diff --git a/interface/src/ui/overlays/Volume3DOverlay.cpp b/interface/src/ui/overlays/Volume3DOverlay.cpp
index cc12d41e2e..24696c8017 100644
--- a/interface/src/ui/overlays/Volume3DOverlay.cpp
+++ b/interface/src/ui/overlays/Volume3DOverlay.cpp
@@ -108,3 +108,7 @@ bool Volume3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::ve
     }
     return false;
 }
+
+void Volume3DOverlay::writeToClone(Volume3DOverlay* clone) {
+    Base3DOverlay::writeToClone(clone);
+}
diff --git a/interface/src/ui/overlays/Volume3DOverlay.h b/interface/src/ui/overlays/Volume3DOverlay.h
index 7cde169c30..94dd463bdf 100644
--- a/interface/src/ui/overlays/Volume3DOverlay.h
+++ b/interface/src/ui/overlays/Volume3DOverlay.h
@@ -42,6 +42,7 @@ public:
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
 
 protected:
+    virtual void writeToClone(Volume3DOverlay* clone);
     glm::vec3 _dimensions;
 };
 

From d3d80d3fe20759f2563b730ff9067bb9b259dce5 Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Thu, 6 Nov 2014 00:34:59 +0100
Subject: [PATCH 02/38] filled in the rest of the properties

---
 interface/src/ui/overlays/Circle3DOverlay.cpp | 11 +++++++++++
 interface/src/ui/overlays/ImageOverlay.cpp    |  2 +-
 interface/src/ui/overlays/Line3DOverlay.cpp   |  1 +
 interface/src/ui/overlays/ModelOverlay.cpp    | 12 ++++++++++++
 interface/src/ui/overlays/ModelOverlay.h      |  3 ++-
 interface/src/ui/overlays/Planar3DOverlay.cpp |  1 +
 interface/src/ui/overlays/Text3DOverlay.cpp   |  8 ++++++++
 interface/src/ui/overlays/TextOverlay.cpp     |  5 +++++
 8 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/interface/src/ui/overlays/Circle3DOverlay.cpp b/interface/src/ui/overlays/Circle3DOverlay.cpp
index 1a025e5a6f..378c59a00e 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Circle3DOverlay.cpp
@@ -327,4 +327,15 @@ Circle3DOverlay* Circle3DOverlay::createClone() {
 
 void Circle3DOverlay::writeToClone(Circle3DOverlay* clone) {
     Planar3DOverlay::writeToClone(clone);
+    clone->setStartAt(getStartAt());
+    clone->setEndAt(getEndAt());
+    clone->setOuterRadius(getOuterRadius());
+    clone->setInnerRadius(getInnerRadius());
+    clone->setHasTickMarks(getHasTickMarks());
+    clone->setMajorTickMarksAngle(getMajorTickMarksAngle());
+    clone->setMinorTickMarksAngle(getMinorTickMarksAngle());
+    clone->setMajorTickMarksLength(getMajorTickMarksLength());
+    clone->setMinorTickMarksLength(getMinorTickMarksLength());
+    clone->setMajorTickMarksColor(getMajorTickMarksColor());
+    clone->setMinorTickMarksColor(getMinorTickMarksColor());
 }
diff --git a/interface/src/ui/overlays/ImageOverlay.cpp b/interface/src/ui/overlays/ImageOverlay.cpp
index 04038834c2..6c2b09018e 100644
--- a/interface/src/ui/overlays/ImageOverlay.cpp
+++ b/interface/src/ui/overlays/ImageOverlay.cpp
@@ -160,6 +160,6 @@ ImageOverlay* ImageOverlay::createClone() {
 void ImageOverlay::writeToClone(ImageOverlay* clone) {
     Overlay2D::writeToClone(clone);
     clone->_imageURL = _imageURL;
-    clone->_textureImage = _textureImage;
+    clone->_textureImage = QImage::QImage(_textureImage);
     clone->_renderImage = _renderImage;
 }
diff --git a/interface/src/ui/overlays/Line3DOverlay.cpp b/interface/src/ui/overlays/Line3DOverlay.cpp
index 4f40d07b5f..d4c48fbc3e 100644
--- a/interface/src/ui/overlays/Line3DOverlay.cpp
+++ b/interface/src/ui/overlays/Line3DOverlay.cpp
@@ -89,4 +89,5 @@ Line3DOverlay* Line3DOverlay::createClone() {
 
 void Line3DOverlay::writeToClone(Line3DOverlay* clone) {
     Base3DOverlay::writeToClone(clone);
+    clone->setEnd(getEnd());
 }
diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index dc7506cc9e..6d49bf3df9 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -140,3 +140,15 @@ ModelOverlay* ModelOverlay::createClone() {
     writeToClone(clone);
     return clone;
 }
+
+void ModelOverlay::writeToClone(ModelOverlay* clone) {
+    Base3DOverlay::writeToClone(clone);
+    clone->_url = _url;
+    if (clone->_url.isValid()) {
+        clone->_updateModel = true;
+        clone->_isLoaded = false;
+    }
+    clone->_rotation = _rotation;
+    clone->_scale = _scale;
+    clone->_updateModel = _updateModel;
+}
diff --git a/interface/src/ui/overlays/ModelOverlay.h b/interface/src/ui/overlays/ModelOverlay.h
index 43f9acc004..50b14a8ff7 100644
--- a/interface/src/ui/overlays/ModelOverlay.h
+++ b/interface/src/ui/overlays/ModelOverlay.h
@@ -31,7 +31,8 @@ public:
     virtual ModelOverlay* createClone();
 
 private:
-    
+    virtual void writeToClone(ModelOverlay* clone);
+
     Model _model;
     
     QUrl _url;
diff --git a/interface/src/ui/overlays/Planar3DOverlay.cpp b/interface/src/ui/overlays/Planar3DOverlay.cpp
index d2222f9051..e14d45773c 100644
--- a/interface/src/ui/overlays/Planar3DOverlay.cpp
+++ b/interface/src/ui/overlays/Planar3DOverlay.cpp
@@ -105,4 +105,5 @@ bool Planar3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::ve
 
 void Planar3DOverlay::writeToClone(Planar3DOverlay* clone) {
     Base3DOverlay::writeToClone(clone);
+    clone->setDimensions(getDimensions());
 }
diff --git a/interface/src/ui/overlays/Text3DOverlay.cpp b/interface/src/ui/overlays/Text3DOverlay.cpp
index a19bd097a4..9ab8e0f82d 100644
--- a/interface/src/ui/overlays/Text3DOverlay.cpp
+++ b/interface/src/ui/overlays/Text3DOverlay.cpp
@@ -187,4 +187,12 @@ Text3DOverlay* Text3DOverlay::createClone() {
 
 void Text3DOverlay::writeToClone(Text3DOverlay* clone) {
     Planar3DOverlay::writeToClone(clone);
+    clone->setText(getText());
+    clone->setLineHeight(getLineHeight());
+    clone->setLeftMargin(getLeftMargin());
+    clone->setTopMargin(getTopMargin());
+    clone->setRightMargin(getRightMargin());
+    clone->setBottomMargin(getBottomMargin());
+    clone->setIsFacingAvatar(getIsFacingAvatar());
+    clone->_backgroundColor = getBackgroundColor();
 }
diff --git a/interface/src/ui/overlays/TextOverlay.cpp b/interface/src/ui/overlays/TextOverlay.cpp
index f09306c4fa..29dc06ab64 100644
--- a/interface/src/ui/overlays/TextOverlay.cpp
+++ b/interface/src/ui/overlays/TextOverlay.cpp
@@ -133,4 +133,9 @@ TextOverlay* TextOverlay::createClone() {
 
 void TextOverlay::writeToClone(TextOverlay* clone) {
     Overlay2D::writeToClone(clone);
+    clone->_text = QString::QString(_text);
+    clone->_backgroundColor = _backgroundColor;
+    clone->_leftMargin = _leftMargin;
+    clone->_topMargin = _topMargin;
+    clone->_fontSize = _fontSize;
 }

From 450e89df21fd5c56565342089d087694a6413420 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Mon, 10 Nov 2014 08:23:42 -0800
Subject: [PATCH 03/38] playChess script

---
 examples/playChess.js | 169 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 169 insertions(+)
 create mode 100644 examples/playChess.js

diff --git a/examples/playChess.js b/examples/playChess.js
new file mode 100644
index 0000000000..660280c8f2
--- /dev/null
+++ b/examples/playChess.js
@@ -0,0 +1,169 @@
+//
+//  playChess.js
+//  examples
+//
+//  Created by Clement Brisset on 11/08/2014
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+
+// Script namespace
+var extraDebug = extraDebug || true;
+var ChessGame = ChessGame || {
+  BOARD_SIZE: 8,
+  MAX_PLAYERS: 2,
+  ROWS: ['1', '2', '3', '4', '5', '6', '7', '8'],
+  COLUMNS: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
+  
+  whitesTileColor: {red: 250, green: 195, blue: 135},
+  blacksTileColor: {red: 190, green: 115, blue: 50},
+  whiteKingURL: "http://public.highfidelity.io/models/attachments/King Piece.fst",
+  whiteKingDimensions: { x: 0.46, y: 1.0, z: 0.46 },
+  blackKingURL: "http://public.highfidelity.io/models/attachments/King Piece.fst",
+  blackKingDimensions: { x: 0.46, y: 1.0, z: 0.46 },
+  
+  board: null,
+  pieces: null
+};
+
+
+// Board class
+ChessGame.Board = (function(position, size) {
+  this.position = position;
+  this.size = size;
+  this.tileSize = this.size / ChessGame.BOARD_SIZE;
+  this.height = this.tileSize * 0.2;
+  this.tiles = new Array();
+  
+  this.spawn();
+});
+// Applies operation to each tile where operation = function(i, j)
+ChessGame.Board.prototype.apply = function(operation) {
+  for (var i = 0; i < ChessGame.BOARD_SIZE; i++) {
+    for (var j = 0; j < ChessGame.BOARD_SIZE; j++) {
+      operation.call(this, i, j);
+    } 
+  }
+}
+// Returns tile position
+ChessGame.Board.prototype.tilePosition = function(i, j) {
+  return { x: this.position.x + i * this.tileSize,
+           y: this.position.y,
+           z: this.position.z + j * this.tileSize };
+}
+// Checks the color of the tile
+ChessGame.Board.prototype.isWhite = function(x, y) {
+  return (x + y) % 2 != 0;
+}
+// Spawns the board using entities
+ChessGame.Board.prototype.spawn = function() {
+  if (extraDebug) {
+    print("Spawning board...");
+  }
+  
+  this.apply(function(i, j) {
+    var tile = Entities.addEntity({
+      type: "Box",
+      position: this.tilePosition(i, j),
+      dimensions: { x: this.tileSize, y: this.height, z: this.tileSize },
+      color: (this.isWhite(i, j)) ? ChessGame.whitesTileColor : ChessGame.blacksTileColor
+    });
+    
+    if (j === 0) {
+      // Create new row if needed
+      this.tiles.push(new Array());
+    }
+    this.tiles[i].push(tile); // Store tile
+  });
+  print("Board spawned");
+}
+// Cleans up the entities of the board
+ChessGame.Board.prototype.cleanup = function() {
+  if (extraDebug) {
+    print("Cleaning up board...");
+  }
+  
+  this.apply(function(i, j) {
+    Entities.deleteEntity(this.tiles[i][j]);
+  });
+  print("Board cleaned up");
+}
+
+// Piece class
+ChessGame.Piece = (function(position, size, url) {
+  this.position = position;
+  this.size = size;
+  this.entityProperties = {
+    type: "Model",
+    position: this.position,
+    dimensions: this.size,
+    modelURL: url
+  }
+  this.entity = null;
+});
+// Spawns the piece
+ChessGame.Piece.prototype.spawn = function() {
+  this.entity = Entities.addEntity(this.entityProperties);
+}
+// Cleans up the piece
+ChessGame.Piece.prototype.cleanup = function() {
+  Entities.deleteEntity(this.entity);
+}
+
+
+
+
+// Player class
+ChessGame.Player = (function() {
+  
+});
+
+ChessGame.update = function() {
+  
+}
+
+ChessGame.scriptStarting = function() {
+  print("playChess.js started");
+  ChessGame.board = new ChessGame.Board({ x: 1, y: 1, z: 1 }, 1);
+  ChessGame.pieces = new Array();
+
+  var url = "http://public.highfidelity.io/models/attachments/King Piece.fst";
+  var dimensions = { x: 0.46, y: 1.0, z: 0.46 };
+  
+  var rowsIndex = [0, 1, 6, 7];
+  for(var i in rowsIndex) {
+    for(var j = 0; j < ChessGame.BOARD_SIZE; j++) {
+      var size = Vec3.multiply(dimensions, ChessGame.board.tileSize);
+      if (rowsIndex[i] == 1 || rowsIndex[i] == 6) {
+        size = Vec3.multiply(size, 0.7);
+      }
+      var position = Vec3.sum(ChessGame.board.tilePosition(rowsIndex[i], j),
+                              { x: 0, y: (size.y + ChessGame.board.height) / 2.0, z: 0});
+      var color = (rowsIndex[i] < 4) ? ChessGame.whitesTileColor : ChessGame.blacksTileColor;
+      
+      var piece = new ChessGame.Piece(position, size, url);
+      piece.spawn();
+      ChessGame.pieces.push(piece);
+    }
+  }
+}
+
+ChessGame.scriptEnding = function() {
+  // Cleaning up board
+  ChessGame.board.cleanup();
+  delete ChessGame.board;
+  
+  // Cleaning up pieces
+  for(var i in ChessGame.pieces) {
+    ChessGame.pieces[i].cleanup();
+  }
+  delete ChessGame.pieces;
+  
+  print("playChess.js finished");
+}
+
+
+Script.update.connect(ChessGame.update)
+Script.scriptEnding.connect(ChessGame.scriptEnding);
+ChessGame.scriptStarting();
\ No newline at end of file

From ba67b042793fe55b14e44dbcd9e901a2b15eff2d Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Mon, 10 Nov 2014 10:18:37 -0800
Subject: [PATCH 04/38] Switch members in EntityItemProperties to hack around
 corruption bug

---
 libraries/entities/src/EntityItemProperties.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/entities/src/EntityItemProperties.h b/libraries/entities/src/EntityItemProperties.h
index 3ae2aa9c7a..6b22e8cba9 100644
--- a/libraries/entities/src/EntityItemProperties.h
+++ b/libraries/entities/src/EntityItemProperties.h
@@ -383,8 +383,8 @@ private:
     // NOTE: The following are pseudo client only properties. They are only used in clients which can access
     // properties of model geometry. But these properties are not serialized like other properties.
     QVector<SittingPoint> _sittingPoints;
-    glm::vec3 _naturalDimensions;
     QStringList _textureNames;
+    glm::vec3 _naturalDimensions;
 };
 Q_DECLARE_METATYPE(EntityItemProperties);
 QScriptValue EntityItemPropertiesToScriptValue(QScriptEngine* engine, const EntityItemProperties& properties);

From e4975c0e2bae6f72152727988421e1b1df1f94ba Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Tue, 11 Nov 2014 17:08:35 -0800
Subject: [PATCH 05/38] chessPiece script with sound

---
 examples/entityScripts/chessPiece.js | 77 ++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 examples/entityScripts/chessPiece.js

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
new file mode 100644
index 0000000000..5342e9cd4f
--- /dev/null
+++ b/examples/entityScripts/chessPiece.js
@@ -0,0 +1,77 @@
+(function(){
+  this.sound = null;
+  this.entityID = null;
+  this.properties = null;
+  this.updateProperties = function(entityID) {
+    if (this.entityID === null) {
+      this.entityID = entityID;
+      print("entityID=" + JSON.stringify(this.entityID));
+    }
+    if (!entityID.isKnownID || this.entityID.id !== entityID.id) {
+      print("Something is very wrong: Bailing!");
+      return;
+    }
+    this.properties = Entities.getEntityProperties(this.entityID);
+    if (!this.properties.isKnownID) {
+      print("Unknown entityID " + this.entityID.id + " should be self.")
+    } 
+  }
+  this.updatePosition = function(mouseEvent) {
+    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);
+    Entities.editEntity(this.entityID, { position: intersection });
+  }
+  this.snapToGrid = function() {
+    var position = { x: 1, y: 1, z: 1 };
+    var size = 1.0;
+    var tileSize = size / 8.0;
+    var height = tileSize * 0.2;
+
+    
+    var relative = Vec3.subtract(this.properties.position, position);
+    var i = Math.floor(relative.x / tileSize);
+    var j = Math.floor(relative.z / tileSize);
+    
+    relative.x = (i + 0.5) * tileSize;
+    relative.z = (j + 0.5) * tileSize;
+    var finalPos = Vec3.sum(position, relative);
+    Entities.editEntity(this.entityID, { position: finalPos });
+  }
+  // Pr, Vr are respectively the Ray's Point of origin and Vector director
+  // Pp, Np are respectively the Plane's Point of origin and Normal vector
+  this.rayPlaneIntersection = function(Pr, Vr, Pp, Np) {
+    var d = -Vec3.dot(Pp, Np);
+    var t = -(Vec3.dot(Pr, Np) + d) / Vec3.dot(Vr, Np);
+    return Vec3.sum(Pr, Vec3.multiply(t, Vr));
+  }
+  this.maybeDownloadSound = function() {
+    if (this.sound === null) {
+      this.sound = new Sound("http://public.highfidelity.io/sounds/Footsteps/FootstepW3Left-12db.wav");
+    }
+  }
+  this.playSound = function() {
+		var options = new AudioInjectionOptions();
+		options.position = this.properties.position;
+		options.volume = 0.5;
+		Audio.playSound(this.sound, options);
+  }
+  
+  
+  this.clickDownOnEntity = function(entityID, mouseEvent){
+    this.maybeDownloadSound();
+    this.updateProperties(entityID);
+    this.updatePosition(mouseEvent);
+  };
+  this.holdingClickOnEntity = function(entityID, mouseEvent){
+    this.updateProperties(entityID);
+    this.updatePosition(mouseEvent);
+  };
+  this.clickReleaseOnEntity = function(entityID, mouseEvent){
+    this.updateProperties(entityID);
+    this.updatePosition(mouseEvent);
+    this.snapToGrid();
+    this.playSound();
+  };
+})
\ No newline at end of file

From f80068798f014aeef345bde3fca3f5e63fc2cada Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Tue, 11 Nov 2014 17:09:08 -0800
Subject: [PATCH 06/38] playChess script with autonomous pieces

---
 examples/playChess.js | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index 660280c8f2..deb9cb4501 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -30,13 +30,16 @@ var ChessGame = ChessGame || {
 
 // Board class
 ChessGame.Board = (function(position, size) {
-  this.position = position;
   this.size = size;
   this.tileSize = this.size / ChessGame.BOARD_SIZE;
   this.height = this.tileSize * 0.2;
+
+  this.position = position;
+  this.position.x += this.tileSize / 2.0;
+  this.position.y += this.height / 2.0;
+  this.position.z += this.tileSize / 2.0;
+
   this.tiles = new Array();
-  
-  this.spawn();
 });
 // Applies operation to each tile where operation = function(i, j)
 ChessGame.Board.prototype.apply = function(operation) {
@@ -98,7 +101,8 @@ ChessGame.Piece = (function(position, size, url) {
     type: "Model",
     position: this.position,
     dimensions: this.size,
-    modelURL: url
+    modelURL: url,
+    script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
   }
   this.entity = null;
 });
@@ -113,7 +117,6 @@ ChessGame.Piece.prototype.cleanup = function() {
 
 
 
-
 // Player class
 ChessGame.Player = (function() {
   
@@ -147,6 +150,8 @@ ChessGame.scriptStarting = function() {
       ChessGame.pieces.push(piece);
     }
   }
+  
+  ChessGame.board.spawn();
 }
 
 ChessGame.scriptEnding = function() {

From b4585163dbb0c7c5d39fc7f2df207580cbee7974 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Wed, 12 Nov 2014 14:14:37 -0800
Subject: [PATCH 07/38] Global board position / piece boundaries

---
 examples/entityScripts/chessPiece.js | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index 5342e9cd4f..fe68e2a13b 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -1,4 +1,6 @@
 (function(){
+  this.GRID_POSITION = { x: 1, y: 1, z: 1 };
+  this.GRID_SIZE = 1.0;
   this.sound = null;
   this.entityID = null;
   this.properties = null;
@@ -24,15 +26,16 @@
     Entities.editEntity(this.entityID, { position: intersection });
   }
   this.snapToGrid = function() {
-    var position = { x: 1, y: 1, z: 1 };
-    var size = 1.0;
+    var position = this.GRID_POSITION;
+    var size = this.GRID_SIZE;
     var tileSize = size / 8.0;
     var height = tileSize * 0.2;
 
-    
     var relative = Vec3.subtract(this.properties.position, position);
     var i = Math.floor(relative.x / tileSize);
     var j = Math.floor(relative.z / tileSize);
+    i = Math.min(Math.max(0, i), 7);
+    j = Math.min(Math.max(-1, j), 8);
     
     relative.x = (i + 0.5) * tileSize;
     relative.z = (j + 0.5) * tileSize;
@@ -58,7 +61,6 @@
 		Audio.playSound(this.sound, options);
   }
   
-  
   this.clickDownOnEntity = function(entityID, mouseEvent){
     this.maybeDownloadSound();
     this.updateProperties(entityID);

From d25af3b4c9428c96ee0c7ec45f8a2dd4daa37088 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Wed, 12 Nov 2014 14:15:18 -0800
Subject: [PATCH 08/38] Actual piece meshes

---
 examples/playChess.js | 183 +++++++++++++++++++++++++++++++++---------
 1 file changed, 147 insertions(+), 36 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index deb9cb4501..0ffaca5bb2 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -16,15 +16,57 @@ var ChessGame = ChessGame || {
   ROWS: ['1', '2', '3', '4', '5', '6', '7', '8'],
   COLUMNS: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
   
-  whitesTileColor: {red: 250, green: 195, blue: 135},
-  blacksTileColor: {red: 190, green: 115, blue: 50},
-  whiteKingURL: "http://public.highfidelity.io/models/attachments/King Piece.fst",
-  whiteKingDimensions: { x: 0.46, y: 1.0, z: 0.46 },
-  blackKingURL: "http://public.highfidelity.io/models/attachments/King Piece.fst",
-  blackKingDimensions: { x: 0.46, y: 1.0, z: 0.46 },
-  
+  whitesTileColor: { red: 250, green: 195, blue: 135 },
+  blacksTileColor: { red: 190, green: 115, blue: 50 },
+
   board: null,
-  pieces: null
+  pieces: {
+    all: new Array(),
+    king: {
+      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/King_White.fbx",
+      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/King_Black.fbx",
+      dimensions: { x: 110.496, y: 306.713, z: 110.496 },
+      rotation: Quat.fromPitchYawRollDegrees(0, 90, 0)
+    },
+    queen: {
+      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Queen_White.fbx",
+      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Queen_Black.fbx",
+      dimensions: { x: 110.496, y: 257.459, z: 110.496 },
+      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0)
+    },
+    bishop: {
+      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Bishop_White.fbx",
+      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Bishop_Black.fbx",
+      dimensions: { x: 102.002, y: 213.941, z: 102.002 },
+      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0),
+      white: [],
+      black: []
+    },
+    knight: {
+      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Knight_White.fbx",
+      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Knight_Black.fbx",
+      dimensions: { x: 95.602, y: 186.939, z: 95.602 },
+      rotation: Quat.fromPitchYawRollDegrees(0, 180, 0),
+      white: [],
+      black: []
+    },
+    rook: {
+      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Rook_White.fbx",
+      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Rook_Black.fbx",
+      dimensions: { x: 101.024, y: 167.523, z: 101.024 },
+      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0),
+      white: [],
+      black: []
+    },
+    pawn: {
+      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Pawn_White.fbx",
+      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Pawn_Black.fbx",
+      dimensions: { x: 93.317, y: 138.747, z: 93.317 },
+      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0),
+      white: [],
+      black: []
+    }
+  }
 };
 
 
@@ -94,14 +136,16 @@ ChessGame.Board.prototype.cleanup = function() {
 }
 
 // Piece class
-ChessGame.Piece = (function(position, size, url) {
+ChessGame.Piece = (function(position, size, url, rotation) {
   this.position = position;
   this.size = size;
   this.entityProperties = {
     type: "Model",
     position: this.position,
+    rotation: rotation,
     dimensions: this.size,
     modelURL: url,
+    //script: "https://s3-us-west-1.amazonaws.com/highfidelity-dev/scripts/chessPiece.js"
     script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
   }
   this.entity = null;
@@ -110,11 +154,30 @@ ChessGame.Piece = (function(position, size, url) {
 ChessGame.Piece.prototype.spawn = function() {
   this.entity = Entities.addEntity(this.entityProperties);
 }
+// Updates the metadata stored by the piece
+ChessGame.Piece.prototype.updateMetaData = function(metaDataString) {
+  Entities.editEntity(this.entity, { animationURL: metaDataString });
+}
 // Cleans up the piece
 ChessGame.Piece.prototype.cleanup = function() {
   Entities.deleteEntity(this.entity);
 }
-
+ChessGame.makePiece = function(properties, i, j, isWhite) {
+  var url = (isWhite) ? properties.whiteURL : properties.blackURL;
+  var size = Vec3.multiply(1.0 / ChessGame.pieces.king.dimensions.y,
+                           properties.dimensions);
+  size = Vec3.multiply(1.5 * ChessGame.board.tileSize, size);
+  var rotation = (isWhite) ? properties.rotation
+                           : Quat.multiply(Quat.fromPitchYawRollDegrees(0, 180, 0),
+                                           properties.rotation);
+  var position = Vec3.sum(ChessGame.board.tilePosition(i, j),
+                          { x: 0, y: (size.y + ChessGame.board.height) / 2.0, z: 0});
+                
+  var piece = new ChessGame.Piece(position, size, url, rotation);
+  piece.spawn();
+  ChessGame.pieces.all.push(piece);
+  return piece;
+}
 
 
 // Player class
@@ -125,33 +188,81 @@ ChessGame.Player = (function() {
 ChessGame.update = function() {
   
 }
+ChessGame.buildMetaDataString = function() {
+  var metadataObject = {
+    board: {
+      position: ChessGame.board.position,
+      size: ChessGame.board.size
+    }
+  };
+  
+  return JSON.stringify(metadataObject);
+}
+
+ChessGame.buildBoard = function() {
+  // Setup board
+  ChessGame.board = new ChessGame.Board({ x: 1, y: 1, z: 1 }, 1);
+  ChessGame.board.spawn();
+  
+  // Setup white pieces
+  // King
+  var piece = ChessGame.makePiece(ChessGame.pieces.king, 0, 3, true);
+  ChessGame.pieces.king.white = piece;
+  // Queen
+  piece = ChessGame.makePiece(ChessGame.pieces.queen, 0, 4, true);
+  ChessGame.pieces.queen.white = piece;
+  // Bishop
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 0, 2, true);
+  ChessGame.pieces.bishop.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 0, 5, true);
+  ChessGame.pieces.bishop.white.push(piece);
+  // Knight
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 0, 1, true);
+  ChessGame.pieces.knight.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 0, 6, true);
+  ChessGame.pieces.knight.white.push(piece);
+  // Rook
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 0, 0, true);
+  ChessGame.pieces.rook.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 0, 7, true);
+  ChessGame.pieces.rook.white.push(piece);
+  for(var j = 0; j < ChessGame.BOARD_SIZE; j++) {
+    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 1, j, true);
+    ChessGame.pieces.pawn.white.push(piece);
+  }
+  
+  // Setup black pieces
+  // King
+  var piece = ChessGame.makePiece(ChessGame.pieces.king, 7, 3, false);
+  ChessGame.pieces.king.white = piece;
+  // Queen
+  piece = ChessGame.makePiece(ChessGame.pieces.queen, 7, 4, false);
+  ChessGame.pieces.queen.white = piece;
+  // Bishop
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 7, 2, false);
+  ChessGame.pieces.bishop.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 7, 5, false);
+  ChessGame.pieces.bishop.white.push(piece);
+  // Knight
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 7, 1, false);
+  ChessGame.pieces.knight.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 7, 6, false);
+  ChessGame.pieces.knight.white.push(piece);
+  // Rook
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 7, 0, false);
+  ChessGame.pieces.rook.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 7, 7, false);
+  ChessGame.pieces.rook.white.push(piece);
+  for(var j = 0; j < ChessGame.BOARD_SIZE; j++) {
+    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 6, j, false);
+    ChessGame.pieces.pawn.black.push(piece);
+  }
+}
+
 
 ChessGame.scriptStarting = function() {
   print("playChess.js started");
-  ChessGame.board = new ChessGame.Board({ x: 1, y: 1, z: 1 }, 1);
-  ChessGame.pieces = new Array();
-
-  var url = "http://public.highfidelity.io/models/attachments/King Piece.fst";
-  var dimensions = { x: 0.46, y: 1.0, z: 0.46 };
-  
-  var rowsIndex = [0, 1, 6, 7];
-  for(var i in rowsIndex) {
-    for(var j = 0; j < ChessGame.BOARD_SIZE; j++) {
-      var size = Vec3.multiply(dimensions, ChessGame.board.tileSize);
-      if (rowsIndex[i] == 1 || rowsIndex[i] == 6) {
-        size = Vec3.multiply(size, 0.7);
-      }
-      var position = Vec3.sum(ChessGame.board.tilePosition(rowsIndex[i], j),
-                              { x: 0, y: (size.y + ChessGame.board.height) / 2.0, z: 0});
-      var color = (rowsIndex[i] < 4) ? ChessGame.whitesTileColor : ChessGame.blacksTileColor;
-      
-      var piece = new ChessGame.Piece(position, size, url);
-      piece.spawn();
-      ChessGame.pieces.push(piece);
-    }
-  }
-  
-  ChessGame.board.spawn();
+  ChessGame.buildBoard();
 }
 
 ChessGame.scriptEnding = function() {
@@ -160,8 +271,8 @@ ChessGame.scriptEnding = function() {
   delete ChessGame.board;
   
   // Cleaning up pieces
-  for(var i in ChessGame.pieces) {
-    ChessGame.pieces[i].cleanup();
+  for(var i in ChessGame.pieces.all) {
+    ChessGame.pieces.all[i].cleanup();
   }
   delete ChessGame.pieces;
   

From 76d45953fd24c0ff8a54c01b2e91be525103b4a1 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Wed, 12 Nov 2014 15:34:14 -0800
Subject: [PATCH 09/38] switch to mesh board

---
 examples/playChess.js | 107 +++++++++++++++++-------------------------
 1 file changed, 43 insertions(+), 64 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index 0ffaca5bb2..35676af21b 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -20,6 +20,9 @@ var ChessGame = ChessGame || {
   blacksTileColor: { red: 190, green: 115, blue: 50 },
 
   board: null,
+  boardURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Board.fbx",
+  boardDimensions: { x: 773.191, y: 20.010, z: 773.191 },
+  sizeFactor: 1.0 / 773.191,
   pieces: {
     all: new Array(),
     king: {
@@ -38,7 +41,7 @@ var ChessGame = ChessGame || {
       whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Bishop_White.fbx",
       blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Bishop_Black.fbx",
       dimensions: { x: 102.002, y: 213.941, z: 102.002 },
-      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0),
+      rotation: Quat.fromPitchYawRollDegrees(0, 90, 0),
       white: [],
       black: []
     },
@@ -72,30 +75,18 @@ var ChessGame = ChessGame || {
 
 // Board class
 ChessGame.Board = (function(position, size) {
-  this.size = size;
-  this.tileSize = this.size / ChessGame.BOARD_SIZE;
-  this.height = this.tileSize * 0.2;
+  this.tileSize = size / 10.0;
+  this.dimensions = Vec3.multiply(ChessGame.sizeFactor * size,
+                                 ChessGame.boardDimensions);
+  this.position = Vec3.sum(position, Vec3.multiply(0.5, this.dimensions));
 
-  this.position = position;
-  this.position.x += this.tileSize / 2.0;
-  this.position.y += this.height / 2.0;
-  this.position.z += this.tileSize / 2.0;
-
-  this.tiles = new Array();
+  this.entity = null;
 });
-// Applies operation to each tile where operation = function(i, j)
-ChessGame.Board.prototype.apply = function(operation) {
-  for (var i = 0; i < ChessGame.BOARD_SIZE; i++) {
-    for (var j = 0; j < ChessGame.BOARD_SIZE; j++) {
-      operation.call(this, i, j);
-    } 
-  }
-}
 // Returns tile position
 ChessGame.Board.prototype.tilePosition = function(i, j) {
-  return { x: this.position.x + i * this.tileSize,
-           y: this.position.y,
-           z: this.position.z + j * this.tileSize };
+  return { x: this.position.x + (i - 5.0 + 0.5) * this.tileSize,
+           y: this.position.y + this.dimensions.y / 2.0,
+           z: this.position.z + (j - 5.0 + 0.5) * this.tileSize };
 }
 // Checks the color of the tile
 ChessGame.Board.prototype.isWhite = function(x, y) {
@@ -107,20 +98,13 @@ ChessGame.Board.prototype.spawn = function() {
     print("Spawning board...");
   }
   
-  this.apply(function(i, j) {
-    var tile = Entities.addEntity({
-      type: "Box",
-      position: this.tilePosition(i, j),
-      dimensions: { x: this.tileSize, y: this.height, z: this.tileSize },
-      color: (this.isWhite(i, j)) ? ChessGame.whitesTileColor : ChessGame.blacksTileColor
-    });
-    
-    if (j === 0) {
-      // Create new row if needed
-      this.tiles.push(new Array());
-    }
-    this.tiles[i].push(tile); // Store tile
+  this.entity = Entities.addEntity({
+    type: "Model",
+    modelURL: ChessGame.boardURL,
+    position: this.position,
+    dimensions: this.dimensions
   });
+  
   print("Board spawned");
 }
 // Cleans up the entities of the board
@@ -128,17 +112,15 @@ ChessGame.Board.prototype.cleanup = function() {
   if (extraDebug) {
     print("Cleaning up board...");
   }
-  
-  this.apply(function(i, j) {
-    Entities.deleteEntity(this.tiles[i][j]);
-  });
+  Entities.deleteEntity(this.entity);
   print("Board cleaned up");
 }
 
 // Piece class
 ChessGame.Piece = (function(position, size, url, rotation) {
-  this.position = position;
   this.size = size;
+  this.position = position;
+  this.position.y += this.size.y / 2.0;
   this.entityProperties = {
     type: "Model",
     position: this.position,
@@ -164,14 +146,11 @@ ChessGame.Piece.prototype.cleanup = function() {
 }
 ChessGame.makePiece = function(properties, i, j, isWhite) {
   var url = (isWhite) ? properties.whiteURL : properties.blackURL;
-  var size = Vec3.multiply(1.0 / ChessGame.pieces.king.dimensions.y,
-                           properties.dimensions);
-  size = Vec3.multiply(1.5 * ChessGame.board.tileSize, size);
+  var size = Vec3.multiply(0.5 * ChessGame.sizeFactor, properties.dimensions);
   var rotation = (isWhite) ? properties.rotation
                            : Quat.multiply(Quat.fromPitchYawRollDegrees(0, 180, 0),
                                            properties.rotation);
-  var position = Vec3.sum(ChessGame.board.tilePosition(i, j),
-                          { x: 0, y: (size.y + ChessGame.board.height) / 2.0, z: 0});
+  var position = ChessGame.board.tilePosition(i, j);
                 
   var piece = new ChessGame.Piece(position, size, url, rotation);
   piece.spawn();
@@ -206,55 +185,55 @@ ChessGame.buildBoard = function() {
   
   // Setup white pieces
   // King
-  var piece = ChessGame.makePiece(ChessGame.pieces.king, 0, 3, true);
+  var piece = ChessGame.makePiece(ChessGame.pieces.king, 1, 4, true);
   ChessGame.pieces.king.white = piece;
   // Queen
-  piece = ChessGame.makePiece(ChessGame.pieces.queen, 0, 4, true);
+  piece = ChessGame.makePiece(ChessGame.pieces.queen, 1, 5, true);
   ChessGame.pieces.queen.white = piece;
   // Bishop
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 0, 2, true);
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 1, 3, true);
   ChessGame.pieces.bishop.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 0, 5, true);
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 1, 6, true);
   ChessGame.pieces.bishop.white.push(piece);
   // Knight
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 0, 1, true);
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 1, 2, true);
   ChessGame.pieces.knight.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 0, 6, true);
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 1, 7, true);
   ChessGame.pieces.knight.white.push(piece);
   // Rook
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 0, 0, true);
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 1, 1, true);
   ChessGame.pieces.rook.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 0, 7, true);
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 1, 8, true);
   ChessGame.pieces.rook.white.push(piece);
-  for(var j = 0; j < ChessGame.BOARD_SIZE; j++) {
-    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 1, j, true);
+  for(var j = 1; j <= ChessGame.BOARD_SIZE; j++) {
+    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 2, j, true);
     ChessGame.pieces.pawn.white.push(piece);
   }
   
   // Setup black pieces
   // King
-  var piece = ChessGame.makePiece(ChessGame.pieces.king, 7, 3, false);
+  var piece = ChessGame.makePiece(ChessGame.pieces.king, 8, 4, false);
   ChessGame.pieces.king.white = piece;
   // Queen
-  piece = ChessGame.makePiece(ChessGame.pieces.queen, 7, 4, false);
+  piece = ChessGame.makePiece(ChessGame.pieces.queen, 8, 5, false);
   ChessGame.pieces.queen.white = piece;
   // Bishop
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 7, 2, false);
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 8, 3, false);
   ChessGame.pieces.bishop.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 7, 5, false);
+  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 8, 6, false);
   ChessGame.pieces.bishop.white.push(piece);
   // Knight
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 7, 1, false);
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 8, 2, false);
   ChessGame.pieces.knight.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 7, 6, false);
+  piece = ChessGame.makePiece(ChessGame.pieces.knight, 8, 7, false);
   ChessGame.pieces.knight.white.push(piece);
   // Rook
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 7, 0, false);
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 8, 1, false);
   ChessGame.pieces.rook.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 7, 7, false);
+  piece = ChessGame.makePiece(ChessGame.pieces.rook, 8, 8, false);
   ChessGame.pieces.rook.white.push(piece);
-  for(var j = 0; j < ChessGame.BOARD_SIZE; j++) {
-    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 6, j, false);
+  for(var j = 1; j <= ChessGame.BOARD_SIZE; j++) {
+    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 7, j, false);
     ChessGame.pieces.pawn.black.push(piece);
   }
 }

From 6f8b702334bde740a3b905d383200bdc6e5ed981 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Wed, 12 Nov 2014 15:34:39 -0800
Subject: [PATCH 10/38] New grid

---
 examples/entityScripts/chessPiece.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index fe68e2a13b..70a4a82c3b 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -28,14 +28,13 @@
   this.snapToGrid = function() {
     var position = this.GRID_POSITION;
     var size = this.GRID_SIZE;
-    var tileSize = size / 8.0;
-    var height = tileSize * 0.2;
+    var tileSize = size / 10.0;
 
     var relative = Vec3.subtract(this.properties.position, position);
     var i = Math.floor(relative.x / tileSize);
     var j = Math.floor(relative.z / tileSize);
-    i = Math.min(Math.max(0, i), 7);
-    j = Math.min(Math.max(-1, j), 8);
+    i = Math.min(Math.max(1, i), 8);
+    j = Math.min(Math.max(0, j), 10);
     
     relative.x = (i + 0.5) * tileSize;
     relative.z = (j + 0.5) * tileSize;

From 7193fcc89dfc523a62a8be5a56306382ae0c6638 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Wed, 12 Nov 2014 17:12:27 -0800
Subject: [PATCH 11/38] Metadata for pieces

---
 examples/entityScripts/chessPiece.js | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index 70a4a82c3b..13d36d28fb 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -34,7 +34,7 @@
     var i = Math.floor(relative.x / tileSize);
     var j = Math.floor(relative.z / tileSize);
     i = Math.min(Math.max(1, i), 8);
-    j = Math.min(Math.max(0, j), 10);
+    j = Math.min(Math.max(0, j), 9);
     
     relative.x = (i + 0.5) * tileSize;
     relative.z = (j + 0.5) * tileSize;
@@ -59,10 +59,20 @@
 		options.volume = 0.5;
 		Audio.playSound(this.sound, options);
   }
+  this.getMetadata = function() {
+    var metadataObject = JSON.parse(this.properties.animationURL);
+    if (metadataObject.gamePosition) {
+      this.GRID_POSITION = metadataObject.gamePosition;
+    }
+    if (metadataObject.gameSize) {
+      this.GRID_SIZE = metadataObject.gameSize;
+    }
+  }
   
   this.clickDownOnEntity = function(entityID, mouseEvent){
     this.maybeDownloadSound();
     this.updateProperties(entityID);
+    this.getMetadata();
     this.updatePosition(mouseEvent);
   };
   this.holdingClickOnEntity = function(entityID, mouseEvent){

From bada1d8e38d29d9099666557b30287627b2148e2 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Wed, 12 Nov 2014 17:13:29 -0800
Subject: [PATCH 12/38] Cleaner code + metadata

---
 examples/playChess.js | 250 +++++++++++++++++++-----------------------
 1 file changed, 114 insertions(+), 136 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index 35676af21b..ecfe1d12ae 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -8,89 +8,86 @@
 //  Distributed under the Apache License, Version 2.0.
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 
+var gamePosition = { x: 1.0, y: 1.0, z: 1.0 };
+var gameSize = 1.0;
+
 // Script namespace
 var extraDebug = extraDebug || true;
 var ChessGame = ChessGame || {
-  BOARD_SIZE: 8,
-  MAX_PLAYERS: 2,
-  ROWS: ['1', '2', '3', '4', '5', '6', '7', '8'],
-  COLUMNS: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
+  BOARD: {
+    modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Board.fbx",
+    dimensions: { x: 773.191, y: 20.010, z: 773.191 },
+    rotation: Quat.fromPitchYawRollDegrees(0, 90, 0),
+    numTiles: 10.0
+  },
+  KING: 0, QUEEN: 1, BISHOP: 2, KNIGHT: 3, ROOK: 4, PAWN: 5,
   
-  whitesTileColor: { red: 250, green: 195, blue: 135 },
-  blacksTileColor: { red: 190, green: 115, blue: 50 },
-
   board: null,
-  boardURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Board.fbx",
-  boardDimensions: { x: 773.191, y: 20.010, z: 773.191 },
-  sizeFactor: 1.0 / 773.191,
-  pieces: {
-    all: new Array(),
-    king: {
-      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/King_White.fbx",
-      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/King_Black.fbx",
-      dimensions: { x: 110.496, y: 306.713, z: 110.496 },
-      rotation: Quat.fromPitchYawRollDegrees(0, 90, 0)
-    },
-    queen: {
-      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Queen_White.fbx",
-      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Queen_Black.fbx",
-      dimensions: { x: 110.496, y: 257.459, z: 110.496 },
-      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0)
-    },
-    bishop: {
-      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Bishop_White.fbx",
-      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Bishop_Black.fbx",
-      dimensions: { x: 102.002, y: 213.941, z: 102.002 },
-      rotation: Quat.fromPitchYawRollDegrees(0, 90, 0),
-      white: [],
-      black: []
-    },
-    knight: {
-      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Knight_White.fbx",
-      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Knight_Black.fbx",
-      dimensions: { x: 95.602, y: 186.939, z: 95.602 },
-      rotation: Quat.fromPitchYawRollDegrees(0, 180, 0),
-      white: [],
-      black: []
-    },
-    rook: {
-      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Rook_White.fbx",
-      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Rook_Black.fbx",
-      dimensions: { x: 101.024, y: 167.523, z: 101.024 },
-      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0),
-      white: [],
-      black: []
-    },
-    pawn: {
-      whiteURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Pawn_White.fbx",
-      blackURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Pawn_Black.fbx",
-      dimensions: { x: 93.317, y: 138.747, z: 93.317 },
-      rotation: Quat.fromPitchYawRollDegrees(0, 0, 0),
-      white: [],
-      black: []
-    }
-  }
+  pieces: new Array()
 };
 
+ChessGame.getPieceInfo = function(type, isWhite) {
+  var info = {
+    modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/",
+    dimensions: { x: 1.0, y: 1.0, z: 1.0 },
+    rotation: Quat.fromPitchYawRollDegrees(0, 0, 0)
+  }
+  
+  switch(type) {
+  case ChessGame.KING:
+    info.modelURL += "King";
+    info.dimensions = { x: 110.496, y: 306.713, z: 110.496 };
+    info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
+    break;
+  case ChessGame.QUEEN:
+    info.modelURL += "Queen";
+    info.dimensions = { x: 110.496, y: 257.459, z: 110.496 };
+    break;
+  case ChessGame.BISHOP:
+    info.modelURL += "Bishop";
+    info.dimensions = { x: 102.002, y: 213.941, z: 102.002 };
+    info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
+    break;
+  case ChessGame.KNIGHT:
+    info.modelURL += "Knight";
+    info.dimensions = { x: 95.602, y: 186.939, z: 95.602 };
+    info.rotation = Quat.fromPitchYawRollDegrees(0, 180, 0);
+    break;
+  case ChessGame.ROOK:
+    info.modelURL += "Rook";
+    info.dimensions = { x: 101.024, y: 167.523, z: 101.024 };
+    break;
+  case ChessGame.PAWN:
+    info.modelURL += "Pawn";
+    info.dimensions = { x: 93.317, y: 138.747, z: 93.317 };
+    break;
+  }
+  info.modelURL += ((isWhite) ? "_White" : "_Black") + ".fbx"
+  
+  return info;
+}
+
 
 // Board class
 ChessGame.Board = (function(position, size) {
-  this.tileSize = size / 10.0;
-  this.dimensions = Vec3.multiply(ChessGame.sizeFactor * size,
-                                 ChessGame.boardDimensions);
+  this.dimensions = Vec3.multiply(1.0 / ChessGame.BOARD.dimensions.x, ChessGame.BOARD.dimensions); // 1 by 1
+  this.dimensions = Vec3.multiply(size, this.dimensions); // size by size
   this.position = Vec3.sum(position, Vec3.multiply(0.5, this.dimensions));
+  this.tileSize = size / ChessGame.BOARD.numTiles;
 
   this.entity = null;
 });
-// Returns tile position
+// Returns the top center point of tile i,j
 ChessGame.Board.prototype.tilePosition = function(i, j) {
-  return { x: this.position.x + (i - 5.0 + 0.5) * this.tileSize,
-           y: this.position.y + this.dimensions.y / 2.0,
-           z: this.position.z + (j - 5.0 + 0.5) * this.tileSize };
+  return {
+    x: this.position.x + (i - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize,
+    y: this.position.y + this.dimensions.y / 2.0,
+    z: this.position.z + (j - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize
+  };
 }
 // Checks the color of the tile
-ChessGame.Board.prototype.isWhite = function(x, y) {
-  return (x + y) % 2 != 0;
+ChessGame.Board.prototype.isWhite = function(i, j) {
+  return (i + j) % 2 != 0;
 }
 // Spawns the board using entities
 ChessGame.Board.prototype.spawn = function() {
@@ -100,7 +97,7 @@ ChessGame.Board.prototype.spawn = function() {
   
   this.entity = Entities.addEntity({
     type: "Model",
-    modelURL: ChessGame.boardURL,
+    modelURL: ChessGame.BOARD.modelURL,
     position: this.position,
     dimensions: this.dimensions
   });
@@ -117,15 +114,15 @@ ChessGame.Board.prototype.cleanup = function() {
 }
 
 // Piece class
-ChessGame.Piece = (function(position, size, url, rotation) {
-  this.size = size;
+ChessGame.Piece = (function(position, dimensions, url, rotation) {
+  this.dimensions = dimensions;
   this.position = position;
-  this.position.y += this.size.y / 2.0;
+  this.position.y += this.dimensions.y / 2.0;
   this.entityProperties = {
     type: "Model",
     position: this.position,
     rotation: rotation,
-    dimensions: this.size,
+    dimensions: this.dimensions,
     modelURL: url,
     //script: "https://s3-us-west-1.amazonaws.com/highfidelity-dev/scripts/chessPiece.js"
     script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
@@ -137,110 +134,93 @@ ChessGame.Piece.prototype.spawn = function() {
   this.entity = Entities.addEntity(this.entityProperties);
 }
 // Updates the metadata stored by the piece
-ChessGame.Piece.prototype.updateMetaData = function(metaDataString) {
-  Entities.editEntity(this.entity, { animationURL: metaDataString });
+ChessGame.Piece.prototype.updateMetadata = function(metadataString) {
+  Entities.editEntity(this.entity, { animationURL: metadataString });
 }
 // Cleans up the piece
 ChessGame.Piece.prototype.cleanup = function() {
   Entities.deleteEntity(this.entity);
 }
-ChessGame.makePiece = function(properties, i, j, isWhite) {
-  var url = (isWhite) ? properties.whiteURL : properties.blackURL;
-  var size = Vec3.multiply(0.5 * ChessGame.sizeFactor, properties.dimensions);
-  var rotation = (isWhite) ? properties.rotation
+ChessGame.makePiece = function(piece, i, j, isWhite) {
+  var info = ChessGame.getPieceInfo(piece, isWhite);
+  var url = info.modelURL; 
+  var size = Vec3.multiply(0.5 * (1.0 / ChessGame.BOARD.dimensions.x), info.dimensions);
+  var rotation = (isWhite) ? info.rotation
                            : Quat.multiply(Quat.fromPitchYawRollDegrees(0, 180, 0),
-                                           properties.rotation);
+                                           info.rotation);
   var position = ChessGame.board.tilePosition(i, j);
                 
   var piece = new ChessGame.Piece(position, size, url, rotation);
   piece.spawn();
-  ChessGame.pieces.all.push(piece);
+  ChessGame.pieces.push(piece);
   return piece;
 }
 
-
-// Player class
-ChessGame.Player = (function() {
-  
-});
-
-ChessGame.update = function() {
-  
-}
 ChessGame.buildMetaDataString = function() {
   var metadataObject = {
-    board: {
-      position: ChessGame.board.position,
-      size: ChessGame.board.size
-    }
+    gamePosition: gamePosition,
+    gameSize: gameSize
   };
-  
   return JSON.stringify(metadataObject);
 }
 
 ChessGame.buildBoard = function() {
   // Setup board
-  ChessGame.board = new ChessGame.Board({ x: 1, y: 1, z: 1 }, 1);
+  ChessGame.board = new ChessGame.Board(gamePosition, gameSize);
   ChessGame.board.spawn();
   
   // Setup white pieces
+  var isWhite = true;
+  var row = 1;
   // King
-  var piece = ChessGame.makePiece(ChessGame.pieces.king, 1, 4, true);
-  ChessGame.pieces.king.white = piece;
+  var piece =ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
   // Queen
-  piece = ChessGame.makePiece(ChessGame.pieces.queen, 1, 5, true);
-  ChessGame.pieces.queen.white = piece;
+  piece = ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
   // Bishop
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 1, 3, true);
-  ChessGame.pieces.bishop.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 1, 6, true);
-  ChessGame.pieces.bishop.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
+  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
   // Knight
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 1, 2, true);
-  ChessGame.pieces.knight.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 1, 7, true);
-  ChessGame.pieces.knight.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
+  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
   // Rook
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 1, 1, true);
-  ChessGame.pieces.rook.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 1, 8, true);
-  ChessGame.pieces.rook.white.push(piece);
-  for(var j = 1; j <= ChessGame.BOARD_SIZE; j++) {
-    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 2, j, true);
-    ChessGame.pieces.pawn.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
+  piece = ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
+  for(var j = 1; j <= 8; j++) {
+    piece = ChessGame.makePiece(ChessGame.PAWN, row + 1, j, isWhite);
   }
   
   // Setup black pieces
+  isWhite = false;
+  row = 8;
   // King
-  var piece = ChessGame.makePiece(ChessGame.pieces.king, 8, 4, false);
-  ChessGame.pieces.king.white = piece;
+  piece = ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
   // Queen
-  piece = ChessGame.makePiece(ChessGame.pieces.queen, 8, 5, false);
-  ChessGame.pieces.queen.white = piece;
+  piece = ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
   // Bishop
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 8, 3, false);
-  ChessGame.pieces.bishop.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.bishop, 8, 6, false);
-  ChessGame.pieces.bishop.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
+  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
   // Knight
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 8, 2, false);
-  ChessGame.pieces.knight.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.knight, 8, 7, false);
-  ChessGame.pieces.knight.white.push(piece);
+  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
+  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
   // Rook
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 8, 1, false);
-  ChessGame.pieces.rook.white.push(piece);
-  piece = ChessGame.makePiece(ChessGame.pieces.rook, 8, 8, false);
-  ChessGame.pieces.rook.white.push(piece);
-  for(var j = 1; j <= ChessGame.BOARD_SIZE; j++) {
-    piece = ChessGame.makePiece(ChessGame.pieces.pawn, 7, j, false);
-    ChessGame.pieces.pawn.black.push(piece);
+  piece = ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
+  piece = ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
+  for(var j = 1; j <= 8; j++) {
+    piece = ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
+  }
+  
+  var metadataString = ChessGame.buildMetadataString();
+  for (i in ChessGame.pieces) {
+    ChessGame.pieces[i].updateMetadata(metadataString);
   }
 }
 
 
 ChessGame.scriptStarting = function() {
   print("playChess.js started");
+  gamePosition = Vec3.sum(MyAvatar.position,
+                          Vec3.multiplyQbyV(MyAvatar.orientation,
+                                            { x: 0, y: 0, z: -1 }));
   ChessGame.buildBoard();
 }
 
@@ -250,15 +230,13 @@ ChessGame.scriptEnding = function() {
   delete ChessGame.board;
   
   // Cleaning up pieces
-  for(var i in ChessGame.pieces.all) {
-    ChessGame.pieces.all[i].cleanup();
+  for(var i in ChessGame.pieces) {
+    ChessGame.pieces[i].cleanup();
   }
   delete ChessGame.pieces;
   
   print("playChess.js finished");
 }
 
-
-Script.update.connect(ChessGame.update)
 Script.scriptEnding.connect(ChessGame.scriptEnding);
 ChessGame.scriptStarting();
\ No newline at end of file

From 16e243aec5bb9d13647beba6d7a79a7e87193ed6 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Wed, 12 Nov 2014 17:19:16 -0800
Subject: [PATCH 13/38] typo

---
 examples/playChess.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index ecfe1d12ae..cb60467492 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -124,8 +124,9 @@ ChessGame.Piece = (function(position, dimensions, url, rotation) {
     rotation: rotation,
     dimensions: this.dimensions,
     modelURL: url,
+    script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js"
     //script: "https://s3-us-west-1.amazonaws.com/highfidelity-dev/scripts/chessPiece.js"
-    script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
+    //script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
   }
   this.entity = null;
 });
@@ -156,7 +157,7 @@ ChessGame.makePiece = function(piece, i, j, isWhite) {
   return piece;
 }
 
-ChessGame.buildMetaDataString = function() {
+ChessGame.buildMetadataString = function() {
   var metadataObject = {
     gamePosition: gamePosition,
     gameSize: gameSize

From 2498fd11a3017a1591c274abef03a2c8a201e672 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Thu, 13 Nov 2014 10:22:45 -0800
Subject: [PATCH 14/38] Preload sounds / use hash injector options

---
 examples/entityScripts/chessPiece.js | 33 ++++++++++++++++------------
 1 file changed, 19 insertions(+), 14 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index 13d36d28fb..39b4784849 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -1,6 +1,7 @@
 (function(){
   this.GRID_POSITION = { x: 1, y: 1, z: 1 };
   this.GRID_SIZE = 1.0;
+  this.metadata = null;
   this.sound = null;
   this.entityID = null;
   this.properties = null;
@@ -34,7 +35,7 @@
     var i = Math.floor(relative.x / tileSize);
     var j = Math.floor(relative.z / tileSize);
     i = Math.min(Math.max(1, i), 8);
-    j = Math.min(Math.max(0, j), 9);
+    j = Math.min(Math.max(1, j), 8);
     
     relative.x = (i + 0.5) * tileSize;
     relative.z = (j + 0.5) * tileSize;
@@ -53,33 +54,37 @@
       this.sound = new Sound("http://public.highfidelity.io/sounds/Footsteps/FootstepW3Left-12db.wav");
     }
   }
+  
   this.playSound = function() {
-		var options = new AudioInjectionOptions();
-		options.position = this.properties.position;
-		options.volume = 0.5;
-		Audio.playSound(this.sound, options);
+    if (this.sound.downloaded) {
+  		Audio.playSound(this.sound, { position: this.properties.position });
+    }
   }
   this.getMetadata = function() {
-    var metadataObject = JSON.parse(this.properties.animationURL);
-    if (metadataObject.gamePosition) {
-      this.GRID_POSITION = metadataObject.gamePosition;
-    }
-    if (metadataObject.gameSize) {
-      this.GRID_SIZE = metadataObject.gameSize;
+    if (this.properties.animationURL !== "") {
+      var metadataObject = JSON.parse(this.properties.animationURL);
+      if (metadataObject.gamePosition) {
+        this.GRID_POSITION = metadataObject.gamePosition;
+      }
+      if (metadataObject.gameSize) {
+        this.GRID_SIZE = metadataObject.gameSize;
+      }
     }
   }
   
-  this.clickDownOnEntity = function(entityID, mouseEvent){
+  this.preload = function() {
     this.maybeDownloadSound();
+  }
+  this.clickDownOnEntity = function(entityID, mouseEvent) {
     this.updateProperties(entityID);
     this.getMetadata();
     this.updatePosition(mouseEvent);
   };
-  this.holdingClickOnEntity = function(entityID, mouseEvent){
+  this.holdingClickOnEntity = function(entityID, mouseEvent) {
     this.updateProperties(entityID);
     this.updatePosition(mouseEvent);
   };
-  this.clickReleaseOnEntity = function(entityID, mouseEvent){
+  this.clickReleaseOnEntity = function(entityID, mouseEvent) {
     this.updateProperties(entityID);
     this.updatePosition(mouseEvent);
     this.snapToGrid();

From ce0cb9fdc7e7e0c3823ea4f6dba4fd84ada4e428 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Thu, 13 Nov 2014 11:34:38 -0800
Subject: [PATCH 15/38] Better move / start of auto move dead piece

---
 examples/entityScripts/chessPiece.js | 85 +++++++++++++++++++++-------
 1 file changed, 65 insertions(+), 20 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index 39b4784849..17b186d396 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -5,10 +5,12 @@
   this.sound = null;
   this.entityID = null;
   this.properties = null;
+  this.startingTile = null;
+  this.pieces = new Array();
+  
   this.updateProperties = function(entityID) {
     if (this.entityID === null) {
       this.entityID = entityID;
-      print("entityID=" + JSON.stringify(this.entityID));
     }
     if (!entityID.isKnownID || this.entityID.id !== entityID.id) {
       print("Something is very wrong: Bailing!");
@@ -19,27 +21,40 @@
       print("Unknown entityID " + this.entityID.id + " should be self.")
     } 
   }
+  
   this.updatePosition = function(mouseEvent) {
     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);
+    if (this.isOutsideGrid(this.getIndexPosition(intersection))) {
+      intersection = this.getAbsolutePosition(this.startingTile);
+    }
     Entities.editEntity(this.entityID, { position: intersection });
+    //this.moveDeadPiece();
+  }
+  this.isOutsideGrid = function(pos) {
+    return !(pos.i >= 0 && pos.j >= 0 && pos.i <= 9 && pos.j <= 9);
+  }
+  this.getIndexPosition = function(position) {
+    var tileSize = this.GRID_SIZE / 10.0;
+    var relative = Vec3.subtract(position, this.GRID_POSITION);
+    return {
+      i: Math.floor(relative.x / tileSize),
+      j: Math.floor(relative.z / tileSize)
+    }
+  }
+  this.getAbsolutePosition = function(pos) {
+    var tileSize = this.GRID_SIZE / 10.0;
+    var relative = Vec3.subtract(this.properties.position, this.GRID_POSITION);
+    relative.x = (pos.i + 0.5) * tileSize;
+    relative.z = (pos.j + 0.5) * tileSize;
+    
+    return Vec3.sum(this.GRID_POSITION, relative);
   }
   this.snapToGrid = function() {
-    var position = this.GRID_POSITION;
-    var size = this.GRID_SIZE;
-    var tileSize = size / 10.0;
-
-    var relative = Vec3.subtract(this.properties.position, position);
-    var i = Math.floor(relative.x / tileSize);
-    var j = Math.floor(relative.z / tileSize);
-    i = Math.min(Math.max(1, i), 8);
-    j = Math.min(Math.max(1, j), 8);
-    
-    relative.x = (i + 0.5) * tileSize;
-    relative.z = (j + 0.5) * tileSize;
-    var finalPos = Vec3.sum(position, relative);
+    var pos = this.getIndexPosition(this.properties.position);
+    var finalPos = this.getAbsolutePosition((this.isOutsideGrid(pos)) ?  this.startingTile : pos);
     Entities.editEntity(this.entityID, { position: finalPos });
   }
   // Pr, Vr are respectively the Ray's Point of origin and Vector director
@@ -56,8 +71,9 @@
   }
   
   this.playSound = function() {
-    if (this.sound.downloaded) {
+    if (this.sound !== null && this.sound.downloaded) {
   		Audio.playSound(this.sound, { position: this.properties.position });
+      print("playing sound");
     }
   }
   this.getMetadata = function() {
@@ -69,6 +85,36 @@
       if (metadataObject.gameSize) {
         this.GRID_SIZE = metadataObject.gameSize;
       }
+      if (metadataObject.pieces) {
+        this.pieces = metadataObject.pieces;
+      }
+    }
+  }
+
+  
+  this.grab = function(mouseEvent) {
+    this.startingTile = this.getIndexPosition(this.properties.position);
+    this.updatePosition(mouseEvent);
+  }
+  this.move = function(mouseEvent) {
+    this.updatePosition(mouseEvent);
+  }
+  this.release = function(mouseEvent) {
+    this.updatePosition(mouseEvent);
+    this.snapToGrid();
+    
+    this.playSound();
+  }
+  this.moveDeadPiece = function() {
+    var myPos = this.getIndexPosition(this.properties.position);
+    for (var i = 0; i < this.pieces.length; i++) {
+      if (this.pieces[i].id != this.entityID.id) {
+        var piecePos = this.getIndexPosition(Entities.getEntityProperties(this.pieces[i]).position);
+        if (myPos.i === piecePos.i && myPos.j === piecePos.j) {
+          Entities.editEntity(this.pieces[i], { position: this.getAbsolutePosition({ i: 0, j: 0 })});
+          break;
+        }
+      }
     }
   }
   
@@ -76,18 +122,17 @@
     this.maybeDownloadSound();
   }
   this.clickDownOnEntity = function(entityID, mouseEvent) {
+    this.maybeDownloadSound();
     this.updateProperties(entityID);
     this.getMetadata();
-    this.updatePosition(mouseEvent);
+    this.grab(mouseEvent);
   };
   this.holdingClickOnEntity = function(entityID, mouseEvent) {
     this.updateProperties(entityID);
-    this.updatePosition(mouseEvent);
+    this.move(mouseEvent);
   };
   this.clickReleaseOnEntity = function(entityID, mouseEvent) {
     this.updateProperties(entityID);
-    this.updatePosition(mouseEvent);
-    this.snapToGrid();
-    this.playSound();
+    this.release(mouseEvent);
   };
 })
\ No newline at end of file

From ac34db14aa2e530b8349e8f01f5e092197c1f527 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Thu, 13 Nov 2014 11:35:14 -0800
Subject: [PATCH 16/38] Send pieces ID

---
 examples/playChess.js | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index cb60467492..1ed836b7ca 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -124,9 +124,9 @@ ChessGame.Piece = (function(position, dimensions, url, rotation) {
     rotation: rotation,
     dimensions: this.dimensions,
     modelURL: url,
-    script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js"
+    //script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js"
     //script: "https://s3-us-west-1.amazonaws.com/highfidelity-dev/scripts/chessPiece.js"
-    //script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
+    script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
   }
   this.entity = null;
 });
@@ -160,8 +160,12 @@ ChessGame.makePiece = function(piece, i, j, isWhite) {
 ChessGame.buildMetadataString = function() {
   var metadataObject = {
     gamePosition: gamePosition,
-    gameSize: gameSize
+    gameSize: gameSize,
+    pieces: new Array()
   };
+  for (i in ChessGame.pieces) {
+    metadataObject.pieces.push(ChessGame.pieces[i].entity);
+  }
   return JSON.stringify(metadataObject);
 }
 

From 388332966d6a11b49f50fc996da8b07df3be0c74 Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Thu, 13 Nov 2014 22:22:46 +0100
Subject: [PATCH 17/38] Added cloning methods to Grid3DOverlay Added example
 script for cloning overlays (TODO: SpriteBillboard fix cloning of in example)

---
 examples/clonedOverlaysExample.js           | 278 ++++++++++++++++++++
 interface/src/ui/overlays/Grid3DOverlay.cpp |  12 +
 interface/src/ui/overlays/Grid3DOverlay.h   |   4 +
 3 files changed, 294 insertions(+)
 create mode 100644 examples/clonedOverlaysExample.js

diff --git a/examples/clonedOverlaysExample.js b/examples/clonedOverlaysExample.js
new file mode 100644
index 0000000000..aacca939f6
--- /dev/null
+++ b/examples/clonedOverlaysExample.js
@@ -0,0 +1,278 @@
+//
+//  clonedOverlaysExample.js
+//  examples
+//
+//  Created by Thijs Wenker on 11/13/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Demonstrates the use of the overlay cloning function.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// Image source: https://openclipart.org/detail/447/christmas-tree-by-theresaknott (heavily edited by Maximillian Merlin)
+const CHRISTMAS_TREE_SPRITES_URL = "http://test.thoys.nl/hifi/images/santa/christmas-tree.svg";
+
+// Image source: http://opengameart.org/content/santa-claus (CC-BY 3.0)
+const SANTA_SPRITES_URL = "http://test.thoys.nl/hifi/images/santa/Santa.png";
+
+Array.prototype.contains = function(obj) {
+    var i = this.length;
+    while (i--) {
+        if (this[i] === obj) {
+            return true;
+        }
+    }
+    return false;
+};
+
+function getRandomPosAroundMyAvatar(radius) {
+    return {x: MyAvatar.position.x + Math.floor(Math.random() * radius * 2) - radius, y: MyAvatar.position.y, z: MyAvatar.position.z + Math.floor(Math.random() * radius * 2) - radius};
+}
+
+function SpriteBillboard(sprite_properties) {
+    var _this = this;
+    // set properties
+    this.overlay_properties = {};
+    this.sprite_properties = sprite_properties;
+    this.edited_overlay_properties = [];
+    this.defaultFPS = 30;
+    this.currentSequence = "";
+    this.sequenceIndex = 0;
+    this.sequenceFPS = 0;
+	this.sequenceStepToNext = false;
+    this.sequenceTimer = null;
+    this.prevSequenceIndex = -1;
+	this.sequenceX = 0;
+	this.sequenceY = 0;
+    
+    this.spriteSize = {x: 0, y: 0, width: 32, height: 64};
+    
+    this.editedProperty = function(prop_name) {
+        if (!_this.edited_overlay_properties.contains(prop_name)) {
+            _this.edited_overlay_properties.push(prop_name);
+        }
+    };
+
+    // function definitions
+    this.getPosition = function() {
+        return _this.overlay_properties.position ?
+            _this.overlay_properties.position : {x: 0, y: 0, z: 0};
+    };
+
+    this.setPosition = function(newPosition) {
+        this.overlay_properties.position = newPosition;
+        this.editedProperty("position");
+        return _this;
+    };
+
+    this.setURL = function(url) {
+        this.overlay_properties.url = url;
+        this.editedProperty("url");
+        return _this;
+    }
+
+    this.setAlpha = function(alpha) {
+        this.overlay_properties.alpha = alpha;
+        this.editedProperty("alpha");
+        return _this;
+    }
+
+    this.setScale = function(scale) {
+        this.overlay_properties.scale = scale;
+        this.editedProperty("scale");
+        return _this;
+    }
+
+    this.setSpriteSize = function(spriteSize) {
+        this.overlay_properties.subImage = spriteSize;
+        this.editedProperty("subImage");
+        return _this;
+    };
+    
+    this.setSpriteXIndex = function(x_index) {
+	    _this.sequenceX = x_index;
+        _this.overlay_properties.subImage.x = x_index * _this.overlay_properties.subImage.width;
+        _this.editedProperty("subImage");
+        return _this;
+    }
+    
+    this.setSpriteYIndex = function(y_index) {
+	    _this.sequenceY = y_index;
+        _this.overlay_properties.subImage.y = y_index * _this.overlay_properties.subImage.height;
+        _this.editedProperty("subImage");
+        return _this;
+    }
+
+    this.editOverlay = function(properties) {
+        for (var key in properties) {
+             _this.overlay_properties[attrname] = properties[key];
+             _this.editedProperty(key);
+        }
+        return _this;
+    };
+
+    this.commitChanges = function() {
+        var changed_properties = {};
+        for (var i = 0; i < _this.edited_overlay_properties.length; i++) {
+             var key = _this.edited_overlay_properties[i];
+             changed_properties[key] = _this.overlay_properties[key];
+        }
+		if (Object.keys(changed_properties).length === 0) {
+		    return;
+		}
+        Overlays.editOverlay(_this.overlay, changed_properties);
+        _this.edited_overlay_properties = [];
+    };
+
+    this._renderFrame = function() {
+        var currentSequence = _this.sprite_properties.sequences[_this.currentSequence];
+        var currentItem = currentSequence[_this.sequenceIndex];
+		var indexChanged = _this.sequenceIndex != _this.prevSequenceIndex;
+		var canMoveToNext = true;
+		_this.prevSequenceIndex = _this.sequenceIndex;
+        if (indexChanged) {
+            if (currentItem.loop != undefined) {
+                _this.loopSequence = currentItem.loop;
+            }
+            if (currentItem.fps !== undefined && currentItem.fps != _this.sequenceFPS) {
+                _this.startSequenceTimerFPS(currentItem.fps);
+            }
+			if (currentItem.step_to_next !== undefined) {
+			    _this.sequenceStepToNext = currentItem.step_to_next;
+			}
+			if (currentItem.x !== undefined) {
+			    _this.setSpriteXIndex(currentItem.x);
+			}
+			if (currentItem.y !== undefined) {
+			    _this.setSpriteYIndex(currentItem.y);
+			}
+			
+			if (_this.sequenceStepToNext) {
+			    canMoveToNext = false;
+			}
+        }
+		_this.prevSequenceIndex = _this.sequenceIndex;
+        var nextIndex = (_this.sequenceIndex + 1) % currentSequence.length;
+        var nextItem = currentSequence[nextIndex];
+		var nextX = nextItem.x != undefined ? nextItem.x : _this.sequenceX;
+		var nextY = nextItem.Y != undefined ? nextItem.Y : _this.sequenceY;
+		
+		if (_this.sequenceStepToNext && !indexChanged) {
+		    var XMoveNext = true;
+			var YMoveNext = true;
+			if (Math.abs(nextX - _this.sequenceX) > 1) {
+				_this.setSpriteXIndex(_this.sequenceX + (nextX > _this.sequenceX ? 1 : -1));
+				XMoveNext = Math.abs(nextX - _this.sequenceX) == 1;
+            }
+			if (Math.abs(nextY - _this.sequenceY) > 1) {
+				_this.setSpriteYIndex(_this.sequenceY + (nextY > _this.sequenceY ? 1 : -1));
+				YMoveNext = Math.abs(nextY - _this.sequenceY) == 1;
+            }
+			canMoveToNext = XMoveNext && YMoveNext;
+		   
+		}
+		if (canMoveToNext) {
+            _this.sequenceIndex = nextIndex;
+		}
+		_this.commitChanges();
+		
+    };
+
+    this.clone = function() {
+        var clone = {};
+        clone.prototype = this.prototype;
+        for (property in this) {
+            clone[property] = this[property];
+        }
+        return clone;
+    };
+    
+    this.startSequenceTimerFPS = function(fps) {
+        _this.sequenceFPS = fps;
+        if (_this.sequenceTimer != null) {
+            Script.clearInterval(_this.sequenceTimer);
+        }
+        _this.sequenceTimer = Script.setInterval(_this._renderFrame, 1000 / fps);
+    }
+
+    this.start = function(sequenceName) {
+        this.currentSequence = sequenceName;
+        this.sequenceFPS = this.defaultFPS;
+        this.startSequenceTimerFPS(this.defaultFPS);
+    };
+
+    if (this.sprite_properties.url !== undefined) {
+        this.setURL(this.sprite_properties.url);
+    }
+
+    if (this.sprite_properties.sprite_size !== undefined) {
+        this.setSpriteSize(this.sprite_properties.sprite_size);
+    }
+
+    if (this.sprite_properties.scale !== undefined) {
+        this.setScale(this.sprite_properties.scale);
+    }
+
+    if (this.sprite_properties.alpha !== undefined) {
+        this.setAlpha(this.sprite_properties.alpha);
+    }
+
+    if (this.sprite_properties.position !== undefined) {
+        this.setPosition(this.sprite_properties.position);
+    }
+
+    // set the overlay
+    this.overlay = Overlays.addOverlay("billboard", this.overlay_properties);
+    this.new_properties = {};
+
+    if (this.sprite_properties.startup_sequence != undefined) {
+        this.start(this.sprite_properties.startup_sequence);
+    }
+
+    Script.scriptEnding.connect(function () {
+        if (_this.sequenceTimer != null) {
+            Script.clearInterval(_this.sequenceTimer);
+        }
+        Overlays.deleteOverlay(_this.overlay);
+    });
+}
+
+var chrismastree = new SpriteBillboard({
+    position: getRandomPosAroundMyAvatar(6),
+    url: CHRISTMAS_TREE_SPRITES_URL,
+    sprite_size: {x: 0, y: 0, width: 250.000, height: 357.626},
+    scale: 6,
+    alpha: 1,
+    sequences: {"idle": [{x: 0, y: 0, step_to_next: true, fps: 3}, {x: 3, step_to_next: false}]},
+    startup_sequence: "idle"
+});
+
+var santa = new SpriteBillboard({
+    position: getRandomPosAroundMyAvatar(6),
+    url: SANTA_SPRITES_URL,
+    loop: true,
+    sprite_size: {x: 0, y: 0, width: 64, height:  72},
+    scale: 4,
+    alpha: 1,
+    sequences: {
+		"walk_left": [{x: 2, y: 0, step_to_next: true, fps: 4}, {x: 10, step_to_next: false}],
+		"walk_right": [{x: 10, y: 1, step_to_next: true, fps: 4}, {x: 2, step_to_next: false}],
+	},
+    startup_sequence: "walk_left"
+});
+
+var santa = new SpriteBillboard({
+    position: getRandomPosAroundMyAvatar(6),
+    url: SANTA_SPRITES_URL,
+    loop: true,
+    sprite_size: {x: 0, y: 0, width: 64, height:  72},
+    scale: 4,
+    alpha: 1,
+    sequences: {
+		"walk_left": [{x: 2, y: 0, step_to_next: true, fps: 4}, {x: 10, step_to_next: false}],
+		"walk_right": [{x: 10, y: 1, step_to_next: true, fps: 4}, {x: 2, step_to_next: false}],
+	},
+    startup_sequence: "walk_right"
+});
\ No newline at end of file
diff --git a/interface/src/ui/overlays/Grid3DOverlay.cpp b/interface/src/ui/overlays/Grid3DOverlay.cpp
index c628199fe3..be99612a1a 100644
--- a/interface/src/ui/overlays/Grid3DOverlay.cpp
+++ b/interface/src/ui/overlays/Grid3DOverlay.cpp
@@ -116,3 +116,15 @@ void Grid3DOverlay::setProperties(const QScriptValue& properties) {
         _majorGridEvery = properties.property("majorGridEvery").toVariant().toInt();
     }
 }
+
+Grid3DOverlay* Grid3DOverlay::createClone() {
+    Grid3DOverlay* clone = new Grid3DOverlay();
+    writeToClone(clone);
+    return clone;
+}
+
+void Grid3DOverlay::writeToClone(Grid3DOverlay* clone) {
+    Base3DOverlay::writeToClone(clone);
+    clone->_minorGridWidth = _minorGridWidth;
+    clone->_majorGridEvery = _majorGridEvery;
+}
diff --git a/interface/src/ui/overlays/Grid3DOverlay.h b/interface/src/ui/overlays/Grid3DOverlay.h
index b1675f15d7..319f298b2c 100644
--- a/interface/src/ui/overlays/Grid3DOverlay.h
+++ b/interface/src/ui/overlays/Grid3DOverlay.h
@@ -34,7 +34,11 @@ public:
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
 
+    virtual Grid3DOverlay* createClone();
+
 private:
+    virtual void writeToClone(Grid3DOverlay* clone);
+
     float _minorGridWidth;
     int _majorGridEvery;
 

From cbb3d463b697b958366dacb2f8100fd691aaaed9 Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Thu, 13 Nov 2014 23:29:05 +0100
Subject: [PATCH 18/38] Fixed Overlays::isLoaded which did not to find my just
 created overlay.

---
 interface/src/ui/overlays/Overlays.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/interface/src/ui/overlays/Overlays.cpp b/interface/src/ui/overlays/Overlays.cpp
index 6702c88125..00b16cf5b7 100644
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@@ -359,14 +359,14 @@ void RayToOverlayIntersectionResultFromScriptValue(const QScriptValue& object, R
 
 bool Overlays::isLoaded(unsigned int id) {
     QReadLocker lock(&_lock);
-    Overlay* overlay = _overlays2D.value(id);
-    if (!overlay) {
-        _overlays3D.value(id);
-    }
-    if (!overlay) {
+    Overlay* thisOverlay = NULL;
+    if (_overlays2D.contains(id)) {
+        thisOverlay = _overlays2D[id];
+    } else if (_overlays3D.contains(id)) {
+        thisOverlay = _overlays3D[id];
+    } else {
         return false; // not found
     }
-
-    return overlay->isLoaded();
+    return thisOverlay->isLoaded();
 }
 

From e964741e30d6ab49e39b003a1443f627733a924f Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Fri, 14 Nov 2014 00:01:51 +0100
Subject: [PATCH 19/38] added OverlayPreloader and made a bunch of clones

---
 examples/clonedOverlaysExample.js | 204 ++++++++++++++++--------------
 1 file changed, 110 insertions(+), 94 deletions(-)

diff --git a/examples/clonedOverlaysExample.js b/examples/clonedOverlaysExample.js
index aacca939f6..7aea048175 100644
--- a/examples/clonedOverlaysExample.js
+++ b/examples/clonedOverlaysExample.js
@@ -11,6 +11,9 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+const NUM_OF_TREES = 40;
+const NUM_OF_SANTAS = 20;
+
 // Image source: https://openclipart.org/detail/447/christmas-tree-by-theresaknott (heavily edited by Maximillian Merlin)
 const CHRISTMAS_TREE_SPRITES_URL = "http://test.thoys.nl/hifi/images/santa/christmas-tree.svg";
 
@@ -27,13 +30,31 @@ Array.prototype.contains = function(obj) {
     return false;
 };
 
-function getRandomPosAroundMyAvatar(radius) {
-    return {x: MyAvatar.position.x + Math.floor(Math.random() * radius * 2) - radius, y: MyAvatar.position.y, z: MyAvatar.position.z + Math.floor(Math.random() * radius * 2) - radius};
+function getRandomPosAroundMyAvatar(radius, height_offset) {
+    if (height_offset == undefined) {
+        height_offset = 0;
+    }
+    return {x: MyAvatar.position.x + Math.floor(Math.random() * radius * 2) - radius, y: MyAvatar.position.y + height_offset, z: MyAvatar.position.z + Math.floor(Math.random() * radius * 2) - radius};
 }
 
-function SpriteBillboard(sprite_properties) {
+function OverlayPreloader(overlay_type, overlay_properties, loaded_callback) {
     var _this = this;
+    this.loaded_callback = loaded_callback;
+    this.overlay = Overlays.addOverlay(overlay_type, overlay_properties);
+    this.timer = null;
+    this.timer = Script.setInterval(function() { 
+        if (Overlays.isLoaded(_this.overlay)) {
+            Script.clearInterval(_this.timer);
+            _this.loaded_callback();
+        }
+    }, 100);
+}
+
+function SpriteBillboard(sprite_properties, overlay) {
+    var _this = this;
+    
     // set properties
+    this.overlay = overlay;
     this.overlay_properties = {};
     this.sprite_properties = sprite_properties;
     this.edited_overlay_properties = [];
@@ -41,11 +62,11 @@ function SpriteBillboard(sprite_properties) {
     this.currentSequence = "";
     this.sequenceIndex = 0;
     this.sequenceFPS = 0;
-	this.sequenceStepToNext = false;
+    this.sequenceStepToNext = false;
     this.sequenceTimer = null;
     this.prevSequenceIndex = -1;
-	this.sequenceX = 0;
-	this.sequenceY = 0;
+    this.sequenceX = 0;
+    this.sequenceY = 0;
     
     this.spriteSize = {x: 0, y: 0, width: 32, height: 64};
     
@@ -67,12 +88,6 @@ function SpriteBillboard(sprite_properties) {
         return _this;
     };
 
-    this.setURL = function(url) {
-        this.overlay_properties.url = url;
-        this.editedProperty("url");
-        return _this;
-    }
-
     this.setAlpha = function(alpha) {
         this.overlay_properties.alpha = alpha;
         this.editedProperty("alpha");
@@ -92,14 +107,14 @@ function SpriteBillboard(sprite_properties) {
     };
     
     this.setSpriteXIndex = function(x_index) {
-	    _this.sequenceX = x_index;
+        _this.sequenceX = x_index;
         _this.overlay_properties.subImage.x = x_index * _this.overlay_properties.subImage.width;
         _this.editedProperty("subImage");
         return _this;
     }
     
     this.setSpriteYIndex = function(y_index) {
-	    _this.sequenceY = y_index;
+        _this.sequenceY = y_index;
         _this.overlay_properties.subImage.y = y_index * _this.overlay_properties.subImage.height;
         _this.editedProperty("subImage");
         return _this;
@@ -107,8 +122,8 @@ function SpriteBillboard(sprite_properties) {
 
     this.editOverlay = function(properties) {
         for (var key in properties) {
-             _this.overlay_properties[attrname] = properties[key];
-             _this.editedProperty(key);
+            _this.overlay_properties[attrname] = properties[key];
+            _this.editedProperty(key);
         }
         return _this;
     };
@@ -119,9 +134,9 @@ function SpriteBillboard(sprite_properties) {
              var key = _this.edited_overlay_properties[i];
              changed_properties[key] = _this.overlay_properties[key];
         }
-		if (Object.keys(changed_properties).length === 0) {
-		    return;
-		}
+        if (Object.keys(changed_properties).length === 0) {
+            return;
+        }
         Overlays.editOverlay(_this.overlay, changed_properties);
         _this.edited_overlay_properties = [];
     };
@@ -129,9 +144,9 @@ function SpriteBillboard(sprite_properties) {
     this._renderFrame = function() {
         var currentSequence = _this.sprite_properties.sequences[_this.currentSequence];
         var currentItem = currentSequence[_this.sequenceIndex];
-		var indexChanged = _this.sequenceIndex != _this.prevSequenceIndex;
-		var canMoveToNext = true;
-		_this.prevSequenceIndex = _this.sequenceIndex;
+        var indexChanged = _this.sequenceIndex != _this.prevSequenceIndex;
+        var canMoveToNext = true;
+        _this.prevSequenceIndex = _this.sequenceIndex;
         if (indexChanged) {
             if (currentItem.loop != undefined) {
                 _this.loopSequence = currentItem.loop;
@@ -139,45 +154,44 @@ function SpriteBillboard(sprite_properties) {
             if (currentItem.fps !== undefined && currentItem.fps != _this.sequenceFPS) {
                 _this.startSequenceTimerFPS(currentItem.fps);
             }
-			if (currentItem.step_to_next !== undefined) {
-			    _this.sequenceStepToNext = currentItem.step_to_next;
-			}
-			if (currentItem.x !== undefined) {
-			    _this.setSpriteXIndex(currentItem.x);
-			}
-			if (currentItem.y !== undefined) {
-			    _this.setSpriteYIndex(currentItem.y);
-			}
-			
-			if (_this.sequenceStepToNext) {
-			    canMoveToNext = false;
-			}
+            if (currentItem.step_to_next !== undefined) {
+                _this.sequenceStepToNext = currentItem.step_to_next;
+            }
+            if (currentItem.x !== undefined) {
+                _this.setSpriteXIndex(currentItem.x);
+            }
+            if (currentItem.y !== undefined) {
+                _this.setSpriteYIndex(currentItem.y);
+            }
+            
+            if (_this.sequenceStepToNext) {
+                canMoveToNext = false;
+            }
         }
-		_this.prevSequenceIndex = _this.sequenceIndex;
+        _this.prevSequenceIndex = _this.sequenceIndex;
         var nextIndex = (_this.sequenceIndex + 1) % currentSequence.length;
         var nextItem = currentSequence[nextIndex];
-		var nextX = nextItem.x != undefined ? nextItem.x : _this.sequenceX;
-		var nextY = nextItem.Y != undefined ? nextItem.Y : _this.sequenceY;
-		
-		if (_this.sequenceStepToNext && !indexChanged) {
-		    var XMoveNext = true;
-			var YMoveNext = true;
-			if (Math.abs(nextX - _this.sequenceX) > 1) {
-				_this.setSpriteXIndex(_this.sequenceX + (nextX > _this.sequenceX ? 1 : -1));
-				XMoveNext = Math.abs(nextX - _this.sequenceX) == 1;
+        var nextX = nextItem.x != undefined ? nextItem.x : _this.sequenceX;
+        var nextY = nextItem.Y != undefined ? nextItem.Y : _this.sequenceY;
+        
+        if (_this.sequenceStepToNext && !indexChanged) {
+            var XMoveNext = true;
+            var YMoveNext = true;
+            if (Math.abs(nextX - _this.sequenceX) > 1) {
+                _this.setSpriteXIndex(_this.sequenceX + (nextX > _this.sequenceX ? 1 : -1));
+                XMoveNext = Math.abs(nextX - _this.sequenceX) == 1;
             }
-			if (Math.abs(nextY - _this.sequenceY) > 1) {
-				_this.setSpriteYIndex(_this.sequenceY + (nextY > _this.sequenceY ? 1 : -1));
-				YMoveNext = Math.abs(nextY - _this.sequenceY) == 1;
+            if (Math.abs(nextY - _this.sequenceY) > 1) {
+                _this.setSpriteYIndex(_this.sequenceY + (nextY > _this.sequenceY ? 1 : -1));
+                YMoveNext = Math.abs(nextY - _this.sequenceY) == 1;
             }
-			canMoveToNext = XMoveNext && YMoveNext;
-		   
-		}
-		if (canMoveToNext) {
+            canMoveToNext = XMoveNext && YMoveNext;
+        }
+        if (canMoveToNext) {
             _this.sequenceIndex = nextIndex;
-		}
-		_this.commitChanges();
-		
+        }
+        _this.commitChanges();
+        
     };
 
     this.clone = function() {
@@ -223,14 +237,12 @@ function SpriteBillboard(sprite_properties) {
         this.setPosition(this.sprite_properties.position);
     }
 
-    // set the overlay
-    this.overlay = Overlays.addOverlay("billboard", this.overlay_properties);
-    this.new_properties = {};
+    _this.commitChanges();
 
     if (this.sprite_properties.startup_sequence != undefined) {
         this.start(this.sprite_properties.startup_sequence);
     }
-
+    
     Script.scriptEnding.connect(function () {
         if (_this.sequenceTimer != null) {
             Script.clearInterval(_this.sequenceTimer);
@@ -239,40 +251,44 @@ function SpriteBillboard(sprite_properties) {
     });
 }
 
-var chrismastree = new SpriteBillboard({
-    position: getRandomPosAroundMyAvatar(6),
-    url: CHRISTMAS_TREE_SPRITES_URL,
-    sprite_size: {x: 0, y: 0, width: 250.000, height: 357.626},
-    scale: 6,
-    alpha: 1,
-    sequences: {"idle": [{x: 0, y: 0, step_to_next: true, fps: 3}, {x: 3, step_to_next: false}]},
-    startup_sequence: "idle"
-});
+var christmastree_loader = null;
+christmastree_loader = new OverlayPreloader("billboard", 
+    {url: CHRISTMAS_TREE_SPRITES_URL, alpha: 0}, function() {
+        for (var i = 0; i < NUM_OF_TREES; i++) {
+            var clonedOverlay = Overlays.cloneOverlay(christmastree_loader.overlay);
+            new SpriteBillboard({
+                position: getRandomPosAroundMyAvatar(20),
+                sprite_size: {x: 0, y: 0, width: 250.000, height: 357.626},
+                scale: 6,
+                alpha: 1,
+                sequences: {"idle": [{x: 0, y: 0, step_to_next: true, fps: 3}, {x: 3, step_to_next: false}]},
+                startup_sequence: "idle"
+            }, clonedOverlay);
+        }
+    }
+);
 
-var santa = new SpriteBillboard({
-    position: getRandomPosAroundMyAvatar(6),
-    url: SANTA_SPRITES_URL,
-    loop: true,
-    sprite_size: {x: 0, y: 0, width: 64, height:  72},
-    scale: 4,
-    alpha: 1,
-    sequences: {
-		"walk_left": [{x: 2, y: 0, step_to_next: true, fps: 4}, {x: 10, step_to_next: false}],
-		"walk_right": [{x: 10, y: 1, step_to_next: true, fps: 4}, {x: 2, step_to_next: false}],
-	},
-    startup_sequence: "walk_left"
-});
+var santa_loader = null;
+santa_loader = new OverlayPreloader("billboard", 
+    {url: SANTA_SPRITES_URL, alpha: 0}, function() {
+        for (var i = 0; i < NUM_OF_SANTAS; i++) {
+            var clonedOverlay = Overlays.cloneOverlay(santa_loader.overlay);
+            new SpriteBillboard({
+                position: getRandomPosAroundMyAvatar(18, -1),
+                sprite_size: {x: 0, y: 0, width: 64, height:  72},
+                scale: 4,
+                alpha: 1,
+                sequences: {
+                    "walk_left": [{x: 2, y: 0, step_to_next: true, fps: 4}, {x: 10, step_to_next: false}],
+                    "walk_right": [{x: 10, y: 1, step_to_next: true, fps: 4}, {x: 2, step_to_next: false}],
+                },
+                startup_sequence: (i % 2 == 0) ? "walk_left" : "walk_right"
+            }, clonedOverlay);
+        }
+    }
+);
 
-var santa = new SpriteBillboard({
-    position: getRandomPosAroundMyAvatar(6),
-    url: SANTA_SPRITES_URL,
-    loop: true,
-    sprite_size: {x: 0, y: 0, width: 64, height:  72},
-    scale: 4,
-    alpha: 1,
-    sequences: {
-		"walk_left": [{x: 2, y: 0, step_to_next: true, fps: 4}, {x: 10, step_to_next: false}],
-		"walk_right": [{x: 10, y: 1, step_to_next: true, fps: 4}, {x: 2, step_to_next: false}],
-	},
-    startup_sequence: "walk_right"
-});
\ No newline at end of file
+Script.scriptEnding.connect(function () {
+    Overlays.deleteOverlay(christmastree_loader.overlay);
+    Overlays.deleteOverlay(santa_loader.overlay);
+});

From 11058355a01e98c3ac0e26c917224f4b7ae164bb Mon Sep 17 00:00:00 2001
From: ZappoMan <bradh@konamoxt.com>
Date: Fri, 14 Nov 2014 09:55:32 -0800
Subject: [PATCH 20/38] implement aboutToFinish for persist thread to allow
 final save before shutdown

---
 assignment-client/src/octree/OctreeServer.cpp |  3 ++
 libraries/entities/src/EntityTree.cpp         |  2 -
 libraries/octree/src/OctreePersistThread.cpp  | 38 +++++++++++++------
 libraries/octree/src/OctreePersistThread.h    |  4 ++
 4 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp
index 26cf94269b..34378effd3 100644
--- a/assignment-client/src/octree/OctreeServer.cpp
+++ b/assignment-client/src/octree/OctreeServer.cpp
@@ -1197,6 +1197,9 @@ void OctreeServer::aboutToFinish() {
         qDebug() << qPrintable(_safeServerName) << "server about to finish while node still connected node:" << *node;
         forceNodeShutdown(node);
     }
+    if (_persistThread) {
+        _persistThread->aboutToFinish();
+    }
     qDebug() << qPrintable(_safeServerName) << "server ENDING about to finish...";
 }
 
diff --git a/libraries/entities/src/EntityTree.cpp b/libraries/entities/src/EntityTree.cpp
index bc2823e15c..73957ad077 100644
--- a/libraries/entities/src/EntityTree.cpp
+++ b/libraries/entities/src/EntityTree.cpp
@@ -1089,7 +1089,6 @@ bool DebugOperator::preRecursion(OctreeElement* element) {
 }
 
 void EntityTree::dumpTree() {
-    // First, look for the existing entity in the tree..
     DebugOperator theOperator;
     recurseTreeWithOperator(&theOperator);
 }
@@ -1107,7 +1106,6 @@ bool PruneOperator::postRecursion(OctreeElement* element) {
 }
 
 void EntityTree::pruneTree() {
-    // First, look for the existing entity in the tree..
     PruneOperator theOperator;
     recurseTreeWithOperator(&theOperator);
 }
diff --git a/libraries/octree/src/OctreePersistThread.cpp b/libraries/octree/src/OctreePersistThread.cpp
index 406681c2c5..dd81b3ff4d 100644
--- a/libraries/octree/src/OctreePersistThread.cpp
+++ b/libraries/octree/src/OctreePersistThread.cpp
@@ -78,19 +78,33 @@ bool OctreePersistThread::process() {
         quint64 intervalToCheck = _persistInterval * MSECS_TO_USECS;
 
         if (sinceLastSave > intervalToCheck) {
-            // check the dirty bit and persist here...
-            _lastCheck = usecTimestampNow();
-            if (_tree->isDirty()) {
-                qDebug() << "pruning Octree before saving...";
-                _tree->pruneTree();
-                qDebug() << "DONE pruning Octree before saving...";
-            
-                qDebug() << "saving Octree to file " << _filename << "...";
-                _tree->writeToSVOFile(_filename.toLocal8Bit().constData());
-                _tree->clearDirtyBit(); // tree is clean after saving
-                qDebug("DONE saving Octree to file...");
-            }
+            _lastCheck = now;
+            persistOperation();
         }
     }
     return isStillRunning();  // keep running till they terminate us
 }
+
+
+void OctreePersistThread::aboutToFinish() {
+    qDebug() << "Persist thread about to finish...";
+    persistOperation();
+    qDebug() << "Persist thread done with about to finish...";
+}
+
+void OctreePersistThread::persistOperation() {
+    if (_tree->isDirty()) {
+        _tree->lockForWrite();
+        {
+            qDebug() << "pruning Octree before saving...";
+            _tree->pruneTree();
+            qDebug() << "DONE pruning Octree before saving...";
+        }
+        _tree->unlock();
+
+        qDebug() << "saving Octree to file " << _filename << "...";
+        _tree->writeToSVOFile(_filename.toLocal8Bit().constData());
+        _tree->clearDirtyBit(); // tree is clean after saving
+        qDebug("DONE saving Octree to file...");
+    }
+}
diff --git a/libraries/octree/src/OctreePersistThread.h b/libraries/octree/src/OctreePersistThread.h
index 2f86320b2e..c4bccd55b9 100644
--- a/libraries/octree/src/OctreePersistThread.h
+++ b/libraries/octree/src/OctreePersistThread.h
@@ -29,12 +29,16 @@ public:
     bool isInitialLoadComplete() const { return _initialLoadComplete; }
     quint64 getLoadElapsedTime() const { return _loadTimeUSecs; }
 
+    void aboutToFinish(); /// call this to inform the persist thread that the owner is about to finish to support final persist
+
 signals:
     void loadCompleted();
 
 protected:
     /// Implements generic processing behavior for this thread.
     virtual bool process();
+    
+    void persistOperation();
 private:
     Octree* _tree;
     QString _filename;

From 76ae60c5caaa5cd8ddfa9c5bd972bedeaadb937e Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Fri, 14 Nov 2014 19:27:27 +0100
Subject: [PATCH 21/38] fix Ubuntu build

---
 interface/src/ui/overlays/TextOverlay.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interface/src/ui/overlays/TextOverlay.cpp b/interface/src/ui/overlays/TextOverlay.cpp
index 70d82ec28e..19f85aed68 100644
--- a/interface/src/ui/overlays/TextOverlay.cpp
+++ b/interface/src/ui/overlays/TextOverlay.cpp
@@ -133,7 +133,7 @@ TextOverlay* TextOverlay::createClone() {
 
 void TextOverlay::writeToClone(TextOverlay* clone) {
     Overlay2D::writeToClone(clone);
-    clone->_text = QString::QString(_text);
+    clone->_text = _text;
     clone->_backgroundColor = _backgroundColor;
     clone->_leftMargin = _leftMargin;
     clone->_topMargin = _topMargin;

From fa03a7eb0cac1991c3d9172364ecba18ef2570a5 Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Fri, 14 Nov 2014 19:53:56 +0100
Subject: [PATCH 22/38] fix ubuntu build

---
 interface/src/ui/overlays/BillboardOverlay.cpp | 2 +-
 interface/src/ui/overlays/ImageOverlay.cpp     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/interface/src/ui/overlays/BillboardOverlay.cpp b/interface/src/ui/overlays/BillboardOverlay.cpp
index aec5e993dd..f1d991d5cb 100644
--- a/interface/src/ui/overlays/BillboardOverlay.cpp
+++ b/interface/src/ui/overlays/BillboardOverlay.cpp
@@ -210,5 +210,5 @@ void BillboardOverlay::writeToClone(BillboardOverlay* clone) {
     clone->setIsFacingAvatar(_isFacingAvatar);
     clone->setClipFromSource(_fromImage);
     clone->_url = _url;
-    clone->_billboard = QByteArray::QByteArray(_billboard);
+    clone->_billboard = _billboard;
 }
diff --git a/interface/src/ui/overlays/ImageOverlay.cpp b/interface/src/ui/overlays/ImageOverlay.cpp
index 6c2b09018e..04038834c2 100644
--- a/interface/src/ui/overlays/ImageOverlay.cpp
+++ b/interface/src/ui/overlays/ImageOverlay.cpp
@@ -160,6 +160,6 @@ ImageOverlay* ImageOverlay::createClone() {
 void ImageOverlay::writeToClone(ImageOverlay* clone) {
     Overlay2D::writeToClone(clone);
     clone->_imageURL = _imageURL;
-    clone->_textureImage = QImage::QImage(_textureImage);
+    clone->_textureImage = _textureImage;
     clone->_renderImage = _renderImage;
 }

From cd4b2677324981374c2d63b1d8d485a59eebff08 Mon Sep 17 00:00:00 2001
From: ZappoMan <bradh@konamoxt.com>
Date: Fri, 14 Nov 2014 11:11:32 -0800
Subject: [PATCH 23/38] implement persist backup

---
 assignment-client/src/octree/OctreeServer.cpp | 25 ++++++-
 assignment-client/src/octree/OctreeServer.h   |  5 ++
 libraries/octree/src/OctreePersistThread.cpp  | 74 +++++++++++++++----
 libraries/octree/src/OctreePersistThread.h    | 16 +++-
 4 files changed, 101 insertions(+), 19 deletions(-)

diff --git a/assignment-client/src/octree/OctreeServer.cpp b/assignment-client/src/octree/OctreeServer.cpp
index 34378effd3..f78a9a2b30 100644
--- a/assignment-client/src/octree/OctreeServer.cpp
+++ b/assignment-client/src/octree/OctreeServer.cpp
@@ -1020,7 +1020,7 @@ void OctreeServer::readConfiguration() {
     bool noPersist;
     readOptionBool(QString("NoPersist"), settingsSectionObject, noPersist);
     _wantPersist = !noPersist;
-    qDebug("wantPersist=%s", debug::valueOf(_wantPersist));
+    qDebug() << "wantPersist=" << _wantPersist;
 
     if (_wantPersist) {
         QString persistFilename;
@@ -1029,6 +1029,26 @@ void OctreeServer::readConfiguration() {
         }
         strcpy(_persistFilename, qPrintable(persistFilename));
         qDebug("persistFilename=%s", _persistFilename);
+
+        _persistInterval = OctreePersistThread::DEFAULT_PERSIST_INTERVAL;
+        readOptionInt(QString("persistInterval"), settingsSectionObject, _persistInterval);
+        qDebug() << "persistInterval=" << _persistInterval;
+
+        bool noBackup;
+        readOptionBool(QString("NoBackup"), settingsSectionObject, noBackup);
+        _wantBackup = !noBackup;
+        qDebug() << "wantBackup=" << _wantBackup;
+
+        if (_wantBackup) {
+            _backupExtensionFormat = OctreePersistThread::DEFAULT_BACKUP_EXTENSION_FORMAT;
+            readOptionString(QString("backupExtensionFormat"), settingsSectionObject, _backupExtensionFormat);
+            qDebug() << "backupExtensionFormat=" << _backupExtensionFormat;
+
+            _backupInterval = OctreePersistThread::DEFAULT_BACKUP_INTERVAL;
+            readOptionInt(QString("backupInterval"), settingsSectionObject, _backupInterval);
+            qDebug() << "backupInterval=" << _backupInterval;
+        }
+
     } else {
         qDebug("persistFilename= DISABLED");
     }
@@ -1112,7 +1132,8 @@ void OctreeServer::run() {
     if (_wantPersist) {
 
         // now set up PersistThread
-        _persistThread = new OctreePersistThread(_tree, _persistFilename);
+        _persistThread = new OctreePersistThread(_tree, _persistFilename, _persistInterval,
+                                    _wantBackup, _backupInterval, _backupExtensionFormat);
         if (_persistThread) {
             _persistThread->initialize(true);
         }
diff --git a/assignment-client/src/octree/OctreeServer.h b/assignment-client/src/octree/OctreeServer.h
index b05896596c..8a91b94da0 100644
--- a/assignment-client/src/octree/OctreeServer.h
+++ b/assignment-client/src/octree/OctreeServer.h
@@ -167,6 +167,11 @@ protected:
     JurisdictionSender* _jurisdictionSender;
     OctreeInboundPacketProcessor* _octreeInboundPacketProcessor;
     OctreePersistThread* _persistThread;
+    
+    int _persistInterval;
+    bool _wantBackup;
+    QString _backupExtensionFormat;
+    int _backupInterval;
 
     static OctreeServer* _instance;
 
diff --git a/libraries/octree/src/OctreePersistThread.cpp b/libraries/octree/src/OctreePersistThread.cpp
index dd81b3ff4d..f8afb52b85 100644
--- a/libraries/octree/src/OctreePersistThread.cpp
+++ b/libraries/octree/src/OctreePersistThread.cpp
@@ -15,12 +15,23 @@
 
 #include "OctreePersistThread.h"
 
-OctreePersistThread::OctreePersistThread(Octree* tree, const QString& filename, int persistInterval) :
+const int OctreePersistThread::DEFAULT_PERSIST_INTERVAL = 1000 * 30; // every 30 seconds
+const int OctreePersistThread::DEFAULT_BACKUP_INTERVAL = 1000 * 60 * 1; // every 1 minutes
+const QString OctreePersistThread::DEFAULT_BACKUP_EXTENSION_FORMAT(".backup.%Y-%m-%d.%H:%M:%S.%z");
+
+
+OctreePersistThread::OctreePersistThread(Octree* tree, const QString& filename, int persistInterval, 
+                                                bool wantBackup, int backupInterval, const QString& backupExtensionFormat) :
     _tree(tree),
     _filename(filename),
+    _backupExtensionFormat(backupExtensionFormat),
     _persistInterval(persistInterval),
+    _backupInterval(backupInterval),
     _initialLoadComplete(false),
-    _loadTimeUSecs(0) 
+    _loadTimeUSecs(0),
+    _lastCheck(0),
+    _lastBackup(0),
+    _wantBackup(wantBackup)
 {
 }
 
@@ -51,16 +62,22 @@ bool OctreePersistThread::process() {
         unsigned long leafNodeCount = OctreeElement::getLeafNodeCount();
         qDebug("Nodes after loading scene %lu nodes %lu internal %lu leaves", nodeCount, internalNodeCount, leafNodeCount);
 
-        double usecPerGet = (double)OctreeElement::getGetChildAtIndexTime() / (double)OctreeElement::getGetChildAtIndexCalls();
-        qDebug() << "getChildAtIndexCalls=" << OctreeElement::getGetChildAtIndexCalls()
-                << " getChildAtIndexTime=" << OctreeElement::getGetChildAtIndexTime() << " perGet=" << usecPerGet;
+        bool wantDebug = false;
+        if (wantDebug) {
+            double usecPerGet = (double)OctreeElement::getGetChildAtIndexTime() 
+                                    / (double)OctreeElement::getGetChildAtIndexCalls();
+            qDebug() << "getChildAtIndexCalls=" << OctreeElement::getGetChildAtIndexCalls()
+                    << " getChildAtIndexTime=" << OctreeElement::getGetChildAtIndexTime() << " perGet=" << usecPerGet;
 
-        double usecPerSet = (double)OctreeElement::getSetChildAtIndexTime() / (double)OctreeElement::getSetChildAtIndexCalls();
-        qDebug() << "setChildAtIndexCalls=" << OctreeElement::getSetChildAtIndexCalls()
-                << " setChildAtIndexTime=" << OctreeElement::getSetChildAtIndexTime() << " perset=" << usecPerSet;
+            double usecPerSet = (double)OctreeElement::getSetChildAtIndexTime() 
+                                    / (double)OctreeElement::getSetChildAtIndexCalls();
+            qDebug() << "setChildAtIndexCalls=" << OctreeElement::getSetChildAtIndexCalls()
+                    << " setChildAtIndexTime=" << OctreeElement::getSetChildAtIndexTime() << " perSet=" << usecPerSet;
+        }
 
         _initialLoadComplete = true;
-        _lastCheck = usecTimestampNow(); // we just loaded, no need to save again
+        _lastBackup = _lastCheck = usecTimestampNow(); // we just loaded, no need to save again
+        time(&_lastPersistTime);
 
         emit loadCompleted();
     }
@@ -79,7 +96,7 @@ bool OctreePersistThread::process() {
 
         if (sinceLastSave > intervalToCheck) {
             _lastCheck = now;
-            persistOperation();
+            persist();
         }
     }
     return isStillRunning();  // keep running till they terminate us
@@ -88,11 +105,11 @@ bool OctreePersistThread::process() {
 
 void OctreePersistThread::aboutToFinish() {
     qDebug() << "Persist thread about to finish...";
-    persistOperation();
+    persist();
     qDebug() << "Persist thread done with about to finish...";
 }
 
-void OctreePersistThread::persistOperation() {
+void OctreePersistThread::persist() {
     if (_tree->isDirty()) {
         _tree->lockForWrite();
         {
@@ -102,9 +119,38 @@ void OctreePersistThread::persistOperation() {
         }
         _tree->unlock();
 
+        backup(); // handle backup if requested        
+
         qDebug() << "saving Octree to file " << _filename << "...";
-        _tree->writeToSVOFile(_filename.toLocal8Bit().constData());
+        _tree->writeToSVOFile(qPrintable(_filename));
+        time(&_lastPersistTime);
         _tree->clearDirtyBit(); // tree is clean after saving
-        qDebug("DONE saving Octree to file...");
+        qDebug() << "DONE saving Octree to file...";
+    }
+}
+
+void OctreePersistThread::backup() {
+    if (_wantBackup) {
+        quint64 now = usecTimestampNow();
+        quint64 sinceLastBackup = now - _lastBackup;
+        quint64 MSECS_TO_USECS = 1000;
+        quint64 intervalToBackup = _backupInterval * MSECS_TO_USECS;
+        
+        if (sinceLastBackup > intervalToBackup) {
+            struct tm* localTime = localtime(&_lastPersistTime);
+
+            char backupExtension[256];
+            strftime(backupExtension, sizeof(backupExtension), qPrintable(_backupExtensionFormat), localTime);
+
+            QString backupFileName = _filename + backupExtension;
+
+            qDebug() << "backing up persist file " << _filename << "to" << backupFileName << "...";
+            int result = rename(qPrintable(_filename), qPrintable(backupFileName));
+            if (result == 0) {
+                qDebug() << "DONE backing up persist file...";
+            } else {
+                qDebug() << "ERROR in backing up persist file...";
+            }
+        }
     }
 }
diff --git a/libraries/octree/src/OctreePersistThread.h b/libraries/octree/src/OctreePersistThread.h
index c4bccd55b9..c02e416e25 100644
--- a/libraries/octree/src/OctreePersistThread.h
+++ b/libraries/octree/src/OctreePersistThread.h
@@ -22,9 +22,13 @@
 class OctreePersistThread : public GenericThread {
     Q_OBJECT
 public:
-    static const int DEFAULT_PERSIST_INTERVAL = 1000 * 30; // every 30 seconds
+    static const int DEFAULT_PERSIST_INTERVAL;
+    static const int DEFAULT_BACKUP_INTERVAL;
+    static const QString DEFAULT_BACKUP_EXTENSION_FORMAT;
 
-    OctreePersistThread(Octree* tree, const QString& filename, int persistInterval = DEFAULT_PERSIST_INTERVAL);
+    OctreePersistThread(Octree* tree, const QString& filename, int persistInterval = DEFAULT_PERSIST_INTERVAL, 
+                                bool wantBackup = true, int backupInterval = DEFAULT_BACKUP_INTERVAL,
+                                const QString& backupExtensionFormat = DEFAULT_BACKUP_EXTENSION_FORMAT);
 
     bool isInitialLoadComplete() const { return _initialLoadComplete; }
     quint64 getLoadElapsedTime() const { return _loadTimeUSecs; }
@@ -38,15 +42,21 @@ protected:
     /// Implements generic processing behavior for this thread.
     virtual bool process();
     
-    void persistOperation();
+    void persist();
+    void backup();
 private:
     Octree* _tree;
     QString _filename;
+    QString _backupExtensionFormat;
     int _persistInterval;
+    int _backupInterval;
     bool _initialLoadComplete;
 
     quint64 _loadTimeUSecs;
     quint64 _lastCheck;
+    quint64 _lastBackup;
+    bool _wantBackup;
+    time_t _lastPersistTime;
 };
 
 #endif // hifi_OctreePersistThread_h

From 6ee4e611ac0634c942ef0fc826fdc443f40d7aa5 Mon Sep 17 00:00:00 2001
From: ZappoMan <bradh@konamoxt.com>
Date: Fri, 14 Nov 2014 11:31:06 -0800
Subject: [PATCH 24/38] add persist settings to domain settings, make default
 backup interval 30 minutes

---
 .../resources/describe-settings.json          | 93 ++++++++++++++++++-
 libraries/octree/src/OctreePersistThread.cpp  |  2 +-
 2 files changed, 93 insertions(+), 2 deletions(-)

diff --git a/domain-server/resources/describe-settings.json b/domain-server/resources/describe-settings.json
index ba4cfe8dfd..04c48e460e 100644
--- a/domain-server/resources/describe-settings.json
+++ b/domain-server/resources/describe-settings.json
@@ -276,6 +276,52 @@
     "label": "Entity Server Settings",
     "assignment-types": [6],
     "settings": [
+      {
+        "name": "persistFilename",
+        "label": "Persistant Filename",
+        "help": "the filename for your entities",
+        "placeholder": "resources/models.svo",
+        "default": "resources/models.svo",
+        "advanced": true
+      },
+      {
+        "name": "persistInterval",
+        "label": "Persist Interval",
+        "help": "Interval between persist checks in msecs.",
+        "placeholder": "30000",
+        "default": "30000",
+        "advanced": true
+      },
+      {
+        "name": "NoPersist",
+        "type": "checkbox",
+        "help": "Don't persist your entities to a file.",
+        "default": false,
+        "advanced": true
+      },
+      {
+        "name": "backupExtensionFormat",
+        "label": "Backup File Extension Format:",
+        "help": "Format used to create the extension for the backup of your persisted entities.",
+        "placeholder": ".backup.%Y-%m-%d.%H:%M:%S.%z",
+        "default": ".backup.%Y-%m-%d.%H:%M:%S.%z",
+        "advanced": true
+      },
+      {
+        "name": "backupInterval",
+        "label": "Backup Interval",
+        "help": "Interval between backup checks in msecs.",
+        "placeholder": "1800000",
+        "default": "1800000",
+        "advanced": true
+      },
+      {
+        "name": "NoBackup",
+        "type": "checkbox",
+        "help": "Don't regularly backup your persisted entities to a backup file.",
+        "default": false,
+        "advanced": true
+      },
       {
         "name": "statusHost",
         "label": "Status Hostname",
@@ -330,7 +376,52 @@
     "label": "Voxel Server Settings",
     "assignment-types": [3],
     "settings": [
-
+      {
+        "name": "persistFilename",
+        "label": "Persistant Filename",
+        "help": "the filename for your voxels",
+        "placeholder": "resources/voxels.svo",
+        "default": "resources/voxels.svo",
+        "advanced": true
+      },
+      {
+        "name": "persistInterval",
+        "label": "Persist Interval",
+        "help": "Interval between persist checks in msecs.",
+        "placeholder": "30000",
+        "default": "30000",
+        "advanced": true
+      },
+      {
+        "name": "NoPersist",
+        "type": "checkbox",
+        "help": "Don't persist your voxels to a file.",
+        "default": false,
+        "advanced": true
+      },
+      {
+        "name": "backupExtensionFormat",
+        "label": "Backup File Extension Format:",
+        "help": "Format used to create the extension for the backup of your persisted voxels.",
+        "placeholder": ".backup.%Y-%m-%d.%H:%M:%S.%z",
+        "default": ".backup.%Y-%m-%d.%H:%M:%S.%z",
+        "advanced": true
+      },
+      {
+        "name": "backupInterval",
+        "label": "Backup Interval",
+        "help": "Interval between backup checks in msecs.",
+        "placeholder": "1800000",
+        "default": "1800000",
+        "advanced": true
+      },
+      {
+        "name": "NoBackup",
+        "type": "checkbox",
+        "help": "Don't regularly backup your persisted voxels to a backup file.",
+        "default": false,
+        "advanced": true
+      },
       {
         "name": "statusHost",
         "label": "Status Hostname",
diff --git a/libraries/octree/src/OctreePersistThread.cpp b/libraries/octree/src/OctreePersistThread.cpp
index f8afb52b85..79507eae64 100644
--- a/libraries/octree/src/OctreePersistThread.cpp
+++ b/libraries/octree/src/OctreePersistThread.cpp
@@ -16,7 +16,7 @@
 #include "OctreePersistThread.h"
 
 const int OctreePersistThread::DEFAULT_PERSIST_INTERVAL = 1000 * 30; // every 30 seconds
-const int OctreePersistThread::DEFAULT_BACKUP_INTERVAL = 1000 * 60 * 1; // every 1 minutes
+const int OctreePersistThread::DEFAULT_BACKUP_INTERVAL = 1000 * 60 * 30; // every 30 minutes
 const QString OctreePersistThread::DEFAULT_BACKUP_EXTENSION_FORMAT(".backup.%Y-%m-%d.%H:%M:%S.%z");
 
 

From 899a3985a5ef56c16e54397746880b6c37b92555 Mon Sep 17 00:00:00 2001
From: ZappoMan <bradh@konamoxt.com>
Date: Fri, 14 Nov 2014 11:32:18 -0800
Subject: [PATCH 25/38] OctreePersistThread defaults to no backup, server
 always uses settings

---
 libraries/octree/src/OctreePersistThread.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libraries/octree/src/OctreePersistThread.h b/libraries/octree/src/OctreePersistThread.h
index c02e416e25..06b97b2dcb 100644
--- a/libraries/octree/src/OctreePersistThread.h
+++ b/libraries/octree/src/OctreePersistThread.h
@@ -27,7 +27,7 @@ public:
     static const QString DEFAULT_BACKUP_EXTENSION_FORMAT;
 
     OctreePersistThread(Octree* tree, const QString& filename, int persistInterval = DEFAULT_PERSIST_INTERVAL, 
-                                bool wantBackup = true, int backupInterval = DEFAULT_BACKUP_INTERVAL,
+                                bool wantBackup = false, int backupInterval = DEFAULT_BACKUP_INTERVAL,
                                 const QString& backupExtensionFormat = DEFAULT_BACKUP_EXTENSION_FORMAT);
 
     bool isInitialLoadComplete() const { return _initialLoadComplete; }

From de12b2543dfddedac9d9016aad1b96a74a0d0dca Mon Sep 17 00:00:00 2001
From: ZappoMan <bradh@konamoxt.com>
Date: Fri, 14 Nov 2014 11:50:45 -0800
Subject: [PATCH 26/38] winblows

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

diff --git a/libraries/octree/src/OctreePersistThread.cpp b/libraries/octree/src/OctreePersistThread.cpp
index 79507eae64..f74ddfa5f0 100644
--- a/libraries/octree/src/OctreePersistThread.cpp
+++ b/libraries/octree/src/OctreePersistThread.cpp
@@ -9,6 +9,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+#include <time.h>
+
 #include <QDebug>
 #include <PerfStat.h>
 #include <SharedUtil.h>

From a1bd5623e1d453e87bd36545bd7e9af6648af458 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 12:04:49 -0800
Subject: [PATCH 27/38] refactor + solved network issues

---
 examples/entityScripts/chessPiece.js | 226 ++++++++++++++++-----------
 examples/playChess.js                | 189 +++++++++++-----------
 2 files changed, 241 insertions(+), 174 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index 17b186d396..f6a2c46d28 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -1,61 +1,101 @@
 (function(){
-  this.GRID_POSITION = { x: 1, y: 1, z: 1 };
-  this.GRID_SIZE = 1.0;
-  this.metadata = null;
-  this.sound = null;
+  this.FIRST_TILE = null; // Global position of the first tile (1a)
+  this.TILE_SIZE = null; // Size of one tile
+  this.whitesDeadPieces = null;
+  this.blacksDeadPieces = null;
+  
+  this.wantDebug = false;
+  this.active = false;
+  
   this.entityID = null;
   this.properties = null;
+  this.boardID = null;
+  this.boardUserData = null;
+  
+  this.sound = null;
   this.startingTile = null;
   this.pieces = new Array();
   
+  // All callbacks start by updating the properties
   this.updateProperties = function(entityID) {
-    if (this.entityID === null) {
-      this.entityID = entityID;
-    }
-    if (!entityID.isKnownID || this.entityID.id !== entityID.id) {
-      print("Something is very wrong: Bailing!");
-      return;
+    // Piece ID
+    if (this.entityID === null || !this.entityID.isKnownID) {
+      this.entityID = Entities.identifyEntity(entityID);
     }
+    // Piece Properties
     this.properties = Entities.getEntityProperties(this.entityID);
-    if (!this.properties.isKnownID) {
-      print("Unknown entityID " + this.entityID.id + " should be self.")
-    } 
-  }
-  
-  this.updatePosition = function(mouseEvent) {
-    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);
-    if (this.isOutsideGrid(this.getIndexPosition(intersection))) {
-      intersection = this.getAbsolutePosition(this.startingTile);
-    }
-    Entities.editEntity(this.entityID, { position: intersection });
-    //this.moveDeadPiece();
-  }
-  this.isOutsideGrid = function(pos) {
-    return !(pos.i >= 0 && pos.j >= 0 && pos.i <= 9 && pos.j <= 9);
-  }
-  this.getIndexPosition = function(position) {
-    var tileSize = this.GRID_SIZE / 10.0;
-    var relative = Vec3.subtract(position, this.GRID_POSITION);
-    return {
-      i: Math.floor(relative.x / tileSize),
-      j: Math.floor(relative.z / tileSize)
-    }
-  }
-  this.getAbsolutePosition = function(pos) {
-    var tileSize = this.GRID_SIZE / 10.0;
-    var relative = Vec3.subtract(this.properties.position, this.GRID_POSITION);
-    relative.x = (pos.i + 0.5) * tileSize;
-    relative.z = (pos.j + 0.5) * tileSize;
     
-    return Vec3.sum(this.GRID_POSITION, relative);
+    // Board ID
+    if (this.boardID === null) {
+      // Read user data string and update boardID
+      var userData = JSON.parse(this.properties.userData);
+      var boardID = Entities.identifyEntity(userData.boardID);
+      if (boardID.isKnownID) {
+        this.boardID = boardID;
+      } else {
+        return;
+      }
+    }
+    
+    // Board User Data
+    this.updateUserData();
   }
-  this.snapToGrid = function() {
-    var pos = this.getIndexPosition(this.properties.position);
-    var finalPos = this.getAbsolutePosition((this.isOutsideGrid(pos)) ?  this.startingTile : pos);
-    Entities.editEntity(this.entityID, { position: finalPos });
+  // Get an entity's user data
+  this.getEntityUserData = function(entityID) {
+    var properties = Entities.getEntityProperties(entityID);
+    
+    if (properties && properties.userData){
+      return JSON.parse(properties.userData);
+    } else {
+      print("No user data found.");
+      return null;
+    }
+  }
+  // Updates user data related objects
+  this.updateUserData = function() {
+    // Get board's user data
+    if (this.boardID !== null && this.boardID.isKnownID) {
+      this.boardUserData = this.getEntityUserData(this.boardID);
+      if (!(this.boardUserData &&
+            this.boardUserData.firstTile &&
+            this.boardUserData.tileSize &&
+            this.boardUserData.whitesDeadPieces &&
+            this.boardUserData.blacksDeadPieces)) {
+        print("Incomplete boardUserData " + this.boardID.id);
+      } else {
+        this.FIRST_TILE = this.boardUserData.firstTile;
+        this.TILE_SIZE = this.boardUserData.tileSize;
+        this.whitesDeadPieces = this.boardUserData.whitesDeadPieces;
+        this.blacksDeadPieces = this.boardUserData.blacksDeadPieces;
+        
+        this.active = true;
+      }
+    } else {
+      print("Missing boardID:" + JSON.stringify(this.boardID));
+    }
+  }
+  // Returns whether pos is inside the grid or not
+  this.isOutsideGrid = function(pos) {
+    return !(pos.i >= 0 && pos.j >= 0 && pos.i < 8 && pos.j < 8);
+  }
+  // Returns the tile coordinate
+  this.getIndexPosition = function(position) {
+    var halfTile = this.TILE_SIZE / 2.0;
+    var corner = Vec3.sum(this.FIRST_TILE, { x: -halfTile, y: 0.0, z: -halfTile });
+    var relative = Vec3.subtract(position, corner);
+    return {
+      i: Math.floor(relative.x / this.TILE_SIZE),
+      j: Math.floor(relative.z / this.TILE_SIZE)
+    }
+  }
+  // Returns the world position
+  this.getAbsolutePosition = function(pos, halfHeight) {
+    var relative = {
+      x: pos.i * this.TILE_SIZE,
+      y: halfHeight,
+      z: pos.j * this.TILE_SIZE
+    }
+    return Vec3.sum(this.FIRST_TILE, relative);
   }
   // Pr, Vr are respectively the Ray's Point of origin and Vector director
   // Pp, Np are respectively the Plane's Point of origin and Normal vector
@@ -64,75 +104,87 @@
     var t = -(Vec3.dot(Pr, Np) + d) / Vec3.dot(Vr, Np);
     return Vec3.sum(Pr, Vec3.multiply(t, Vr));
   }
+  // Download sound if needed
   this.maybeDownloadSound = function() {
     if (this.sound === null) {
-      this.sound = new Sound("http://public.highfidelity.io/sounds/Footsteps/FootstepW3Left-12db.wav");
+      this.sound = SoundCache.getSound("http://public.highfidelity.io/sounds/Footsteps/FootstepW3Left-12db.wav");
     }
   }
-  
+  // Play drop sound
   this.playSound = function() {
-    if (this.sound !== null && this.sound.downloaded) {
+    if (this.sound && this.sound.downloaded) {
   		Audio.playSound(this.sound, { position: this.properties.position });
-      print("playing sound");
     }
   }
-  this.getMetadata = function() {
-    if (this.properties.animationURL !== "") {
-      var metadataObject = JSON.parse(this.properties.animationURL);
-      if (metadataObject.gamePosition) {
-        this.GRID_POSITION = metadataObject.gamePosition;
-      }
-      if (metadataObject.gameSize) {
-        this.GRID_SIZE = metadataObject.gameSize;
-      }
-      if (metadataObject.pieces) {
-        this.pieces = metadataObject.pieces;
-      }
+  // updates the piece position based on mouse input
+  this.updatePosition = function(mouseEvent) {
+    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);                                 
+    // if piece outside grid then send it back to the starting tile
+    if (this.isOutsideGrid(this.getIndexPosition(intersection))) {
+      intersection = this.getAbsolutePosition(this.startingTile, this.properties.dimensions.y / 2.0);
     }
+    Entities.editEntity(this.entityID, { position: intersection });
+  }
+  // Snap piece to the center of the tile it is on
+  this.snapToGrid = function() {
+    var pos = this.getIndexPosition(this.properties.position);
+    var finalPos = this.getAbsolutePosition((this.isOutsideGrid(pos)) ?  this.startingTile : pos,
+                                            this.properties.dimensions.y / 2.0);
+    Entities.editEntity(this.entityID, { position: finalPos });
+  }
+  this.moveDeadPiece = function() {
+    return;
+     var myPos = this.getIndexPosition(this.properties.position);
+     for (var i = 0; i < this.pieces.length; i++) {
+       if (this.pieces[i].id != this.entityID.id) {
+         var piecePos = this.getIndexPosition(Entities.getEntityProperties(this.pieces[i]).position);
+         if (myPos.i === piecePos.i && myPos.j === piecePos.j) {
+           Entities.editEntity(this.pieces[i], { position: this.getAbsolutePosition({ i: 0, j: 0 })});
+           break;
+         }
+       }
+     }
   }
 
   
   this.grab = function(mouseEvent) {
-    this.startingTile = this.getIndexPosition(this.properties.position);
-    this.updatePosition(mouseEvent);
+    if (this.active) {
+      this.startingTile = this.getIndexPosition(this.properties.position);
+      this.updatePosition(mouseEvent);
+    }
   }
   this.move = function(mouseEvent) {
-    this.updatePosition(mouseEvent);
+    if (this.active) {
+      this.updatePosition(mouseEvent);
+    }
   }
   this.release = function(mouseEvent) {
-    this.updatePosition(mouseEvent);
-    this.snapToGrid();
-    
-    this.playSound();
-  }
-  this.moveDeadPiece = function() {
-    var myPos = this.getIndexPosition(this.properties.position);
-    for (var i = 0; i < this.pieces.length; i++) {
-      if (this.pieces[i].id != this.entityID.id) {
-        var piecePos = this.getIndexPosition(Entities.getEntityProperties(this.pieces[i]).position);
-        if (myPos.i === piecePos.i && myPos.j === piecePos.j) {
-          Entities.editEntity(this.pieces[i], { position: this.getAbsolutePosition({ i: 0, j: 0 })});
-          break;
-        }
-      }
+    if (this.active) {
+      this.updatePosition(mouseEvent);
+      this.snapToGrid();
+      //this.moveDeadPiece(); TODO
+      this.playSound();
     }
   }
   
-  this.preload = function() {
+  this.preload = function(entityID) {
+    this.updateProperties(entityID); // All callbacks start by updating the properties
     this.maybeDownloadSound();
   }
   this.clickDownOnEntity = function(entityID, mouseEvent) {
-    this.maybeDownloadSound();
-    this.updateProperties(entityID);
-    this.getMetadata();
+    this.preload(entityID); // TODO : remove
+    this.updateProperties(entityID); // All callbacks start by updating the properties
     this.grab(mouseEvent);
   };
   this.holdingClickOnEntity = function(entityID, mouseEvent) {
-    this.updateProperties(entityID);
+    this.updateProperties(entityID); // All callbacks start by updating the properties
     this.move(mouseEvent);
   };
   this.clickReleaseOnEntity = function(entityID, mouseEvent) {
-    this.updateProperties(entityID);
+    this.updateProperties(entityID); // All callbacks start by updating the properties
     this.release(mouseEvent);
   };
 })
\ No newline at end of file
diff --git a/examples/playChess.js b/examples/playChess.js
index 1ed836b7ca..da66d93677 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -69,16 +69,34 @@ ChessGame.getPieceInfo = function(type, isWhite) {
 
 
 // Board class
-ChessGame.Board = (function(position, size) {
+ChessGame.Board = (function(position, scale) {
   this.dimensions = Vec3.multiply(1.0 / ChessGame.BOARD.dimensions.x, ChessGame.BOARD.dimensions); // 1 by 1
-  this.dimensions = Vec3.multiply(size, this.dimensions); // size by size
-  this.position = Vec3.sum(position, Vec3.multiply(0.5, this.dimensions));
-  this.tileSize = size / ChessGame.BOARD.numTiles;
-
+  this.dimensions = Vec3.multiply(scale, this.dimensions); // scale by scale
+  this.position = position
+  this.tileSize = scale / ChessGame.BOARD.numTiles;
+  
+  this.userDataObject = {
+    firstTile: this.tilePosition(1, 1),
+    tileSize: this.tileSize,
+    whitesDeadPieces: this.tilePosition(0,0),
+    blacksDeadPieces: this.tilePosition(9,9),
+    pieces: new Array()
+  }
+  this.entityProperties = {
+    type: "Model",
+    modelURL: ChessGame.BOARD.modelURL,
+    position: this.position,
+    dimensions: this.dimensions,
+    userData: this.buildUserDataString()
+  }
   this.entity = null;
 });
 // Returns the top center point of tile i,j
 ChessGame.Board.prototype.tilePosition = function(i, j) {
+  if (!(this.position || this.dimensions || this.tileSize || ChessGame.BOARD.numTiles)) {
+    print("ChessGame.Board.prototype.tilePosition(): Called before proper initialisation, bailing.");
+    return null;
+  }
   return {
     x: this.position.x + (i - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize,
     y: this.position.y + this.dimensions.y / 2.0,
@@ -89,19 +107,22 @@ ChessGame.Board.prototype.tilePosition = function(i, j) {
 ChessGame.Board.prototype.isWhite = function(i, j) {
   return (i + j) % 2 != 0;
 }
+// Build the user data string
+ChessGame.Board.prototype.buildUserDataString = function() {
+  return JSON.stringify(this.userDataObject);
+}
+// Updates the user data stored by the board
+ChessGame.Board.prototype.updateUserData = function() {
+  var userDataString = this.buildUserDataString();
+  this.entityProperties.userData = userDataString;
+  Entities.editEntity(this.entity, { userData: userDataString });
+}
 // Spawns the board using entities
 ChessGame.Board.prototype.spawn = function() {
   if (extraDebug) {
     print("Spawning board...");
   }
-  
-  this.entity = Entities.addEntity({
-    type: "Model",
-    modelURL: ChessGame.BOARD.modelURL,
-    position: this.position,
-    dimensions: this.dimensions
-  });
-  
+  this.entity = Entities.addEntity(this.entityProperties);
   print("Board spawned");
 }
 // Cleans up the entities of the board
@@ -118,26 +139,35 @@ ChessGame.Piece = (function(position, dimensions, url, rotation) {
   this.dimensions = dimensions;
   this.position = position;
   this.position.y += this.dimensions.y / 2.0;
+  
   this.entityProperties = {
     type: "Model",
     position: this.position,
     rotation: rotation,
     dimensions: this.dimensions,
     modelURL: url,
-    //script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js"
-    //script: "https://s3-us-west-1.amazonaws.com/highfidelity-dev/scripts/chessPiece.js"
-    script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js"
+    //script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js",
+    //script: "https://s3-us-west-1.amazonaws.com/highfidelity-dev/scripts/chessPiece.js",
+    script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js",
+    userData: this.buildUserDataString()
   }
   this.entity = null;
 });
+// Build the user data string
+ChessGame.Piece.prototype.buildUserDataString = function() {
+  if (!(ChessGame.board !== null || ChessGame.board.entity.isKnownID)) {
+    print("ChessGame.Piece.prototype.buildUserDataString(): Called before proper initialization, bailing.");
+    return null;
+  }
+  var userDataObject = {
+    boardID: ChessGame.board.entity,
+  };
+  return JSON.stringify(userDataObject);
+}
 // Spawns the piece
 ChessGame.Piece.prototype.spawn = function() {
   this.entity = Entities.addEntity(this.entityProperties);
 }
-// Updates the metadata stored by the piece
-ChessGame.Piece.prototype.updateMetadata = function(metadataString) {
-  Entities.editEntity(this.entity, { animationURL: metadataString });
-}
 // Cleans up the piece
 ChessGame.Piece.prototype.cleanup = function() {
   Entities.deleteEntity(this.entity);
@@ -157,91 +187,76 @@ ChessGame.makePiece = function(piece, i, j, isWhite) {
   return piece;
 }
 
-ChessGame.buildMetadataString = function() {
-  var metadataObject = {
-    gamePosition: gamePosition,
-    gameSize: gameSize,
-    pieces: new Array()
-  };
-  for (i in ChessGame.pieces) {
-    metadataObject.pieces.push(ChessGame.pieces[i].entity);
-  }
-  return JSON.stringify(metadataObject);
-}
-
-ChessGame.buildBoard = function() {
-  // Setup board
-  ChessGame.board = new ChessGame.Board(gamePosition, gameSize);
-  ChessGame.board.spawn();
-  
-  // Setup white pieces
-  var isWhite = true;
-  var row = 1;
-  // King
-  var piece =ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
-  // Queen
-  piece = ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
-  // Bishop
-  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
-  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
-  // Knight
-  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
-  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
-  // Rook
-  piece = ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
-  piece = ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
-  for(var j = 1; j <= 8; j++) {
-    piece = ChessGame.makePiece(ChessGame.PAWN, row + 1, j, isWhite);
-  }
-  
-  // Setup black pieces
-  isWhite = false;
-  row = 8;
-  // King
-  piece = ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
-  // Queen
-  piece = ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
-  // Bishop
-  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
-  piece = ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
-  // Knight
-  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
-  piece = ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
-  // Rook
-  piece = ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
-  piece = ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
-  for(var j = 1; j <= 8; j++) {
-    piece = ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
-  }
-  
-  var metadataString = ChessGame.buildMetadataString();
-  for (i in ChessGame.pieces) {
-    ChessGame.pieces[i].updateMetadata(metadataString);
-  }
-}
-
-
 ChessGame.scriptStarting = function() {
   print("playChess.js started");
   gamePosition = Vec3.sum(MyAvatar.position,
                           Vec3.multiplyQbyV(MyAvatar.orientation,
                                             { x: 0, y: 0, z: -1 }));
-  ChessGame.buildBoard();
+  // Setup board
+  ChessGame.board = new ChessGame.Board(gamePosition, gameSize);
+  ChessGame.board.spawn();
+}
+
+ChessGame.update = function() {
+  ChessGame.board.entity = Entities.identifyEntity(ChessGame.board.entity);
+  print(JSON.stringify(ChessGame.board.entity));
+  if (ChessGame.board.entity.isKnownID && ChessGame.pieces.length == 0) {
+    // Setup white pieces
+    var isWhite = true;
+    var row = 1;
+    // King
+    ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
+    // Queen
+    ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
+    // Bishop
+    ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
+    ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
+    // Knight
+    ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
+    ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
+    // Rook
+    ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
+    ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
+    for(var j = 1; j <= 8; j++) {
+      ChessGame.makePiece(ChessGame.PAWN, row + 1, j, isWhite);
+    }
+  
+    // Setup black pieces
+    isWhite = false;
+    row = 8;
+    // King
+    ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
+    // Queen
+    ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
+    // Bishop
+    ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
+    ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
+    // Knight
+    ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
+    ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
+    // Rook
+    ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
+    ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
+    for(var j = 1; j <= 8; j++) {
+      ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
+    }
+
+    Script.update.disconnect(ChessGame.update);
+  }
 }
 
 ChessGame.scriptEnding = function() {
   // Cleaning up board
   ChessGame.board.cleanup();
-  delete ChessGame.board;
   
   // Cleaning up pieces
   for(var i in ChessGame.pieces) {
     ChessGame.pieces[i].cleanup();
   }
-  delete ChessGame.pieces;
   
   print("playChess.js finished");
 }
 
 Script.scriptEnding.connect(ChessGame.scriptEnding);
+Script.update.connect(ChessGame.update);
 ChessGame.scriptStarting();
\ No newline at end of file

From cc35b83d318f4d3fcbaa43721da59423cd4a9742 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 12:19:26 -0800
Subject: [PATCH 28/38] update pieces id

---
 examples/playChess.js | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index da66d93677..1b3c643af7 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -199,7 +199,7 @@ ChessGame.scriptStarting = function() {
 
 ChessGame.update = function() {
   ChessGame.board.entity = Entities.identifyEntity(ChessGame.board.entity);
-  print(JSON.stringify(ChessGame.board.entity));
+  
   if (ChessGame.board.entity.isKnownID && ChessGame.pieces.length == 0) {
     // Setup white pieces
     var isWhite = true;
@@ -240,8 +240,25 @@ ChessGame.update = function() {
     for(var j = 1; j <= 8; j++) {
       ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
     }
-
-    Script.update.disconnect(ChessGame.update);
+  }
+  
+  if (ChessGame.pieces.length > 0) {
+    var unknown = 0;
+    ChessGame.board.userDataObject.pieces = new Array();
+    for(var i = 1; i < ChessGame.pieces.length; i++) {
+      ChessGame.pieces[i].entity = Entities.identifyEntity(ChessGame.pieces[i].entity);
+      if (ChessGame.pieces[i].entity.isKnownID) {
+        ChessGame.board.userDataObject.pieces.push(ChessGame.pieces[i].entity)
+      } else {
+        unknown++;
+      }
+    }
+    ChessGame.board.updateUserData();
+    
+    if (unknown === 0) {
+      print("Board complete");
+      Script.update.disconnect(ChessGame.update);      
+    }
   }
 }
 

From 4c40f5e7de1734a109e79b7f9214b212c710e4ef Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 12:20:20 -0800
Subject: [PATCH 29/38] Changed entity scripts debug

---
 interface/src/entities/EntityTreeRenderer.cpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/interface/src/entities/EntityTreeRenderer.cpp b/interface/src/entities/EntityTreeRenderer.cpp
index 99e4916c62..6357dfc71d 100644
--- a/interface/src/entities/EntityTreeRenderer.cpp
+++ b/interface/src/entities/EntityTreeRenderer.cpp
@@ -163,10 +163,12 @@ QScriptValue EntityTreeRenderer::loadEntityScript(EntityItem* entity) {
     
     QString scriptContents = loadScriptContents(entity->getScript());
     
-    if (QScriptEngine::checkSyntax(scriptContents).state() != QScriptSyntaxCheckResult::Valid) {
+    QScriptSyntaxCheckResult syntaxCheck = QScriptEngine::checkSyntax(scriptContents);
+    if (syntaxCheck.state() != QScriptSyntaxCheckResult::Valid) {
         qDebug() << "EntityTreeRenderer::loadEntityScript() entity:" << entityID;
-        qDebug() << "    INVALID SYNTAX";
-        qDebug() << "    SCRIPT:" << scriptContents;
+        qDebug() << "   " << syntaxCheck.errorMessage() << ":"
+                          << syntaxCheck.errorLineNumber() << syntaxCheck.errorColumnNumber();
+        qDebug() << "    SCRIPT:" << entity->getScript();
         return QScriptValue(); // invalid script
     }
     
@@ -175,7 +177,7 @@ QScriptValue EntityTreeRenderer::loadEntityScript(EntityItem* entity) {
     if (!entityScriptConstructor.isFunction()) {
         qDebug() << "EntityTreeRenderer::loadEntityScript() entity:" << entityID;
         qDebug() << "    NOT CONSTRUCTOR";
-        qDebug() << "    SCRIPT:" << scriptContents;
+        qDebug() << "    SCRIPT:" << entity->getScript();
         return QScriptValue(); // invalid script
     }
 

From ba5491bc8b3233559b2ee944610e63fbb460ae32 Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Fri, 14 Nov 2014 22:55:25 +0100
Subject: [PATCH 30/38] moved writeToClone to copy constructor

---
 interface/src/ui/overlays/Base3DOverlay.cpp   | 22 ++++++------
 interface/src/ui/overlays/Base3DOverlay.h     |  3 +-
 .../src/ui/overlays/BillboardOverlay.cpp      | 24 ++++++-------
 interface/src/ui/overlays/BillboardOverlay.h  |  5 ++-
 interface/src/ui/overlays/Circle3DOverlay.cpp | 35 +++++++++---------
 interface/src/ui/overlays/Circle3DOverlay.h   |  3 +-
 interface/src/ui/overlays/Cube3DOverlay.cpp   |  9 +++--
 interface/src/ui/overlays/Cube3DOverlay.h     |  1 +
 interface/src/ui/overlays/Grid3DOverlay.cpp   | 17 +++++----
 interface/src/ui/overlays/Grid3DOverlay.h     |  3 +-
 interface/src/ui/overlays/ImageOverlay.cpp    | 23 ++++++------
 interface/src/ui/overlays/ImageOverlay.h      |  2 +-
 interface/src/ui/overlays/Line3DOverlay.cpp   | 16 ++++-----
 interface/src/ui/overlays/Line3DOverlay.h     |  3 +-
 .../src/ui/overlays/LocalModelsOverlay.cpp    | 11 ++++--
 .../src/ui/overlays/LocalModelsOverlay.h      |  1 +
 .../src/ui/overlays/LocalVoxelsOverlay.cpp    | 10 ++++--
 .../src/ui/overlays/LocalVoxelsOverlay.h      |  1 +
 interface/src/ui/overlays/ModelOverlay.cpp    | 32 +++++++++--------
 interface/src/ui/overlays/ModelOverlay.h      |  4 +--
 interface/src/ui/overlays/Overlay.cpp         | 36 ++++++++++---------
 interface/src/ui/overlays/Overlay.h           |  2 +-
 interface/src/ui/overlays/Overlay2D.cpp       | 12 +++----
 interface/src/ui/overlays/Overlay2D.h         |  4 +--
 interface/src/ui/overlays/Planar3DOverlay.cpp | 11 +++---
 interface/src/ui/overlays/Planar3DOverlay.h   |  2 +-
 .../src/ui/overlays/Rectangle3DOverlay.cpp    |  9 +++--
 .../src/ui/overlays/Rectangle3DOverlay.h      |  1 +
 interface/src/ui/overlays/Sphere3DOverlay.cpp |  9 +++--
 interface/src/ui/overlays/Sphere3DOverlay.h   |  1 +
 interface/src/ui/overlays/Text3DOverlay.cpp   | 30 ++++++++--------
 interface/src/ui/overlays/Text3DOverlay.h     |  2 +-
 interface/src/ui/overlays/TextOverlay.cpp     | 24 ++++++-------
 interface/src/ui/overlays/TextOverlay.h       |  3 +-
 interface/src/ui/overlays/Volume3DOverlay.cpp | 10 +++---
 interface/src/ui/overlays/Volume3DOverlay.h   |  2 +-
 36 files changed, 201 insertions(+), 182 deletions(-)

diff --git a/interface/src/ui/overlays/Base3DOverlay.cpp b/interface/src/ui/overlays/Base3DOverlay.cpp
index aae2acf61e..7ed7079795 100644
--- a/interface/src/ui/overlays/Base3DOverlay.cpp
+++ b/interface/src/ui/overlays/Base3DOverlay.cpp
@@ -31,6 +31,17 @@ Base3DOverlay::Base3DOverlay() :
 {
 }
 
+Base3DOverlay::Base3DOverlay(Base3DOverlay* base3DOverlay) :
+    Overlay(base3DOverlay),
+    _position(base3DOverlay->_position),
+    _lineWidth(base3DOverlay->_lineWidth),
+    _rotation(base3DOverlay->_rotation),
+    _isSolid(base3DOverlay->_isSolid),
+    _isDashedLine(base3DOverlay->_isDashedLine),
+    _ignoreRayIntersection(base3DOverlay->_ignoreRayIntersection)
+{
+}
+
 Base3DOverlay::~Base3DOverlay() {
 }
 
@@ -178,15 +189,4 @@ void Base3DOverlay::drawDashedLine(const glm::vec3& start, const glm::vec3& end)
     glVertex3f(end.x, end.y, end.z);
 
     glEnd();
-
-}
-
-void Base3DOverlay::writeToClone(Base3DOverlay* clone) {
-    Overlay::writeToClone(clone);
-    clone->setPosition(getPosition());
-    clone->setLineWidth(getLineWidth());
-    clone->setIsSolid(getIsSolid());
-    clone->setIsDashedLine(getIsDashedLine());
-    clone->setRotation(getRotation());
-    clone->setIgnoreRayIntersection(getIgnoreRayIntersection());
 }
diff --git a/interface/src/ui/overlays/Base3DOverlay.h b/interface/src/ui/overlays/Base3DOverlay.h
index f4032f2015..4422203566 100644
--- a/interface/src/ui/overlays/Base3DOverlay.h
+++ b/interface/src/ui/overlays/Base3DOverlay.h
@@ -23,6 +23,7 @@ class Base3DOverlay : public Overlay {
     
 public:
     Base3DOverlay();
+    Base3DOverlay(Base3DOverlay* base3DOverlay);
     ~Base3DOverlay();
 
     // getters
@@ -55,7 +56,6 @@ public:
     }
 
 protected:
-    virtual void writeToClone(Base3DOverlay* clone);
     void drawDashedLine(const glm::vec3& start, const glm::vec3& end);
 
     glm::vec3 _position;
@@ -65,6 +65,5 @@ protected:
     bool _isDashedLine;
     bool _ignoreRayIntersection;
 };
-
  
 #endif // hifi_Base3DOverlay_h
diff --git a/interface/src/ui/overlays/BillboardOverlay.cpp b/interface/src/ui/overlays/BillboardOverlay.cpp
index b570576380..87c8f8bb74 100644
--- a/interface/src/ui/overlays/BillboardOverlay.cpp
+++ b/interface/src/ui/overlays/BillboardOverlay.cpp
@@ -24,6 +24,17 @@ BillboardOverlay::BillboardOverlay() :
       _isLoaded = false;
 }
 
+BillboardOverlay::BillboardOverlay(BillboardOverlay* billboardOverlay) :
+    Base3DOverlay(billboardOverlay),
+    _newTextureNeeded(true),
+    _scale(billboardOverlay->_scale),
+    _isFacingAvatar(billboardOverlay->_isFacingAvatar),
+    _fromImage(billboardOverlay->_fromImage),
+    _url(billboardOverlay->_url),
+    _billboard(billboardOverlay->_billboard)
+{
+}
+
 void BillboardOverlay::render(RenderArgs* args) {
     if (!_visible || !_isLoaded) {
         return;
@@ -216,16 +227,5 @@ bool BillboardOverlay::findRayIntersection(const glm::vec3& origin, const glm::v
 }
 
 BillboardOverlay* BillboardOverlay::createClone() {
-    BillboardOverlay* clone = new BillboardOverlay();
-    writeToClone(clone);
-    return clone;
-}
-
-void BillboardOverlay::writeToClone(BillboardOverlay* clone) {
-    Base3DOverlay::writeToClone(clone);
-    clone->setScale(_scale);
-    clone->setIsFacingAvatar(_isFacingAvatar);
-    clone->setClipFromSource(_fromImage);
-    clone->_url = _url;
-    clone->_billboard = _billboard;
+    return new BillboardOverlay(this);
 }
diff --git a/interface/src/ui/overlays/BillboardOverlay.h b/interface/src/ui/overlays/BillboardOverlay.h
index e967aba408..e8c25c8549 100644
--- a/interface/src/ui/overlays/BillboardOverlay.h
+++ b/interface/src/ui/overlays/BillboardOverlay.h
@@ -22,7 +22,8 @@ class BillboardOverlay : public Base3DOverlay {
     Q_OBJECT
 public:
     BillboardOverlay();
-    
+    BillboardOverlay(BillboardOverlay* billboardOverlay);
+
     virtual void render(RenderArgs* args);
 
     // setters
@@ -42,8 +43,6 @@ private slots:
     void replyFinished();
 
 private:
-    virtual void writeToClone(BillboardOverlay* clone);
-
     void setBillboardURL(const QString& url);
     
     QString _url;
diff --git a/interface/src/ui/overlays/Circle3DOverlay.cpp b/interface/src/ui/overlays/Circle3DOverlay.cpp
index 1258ee56c5..6c0c82f3ec 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Circle3DOverlay.cpp
@@ -33,6 +33,22 @@ Circle3DOverlay::Circle3DOverlay() :
     _minorTickMarksColor.red = _minorTickMarksColor.green = _minorTickMarksColor.blue = (unsigned char)0;
 }
 
+Circle3DOverlay::Circle3DOverlay(Circle3DOverlay* circle3DOverlay) :
+    Planar3DOverlay(circle3DOverlay),
+    _startAt(circle3DOverlay->_startAt),
+    _endAt(circle3DOverlay->_endAt),
+    _outerRadius(circle3DOverlay->_outerRadius),
+    _innerRadius(circle3DOverlay->_innerRadius),
+    _hasTickMarks(circle3DOverlay->_hasTickMarks),
+    _majorTickMarksAngle(circle3DOverlay->_majorTickMarksAngle),
+    _minorTickMarksAngle(circle3DOverlay->_minorTickMarksAngle),
+    _majorTickMarksLength(circle3DOverlay->_majorTickMarksLength),
+    _minorTickMarksLength(circle3DOverlay->_minorTickMarksLength),
+    _majorTickMarksColor(circle3DOverlay->_majorTickMarksColor),
+    _minorTickMarksColor(circle3DOverlay->_minorTickMarksColor)
+{
+}
+
 Circle3DOverlay::~Circle3DOverlay() {
 }
 
@@ -359,22 +375,5 @@ bool Circle3DOverlay::findRayIntersection(const glm::vec3& origin,
 }
 
 Circle3DOverlay* Circle3DOverlay::createClone() {
-    Circle3DOverlay* clone = new Circle3DOverlay();
-    writeToClone(clone);
-    return clone;
-}
-
-void Circle3DOverlay::writeToClone(Circle3DOverlay* clone) {
-    Planar3DOverlay::writeToClone(clone);
-    clone->setStartAt(getStartAt());
-    clone->setEndAt(getEndAt());
-    clone->setOuterRadius(getOuterRadius());
-    clone->setInnerRadius(getInnerRadius());
-    clone->setHasTickMarks(getHasTickMarks());
-    clone->setMajorTickMarksAngle(getMajorTickMarksAngle());
-    clone->setMinorTickMarksAngle(getMinorTickMarksAngle());
-    clone->setMajorTickMarksLength(getMajorTickMarksLength());
-    clone->setMinorTickMarksLength(getMinorTickMarksLength());
-    clone->setMajorTickMarksColor(getMajorTickMarksColor());
-    clone->setMinorTickMarksColor(getMinorTickMarksColor());
+    return new Circle3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Circle3DOverlay.h b/interface/src/ui/overlays/Circle3DOverlay.h
index 85bda28d46..cf9fc8e2fc 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.h
+++ b/interface/src/ui/overlays/Circle3DOverlay.h
@@ -18,6 +18,7 @@ class Circle3DOverlay : public Planar3DOverlay {
     
 public:
     Circle3DOverlay();
+    Circle3DOverlay(Circle3DOverlay* circle3DOverlay);
     ~Circle3DOverlay();
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
@@ -52,8 +53,6 @@ public:
     virtual Circle3DOverlay* createClone();
     
 protected:
-    virtual void writeToClone(Circle3DOverlay* clone);
-
     float _startAt;
     float _endAt;
     float _outerRadius;
diff --git a/interface/src/ui/overlays/Cube3DOverlay.cpp b/interface/src/ui/overlays/Cube3DOverlay.cpp
index 9bf3de90c0..2aa4d29f23 100644
--- a/interface/src/ui/overlays/Cube3DOverlay.cpp
+++ b/interface/src/ui/overlays/Cube3DOverlay.cpp
@@ -22,6 +22,11 @@
 Cube3DOverlay::Cube3DOverlay() {
 }
 
+Cube3DOverlay::Cube3DOverlay(Cube3DOverlay* cube3DOverlay) :
+    Volume3DOverlay(cube3DOverlay)
+{
+}
+
 Cube3DOverlay::~Cube3DOverlay() {
 }
 
@@ -104,7 +109,5 @@ void Cube3DOverlay::render(RenderArgs* args) {
 }
 
 Cube3DOverlay* Cube3DOverlay::createClone() {
-    Cube3DOverlay* clone = new Cube3DOverlay();
-    writeToClone(clone);
-    return clone;
+    return new Cube3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Cube3DOverlay.h b/interface/src/ui/overlays/Cube3DOverlay.h
index 0b7b9e14a3..4fe137b73c 100644
--- a/interface/src/ui/overlays/Cube3DOverlay.h
+++ b/interface/src/ui/overlays/Cube3DOverlay.h
@@ -18,6 +18,7 @@ class Cube3DOverlay : public Volume3DOverlay {
     
 public:
     Cube3DOverlay();
+    Cube3DOverlay(Cube3DOverlay* cube3DOverlay);
     ~Cube3DOverlay();
     virtual void render(RenderArgs* args);
 
diff --git a/interface/src/ui/overlays/Grid3DOverlay.cpp b/interface/src/ui/overlays/Grid3DOverlay.cpp
index 62ba5d1e78..601413226a 100644
--- a/interface/src/ui/overlays/Grid3DOverlay.cpp
+++ b/interface/src/ui/overlays/Grid3DOverlay.cpp
@@ -20,6 +20,13 @@ Grid3DOverlay::Grid3DOverlay() : Base3DOverlay(),
     _majorGridEvery(5) {
 }
 
+Grid3DOverlay::Grid3DOverlay(Grid3DOverlay* grid3DOverlay) :
+    Base3DOverlay(grid3DOverlay),
+    _minorGridWidth(grid3DOverlay->_minorGridWidth),
+    _majorGridEvery(grid3DOverlay->_majorGridEvery)
+{
+}
+
 Grid3DOverlay::~Grid3DOverlay() {
 }
 
@@ -129,13 +136,5 @@ QScriptValue Grid3DOverlay::getProperty(const QString& property) {
 }
 
 Grid3DOverlay* Grid3DOverlay::createClone() {
-    Grid3DOverlay* clone = new Grid3DOverlay();
-    writeToClone(clone);
-    return clone;
-}
-
-void Grid3DOverlay::writeToClone(Grid3DOverlay* clone) {
-    Base3DOverlay::writeToClone(clone);
-    clone->_minorGridWidth = _minorGridWidth;
-    clone->_majorGridEvery = _majorGridEvery;
+    return new Grid3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Grid3DOverlay.h b/interface/src/ui/overlays/Grid3DOverlay.h
index 1a1841cd96..28dfbf9de7 100644
--- a/interface/src/ui/overlays/Grid3DOverlay.h
+++ b/interface/src/ui/overlays/Grid3DOverlay.h
@@ -29,6 +29,7 @@ class Grid3DOverlay : public Base3DOverlay {
 
 public:
     Grid3DOverlay();
+    Grid3DOverlay(Grid3DOverlay* grid3DOverlay);
     ~Grid3DOverlay();
 
     virtual void render(RenderArgs* args);
@@ -38,8 +39,6 @@ public:
     virtual Grid3DOverlay* createClone();
 
 private:
-    virtual void writeToClone(Grid3DOverlay* clone);
-
     float _minorGridWidth;
     int _majorGridEvery;
 
diff --git a/interface/src/ui/overlays/ImageOverlay.cpp b/interface/src/ui/overlays/ImageOverlay.cpp
index 7c6d576698..dd06ee4da2 100644
--- a/interface/src/ui/overlays/ImageOverlay.cpp
+++ b/interface/src/ui/overlays/ImageOverlay.cpp
@@ -27,6 +27,17 @@ ImageOverlay::ImageOverlay() :
     _isLoaded = false;
 }
 
+ImageOverlay::ImageOverlay(ImageOverlay* imageOverlay) :
+    Overlay2D(imageOverlay),
+    _textureID(0),
+    _textureBound(false),
+    _wantClipFromImage(false),
+    _renderImage(imageOverlay->_renderImage),
+    _imageURL(imageOverlay->_imageURL),
+    _textureImage(imageOverlay->_textureImage)
+{
+}
+
 ImageOverlay::~ImageOverlay() {
     if (_parent && _textureID) {
         // do we need to call this?
@@ -162,15 +173,5 @@ QScriptValue ImageOverlay::getProperty(const QString& property) {
     return Overlay2D::getProperty(property);
 }
 ImageOverlay* ImageOverlay::createClone() {
-    ImageOverlay* clone = new ImageOverlay();
-    writeToClone(clone);
-    return clone;
+    return new ImageOverlay(this);
 }
-
-void ImageOverlay::writeToClone(ImageOverlay* clone) {
-    Overlay2D::writeToClone(clone);
-    clone->_imageURL = _imageURL;
-    clone->_textureImage = _textureImage;
-    clone->_renderImage = _renderImage;
-}
-
diff --git a/interface/src/ui/overlays/ImageOverlay.h b/interface/src/ui/overlays/ImageOverlay.h
index 54f50dad2d..9c8d48a2e2 100644
--- a/interface/src/ui/overlays/ImageOverlay.h
+++ b/interface/src/ui/overlays/ImageOverlay.h
@@ -33,6 +33,7 @@ class ImageOverlay : public Overlay2D {
     
 public:
     ImageOverlay();
+    ImageOverlay(ImageOverlay* imageOverlay);
     ~ImageOverlay();
     virtual void render(RenderArgs* args);
 
@@ -52,7 +53,6 @@ private slots:
     void replyFinished(); // we actually want to hide this...
 
 private:
-    virtual void writeToClone(ImageOverlay* clone);
 
     QUrl _imageURL;
     QImage _textureImage;
diff --git a/interface/src/ui/overlays/Line3DOverlay.cpp b/interface/src/ui/overlays/Line3DOverlay.cpp
index 7ecc7eb1f8..aac773f08f 100644
--- a/interface/src/ui/overlays/Line3DOverlay.cpp
+++ b/interface/src/ui/overlays/Line3DOverlay.cpp
@@ -18,6 +18,12 @@
 Line3DOverlay::Line3DOverlay() {
 }
 
+Line3DOverlay::Line3DOverlay(Line3DOverlay* line3DOverlay) :
+    Base3DOverlay(line3DOverlay),
+    _end(line3DOverlay->_end)
+{
+}
+
 Line3DOverlay::~Line3DOverlay() {
 }
 
@@ -89,13 +95,5 @@ QScriptValue Line3DOverlay::getProperty(const QString& property) {
 }
 
 Line3DOverlay* Line3DOverlay::createClone() {
-    Line3DOverlay* clone = new Line3DOverlay();
-    writeToClone(clone);
-    return clone;
+    return new Line3DOverlay(this);
 }
-
-void Line3DOverlay::writeToClone(Line3DOverlay* clone) {
-    Base3DOverlay::writeToClone(clone);
-    clone->setEnd(getEnd());
-}
-
diff --git a/interface/src/ui/overlays/Line3DOverlay.h b/interface/src/ui/overlays/Line3DOverlay.h
index 5d7d9cbe3a..3d481438b9 100644
--- a/interface/src/ui/overlays/Line3DOverlay.h
+++ b/interface/src/ui/overlays/Line3DOverlay.h
@@ -18,6 +18,7 @@ class Line3DOverlay : public Base3DOverlay {
     
 public:
     Line3DOverlay();
+    Line3DOverlay(Line3DOverlay* line3DOverlay);
     ~Line3DOverlay();
     virtual void render(RenderArgs* args);
 
@@ -33,8 +34,6 @@ public:
     virtual Line3DOverlay* createClone();
 
 protected:
-    virtual void writeToClone(Line3DOverlay* clone);
-
     glm::vec3 _end;
 };
 
diff --git a/interface/src/ui/overlays/LocalModelsOverlay.cpp b/interface/src/ui/overlays/LocalModelsOverlay.cpp
index 7f1faf3a39..25cb0ead64 100644
--- a/interface/src/ui/overlays/LocalModelsOverlay.cpp
+++ b/interface/src/ui/overlays/LocalModelsOverlay.cpp
@@ -18,6 +18,13 @@ LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer) :
     _entityTreeRenderer(entityTreeRenderer) {
 }
 
+LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer, LocalModelsOverlay* localModelsOverlay) :
+    Volume3DOverlay(localModelsOverlay),
+    _entityTreeRenderer(entityTreeRenderer)
+{
+
+}
+
 LocalModelsOverlay::~LocalModelsOverlay() {
 }
 
@@ -50,7 +57,5 @@ void LocalModelsOverlay::render(RenderArgs* args) {
 }
 
 LocalModelsOverlay* LocalModelsOverlay::createClone() {
-    LocalModelsOverlay* clone = new LocalModelsOverlay(Application::getInstance()->getEntityClipboardRenderer());
-    writeToClone(clone);
-    return clone;
+    return new LocalModelsOverlay(Application::getInstance()->getEntityClipboardRenderer(), this);
 }
diff --git a/interface/src/ui/overlays/LocalModelsOverlay.h b/interface/src/ui/overlays/LocalModelsOverlay.h
index 0659de0ab1..c38bc6b2a3 100644
--- a/interface/src/ui/overlays/LocalModelsOverlay.h
+++ b/interface/src/ui/overlays/LocalModelsOverlay.h
@@ -20,6 +20,7 @@ class LocalModelsOverlay : public Volume3DOverlay {
     Q_OBJECT
 public:
     LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer);
+    LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer, LocalModelsOverlay* localModelsOverlay);
     ~LocalModelsOverlay();
     
     virtual void update(float deltatime);
diff --git a/interface/src/ui/overlays/LocalVoxelsOverlay.cpp b/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
index eab833aea3..4c44fe6dd8 100644
--- a/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
+++ b/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
@@ -28,6 +28,12 @@ LocalVoxelsOverlay::LocalVoxelsOverlay() :
 {
 }
 
+LocalVoxelsOverlay::LocalVoxelsOverlay(LocalVoxelsOverlay* localVoxelsOverlay) :
+    Volume3DOverlay(localVoxelsOverlay),
+    _voxelCount(localVoxelsOverlay->_voxelCount)
+{
+}
+
 LocalVoxelsOverlay::~LocalVoxelsOverlay() {
     _voxelSystem->changeTree(new VoxelTree());
     _voxelSystem.clear();
@@ -104,9 +110,7 @@ void LocalVoxelsOverlay::setProperties(const QScriptValue &properties) {
 }
 
 LocalVoxelsOverlay* LocalVoxelsOverlay::createClone() {
-    LocalVoxelsOverlay* clone = new LocalVoxelsOverlay();
-    writeToClone(clone);
-    return clone;
+    return new LocalVoxelsOverlay(this);
 }
 
 QScriptValue LocalVoxelsOverlay::getProperty(const QString& property) {
diff --git a/interface/src/ui/overlays/LocalVoxelsOverlay.h b/interface/src/ui/overlays/LocalVoxelsOverlay.h
index 5c75c13db7..3e5bbbc5b6 100644
--- a/interface/src/ui/overlays/LocalVoxelsOverlay.h
+++ b/interface/src/ui/overlays/LocalVoxelsOverlay.h
@@ -32,6 +32,7 @@ class LocalVoxelsOverlay : public Volume3DOverlay {
     Q_OBJECT
 public:
     LocalVoxelsOverlay();
+    LocalVoxelsOverlay(LocalVoxelsOverlay* localVoxelsOverlay);
     ~LocalVoxelsOverlay();
     
     virtual void update(float deltatime);
diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index 9edb744b41..f1c588f45d 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -22,6 +22,22 @@ ModelOverlay::ModelOverlay()
     _isLoaded = false;
 }
 
+ModelOverlay::ModelOverlay(ModelOverlay* modelOverlay) :
+    Base3DOverlay(modelOverlay),
+    _model(),
+    _modelTextures(QVariantMap()),
+    _scale(modelOverlay->_scale),
+    _updateModel(false),
+    _url(modelOverlay->_url),
+    _rotation(modelOverlay->_rotation)
+{
+    _model.init();
+    if (_url.isValid()) {
+        _updateModel = true;
+        _isLoaded = false;
+    }
+}
+
 void ModelOverlay::update(float deltatime) {
     if (_updateModel) {
         _updateModel = false;
@@ -167,19 +183,5 @@ bool ModelOverlay::findRayIntersectionExtraInfo(const glm::vec3& origin, const g
 }
 
 ModelOverlay* ModelOverlay::createClone() {
-    ModelOverlay* clone = new ModelOverlay();
-    writeToClone(clone);
-    return clone;
-}
-
-void ModelOverlay::writeToClone(ModelOverlay* clone) {
-    Base3DOverlay::writeToClone(clone);
-    clone->_url = _url;
-    if (clone->_url.isValid()) {
-        clone->_updateModel = true;
-        clone->_isLoaded = false;
-    }
-    clone->_rotation = _rotation;
-    clone->_scale = _scale;
-    clone->_updateModel = _updateModel;
+    return new ModelOverlay(this);
 }
diff --git a/interface/src/ui/overlays/ModelOverlay.h b/interface/src/ui/overlays/ModelOverlay.h
index 9c59a1ddd8..393e09c78b 100644
--- a/interface/src/ui/overlays/ModelOverlay.h
+++ b/interface/src/ui/overlays/ModelOverlay.h
@@ -20,7 +20,8 @@ class ModelOverlay : public Base3DOverlay {
     Q_OBJECT
 public:
     ModelOverlay();
-    
+    ModelOverlay(ModelOverlay* modelOverlay);
+
     virtual void update(float deltatime);
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
@@ -32,7 +33,6 @@ public:
     virtual ModelOverlay* createClone();
 
 private:
-    virtual void writeToClone(ModelOverlay* clone);
 
     Model _model;
     QVariantMap _modelTextures;
diff --git a/interface/src/ui/overlays/Overlay.cpp b/interface/src/ui/overlays/Overlay.cpp
index 8544eacc39..e67c1572f1 100644
--- a/interface/src/ui/overlays/Overlay.cpp
+++ b/interface/src/ui/overlays/Overlay.cpp
@@ -39,12 +39,30 @@ Overlay::Overlay() :
 {
 }
 
+Overlay::Overlay(Overlay* overlay) :
+    _parent(NULL),
+    _alpha(overlay->_alpha),
+    _lastPulseUpdate(usecTimestampNow()),
+    _alphaPulse(overlay->_alphaPulse),
+    _anchor(overlay->_anchor),
+    _color(overlay->_color),
+    _colorPulse(overlay->_colorPulse),
+    _glowLevel(overlay->_glowLevel),
+    _glowLevelPulse(overlay->_glowLevelPulse),
+    _pulseDirection(overlay->_pulseDirection),
+    _pulseMax(overlay->_pulseMax),
+    _pulseMin(overlay->_pulseMin),
+    _pulsePeriod(overlay->_pulsePeriod),
+    _visible(overlay->_visible),
+    _isLoaded(overlay->_isLoaded)
+{
+}
+
 void Overlay::init(QGLWidget* parent, QScriptEngine* scriptEngine) {
     _parent = parent;
     _scriptEngine = scriptEngine;
 }
 
-
 Overlay::~Overlay() {
 }
 
@@ -212,19 +230,3 @@ float Overlay::updatePulse() {
     
     return _pulse;
 }
-
-void Overlay::writeToClone(Overlay* clone) {
-    clone->setAlpha(getAlpha());
-    clone->setAlphaPulse(getAlphaPulse());
-    clone->setAnchor(getAnchor());
-    clone->setColor(getColor());
-    clone->setColorPulse(getColorPulse());
-    clone->setGlowLevel(getGlowLevel());
-    clone->setGlowLevelPulse(getGlowLevelPulse());
-    clone->setPulseDirection(getPulseDirection());
-    clone->setPulseMax(getPulseMax());
-    clone->setPulseMin(getPulseMin());
-    clone->setPulsePeriod(getPulsePeriod());
-    clone->setVisible(getVisible());
-    clone->_isLoaded = _isLoaded;
-}
diff --git a/interface/src/ui/overlays/Overlay.h b/interface/src/ui/overlays/Overlay.h
index 0efd7174b4..341a7b56a3 100644
--- a/interface/src/ui/overlays/Overlay.h
+++ b/interface/src/ui/overlays/Overlay.h
@@ -36,6 +36,7 @@ public:
     };
     
     Overlay();
+    Overlay(Overlay* overlay);
     ~Overlay();
     void init(QGLWidget* parent, QScriptEngine* scriptEngine);
     virtual void update(float deltatime) {}
@@ -82,7 +83,6 @@ public:
     virtual QScriptValue getProperty(const QString& property);
 
 protected:
-    virtual void writeToClone(Overlay* clone);
     float updatePulse();
 
     QGLWidget* _parent;
diff --git a/interface/src/ui/overlays/Overlay2D.cpp b/interface/src/ui/overlays/Overlay2D.cpp
index ccbecb31a2..53ef9cdf29 100644
--- a/interface/src/ui/overlays/Overlay2D.cpp
+++ b/interface/src/ui/overlays/Overlay2D.cpp
@@ -22,6 +22,12 @@
 Overlay2D::Overlay2D() {
 }
 
+Overlay2D::Overlay2D(Overlay2D* overlay2D) :
+    Overlay(overlay2D),
+    _bounds(overlay2D->_bounds)
+{
+}
+
 Overlay2D::~Overlay2D() {
 }
 
@@ -84,9 +90,3 @@ QScriptValue Overlay2D::getProperty(const QString& property) {
 
     return Overlay::getProperty(property);
 }
-
-void Overlay2D::writeToClone(Overlay2D* clone) {
-    Overlay::writeToClone(clone);
-    clone->setBounds(getBounds());
-}
-
diff --git a/interface/src/ui/overlays/Overlay2D.h b/interface/src/ui/overlays/Overlay2D.h
index 31b1bd351e..ea3936c2c7 100644
--- a/interface/src/ui/overlays/Overlay2D.h
+++ b/interface/src/ui/overlays/Overlay2D.h
@@ -28,6 +28,7 @@ class Overlay2D : public Overlay {
     
 public:
     Overlay2D();
+    Overlay2D(Overlay2D* overlay2D);
     ~Overlay2D();
     
     virtual bool is3D() const { return false; }
@@ -43,14 +44,13 @@ public:
     void setX(int x) { _bounds.setX(x); }
     void setY(int y) { _bounds.setY(y);  }
     void setWidth(int width) { _bounds.setWidth(width); }
-    void setHeight(int height) {  _bounds.setHeight(height); }
+    void setHeight(int height) { _bounds.setHeight(height); }
     void setBounds(const QRect& bounds) { _bounds = bounds; }
 
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
 protected:
-    virtual void writeToClone(Overlay2D* clone);
     QRect _bounds; // where on the screen to draw
 };
 
diff --git a/interface/src/ui/overlays/Planar3DOverlay.cpp b/interface/src/ui/overlays/Planar3DOverlay.cpp
index 08c765c5ee..390b92948c 100644
--- a/interface/src/ui/overlays/Planar3DOverlay.cpp
+++ b/interface/src/ui/overlays/Planar3DOverlay.cpp
@@ -26,6 +26,12 @@ Planar3DOverlay::Planar3DOverlay() :
 {
 }
 
+Planar3DOverlay::Planar3DOverlay(Planar3DOverlay* planar3DOverlay) :
+    Base3DOverlay(planar3DOverlay),
+    _dimensions(planar3DOverlay->_dimensions)
+{
+}
+
 Planar3DOverlay::~Planar3DOverlay() {
 }
 
@@ -110,8 +116,3 @@ bool Planar3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::ve
     }
     return intersects;
 }
-
-void Planar3DOverlay::writeToClone(Planar3DOverlay* clone) {
-    Base3DOverlay::writeToClone(clone);
-    clone->setDimensions(getDimensions());
-}
diff --git a/interface/src/ui/overlays/Planar3DOverlay.h b/interface/src/ui/overlays/Planar3DOverlay.h
index 2f6c4a561b..7de68e24b2 100644
--- a/interface/src/ui/overlays/Planar3DOverlay.h
+++ b/interface/src/ui/overlays/Planar3DOverlay.h
@@ -26,6 +26,7 @@ class Planar3DOverlay : public Base3DOverlay {
     
 public:
     Planar3DOverlay();
+    Planar3DOverlay(Planar3DOverlay* planar3DOverlay);
     ~Planar3DOverlay();
 
     // getters
@@ -41,7 +42,6 @@ public:
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
 
 protected:
-    virtual void writeToClone(Planar3DOverlay* clone);
     glm::vec2 _dimensions;
 };
 
diff --git a/interface/src/ui/overlays/Rectangle3DOverlay.cpp b/interface/src/ui/overlays/Rectangle3DOverlay.cpp
index 728accfad6..a2043d77c1 100644
--- a/interface/src/ui/overlays/Rectangle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Rectangle3DOverlay.cpp
@@ -20,6 +20,11 @@
 Rectangle3DOverlay::Rectangle3DOverlay() {
 }
 
+Rectangle3DOverlay::Rectangle3DOverlay(Rectangle3DOverlay* rectangle3DOverlay) :
+    Planar3DOverlay(rectangle3DOverlay)
+{
+}
+
 Rectangle3DOverlay::~Rectangle3DOverlay() {
 }
 
@@ -107,7 +112,5 @@ void Rectangle3DOverlay::setProperties(const QScriptValue &properties) {
 }
 
 Rectangle3DOverlay* Rectangle3DOverlay::createClone() {
-    Rectangle3DOverlay* clone = new Rectangle3DOverlay();
-    writeToClone(clone);
-    return clone;
+    return new Rectangle3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Rectangle3DOverlay.h b/interface/src/ui/overlays/Rectangle3DOverlay.h
index 0bb805200c..98e04324b4 100644
--- a/interface/src/ui/overlays/Rectangle3DOverlay.h
+++ b/interface/src/ui/overlays/Rectangle3DOverlay.h
@@ -18,6 +18,7 @@ class Rectangle3DOverlay : public Planar3DOverlay {
     
 public:
     Rectangle3DOverlay();
+    Rectangle3DOverlay(Rectangle3DOverlay* rectangle3DOverlay);
     ~Rectangle3DOverlay();
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
diff --git a/interface/src/ui/overlays/Sphere3DOverlay.cpp b/interface/src/ui/overlays/Sphere3DOverlay.cpp
index ef4e2ba51b..30bb7d1c52 100644
--- a/interface/src/ui/overlays/Sphere3DOverlay.cpp
+++ b/interface/src/ui/overlays/Sphere3DOverlay.cpp
@@ -21,6 +21,11 @@
 Sphere3DOverlay::Sphere3DOverlay() {
 }
 
+Sphere3DOverlay::Sphere3DOverlay(Sphere3DOverlay* Sphere3DOverlay) :
+    Volume3DOverlay(Sphere3DOverlay)
+{
+}
+
 Sphere3DOverlay::~Sphere3DOverlay() {
 }
 
@@ -72,7 +77,5 @@ void Sphere3DOverlay::render(RenderArgs* args) {
 }
 
 Sphere3DOverlay* Sphere3DOverlay::createClone() {
-    Sphere3DOverlay* clone = new Sphere3DOverlay();
-    writeToClone(clone);
-    return clone;
+    return new Sphere3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Sphere3DOverlay.h b/interface/src/ui/overlays/Sphere3DOverlay.h
index f9db6b99af..2f63c4fe48 100644
--- a/interface/src/ui/overlays/Sphere3DOverlay.h
+++ b/interface/src/ui/overlays/Sphere3DOverlay.h
@@ -18,6 +18,7 @@ class Sphere3DOverlay : public Volume3DOverlay {
     
 public:
     Sphere3DOverlay();
+    Sphere3DOverlay(Sphere3DOverlay* Sphere3DOverlay);
     ~Sphere3DOverlay();
     virtual void render(RenderArgs* args);
 
diff --git a/interface/src/ui/overlays/Text3DOverlay.cpp b/interface/src/ui/overlays/Text3DOverlay.cpp
index 9af96cad7e..0a83ec80f5 100644
--- a/interface/src/ui/overlays/Text3DOverlay.cpp
+++ b/interface/src/ui/overlays/Text3DOverlay.cpp
@@ -31,6 +31,19 @@ Text3DOverlay::Text3DOverlay() :
 {
 }
 
+Text3DOverlay::Text3DOverlay(Text3DOverlay* text3DOverlay) :
+    Planar3DOverlay(text3DOverlay),
+    _text(text3DOverlay->_text),
+    _backgroundColor(text3DOverlay->_backgroundColor),
+    _lineHeight(text3DOverlay->_lineHeight),
+    _leftMargin(text3DOverlay->_leftMargin),
+    _topMargin(text3DOverlay->_topMargin),
+    _rightMargin(text3DOverlay->_rightMargin),
+    _bottomMargin(text3DOverlay->_bottomMargin),
+    _isFacingAvatar(text3DOverlay->_isFacingAvatar)
+{
+}
+
 Text3DOverlay::~Text3DOverlay() {
 }
 
@@ -172,7 +185,6 @@ void Text3DOverlay::setProperties(const QScriptValue& properties) {
         setBottomMargin(properties.property("bottomMargin").toVariant().toFloat());
     }
 
-
     QScriptValue isFacingAvatarValue = properties.property("isFacingAvatar");
     if (isFacingAvatarValue.isValid()) {
         _isFacingAvatar = isFacingAvatarValue.toVariant().toBool();
@@ -207,10 +219,9 @@ QScriptValue Text3DOverlay::getProperty(const QString& property) {
     }
     return Planar3DOverlay::getProperty(property);
 }
+
 Text3DOverlay* Text3DOverlay::createClone() {
-    Text3DOverlay* clone = new Text3DOverlay();
-    writeToClone(clone);
-    return clone;
+    return new Text3DOverlay(this);;
 }
 
 float Text3DOverlay::textWidth(const QString& text) const {
@@ -220,15 +231,4 @@ float Text3DOverlay::textWidth(const QString& text) const {
     return scaleFactor * (float)fontMetrics.width(qPrintable(text));
 }
 
-void Text3DOverlay::writeToClone(Text3DOverlay* clone) {
-    Planar3DOverlay::writeToClone(clone);
-    clone->setText(getText());
-    clone->setLineHeight(getLineHeight());
-    clone->setLeftMargin(getLeftMargin());
-    clone->setTopMargin(getTopMargin());
-    clone->setRightMargin(getRightMargin());
-    clone->setBottomMargin(getBottomMargin());
-    clone->setIsFacingAvatar(getIsFacingAvatar());
-    clone->_backgroundColor = getBackgroundColor();
-}
 
diff --git a/interface/src/ui/overlays/Text3DOverlay.h b/interface/src/ui/overlays/Text3DOverlay.h
index a72efe7564..c459b2eb36 100644
--- a/interface/src/ui/overlays/Text3DOverlay.h
+++ b/interface/src/ui/overlays/Text3DOverlay.h
@@ -24,6 +24,7 @@ class Text3DOverlay : public Planar3DOverlay {
     
 public:
     Text3DOverlay();
+    Text3DOverlay(Text3DOverlay* text3DOverlay);
     ~Text3DOverlay();
     virtual void render(RenderArgs* args);
 
@@ -54,7 +55,6 @@ public:
     virtual Text3DOverlay* createClone();
 
 private:
-    virtual void writeToClone(Text3DOverlay* clone);
     void enableClipPlane(GLenum plane, float x, float y, float z, float w);
 
     QString _text;
diff --git a/interface/src/ui/overlays/TextOverlay.cpp b/interface/src/ui/overlays/TextOverlay.cpp
index 2d98cfc243..368a604c9a 100644
--- a/interface/src/ui/overlays/TextOverlay.cpp
+++ b/interface/src/ui/overlays/TextOverlay.cpp
@@ -25,6 +25,16 @@ TextOverlay::TextOverlay() :
 {
 }
 
+TextOverlay::TextOverlay(TextOverlay* textOverlay) :
+    Overlay2D(textOverlay),
+    _text(textOverlay->_text),
+    _backgroundColor(textOverlay->_backgroundColor),
+    _leftMargin(textOverlay->_leftMargin),
+    _topMargin(textOverlay->_topMargin),
+    _fontSize(textOverlay->_fontSize)
+{
+}
+
 TextOverlay::~TextOverlay() {
 }
 
@@ -125,9 +135,7 @@ void TextOverlay::setProperties(const QScriptValue& properties) {
 }
 
 TextOverlay* TextOverlay::createClone() {
-    TextOverlay* clone = new TextOverlay();
-    writeToClone(clone);
-    return clone;
+    return new TextOverlay(this);;
 }
 
 QScriptValue TextOverlay::getProperty(const QString& property) {
@@ -152,18 +160,8 @@ QScriptValue TextOverlay::getProperty(const QString& property) {
     return Overlay2D::getProperty(property);
 }
 
-void TextOverlay::writeToClone(TextOverlay* clone) {
-    Overlay2D::writeToClone(clone);
-    clone->_text = _text;
-    clone->_backgroundColor = _backgroundColor;
-    clone->_leftMargin = _leftMargin;
-    clone->_topMargin = _topMargin;
-    clone->_fontSize = _fontSize;
-}
-
 float TextOverlay::textWidth(const QString& text) const {
     QFont font(SANS_FONT_FAMILY, _fontSize, DEFAULT_FONT_WEIGHT);  // Same font properties as render()
     QFontMetrics fontMetrics(font);
     return fontMetrics.width(qPrintable(text));
 }
-
diff --git a/interface/src/ui/overlays/TextOverlay.h b/interface/src/ui/overlays/TextOverlay.h
index 30c91d02a3..adfd9bde17 100644
--- a/interface/src/ui/overlays/TextOverlay.h
+++ b/interface/src/ui/overlays/TextOverlay.h
@@ -37,6 +37,7 @@ class TextOverlay : public Overlay2D {
     
 public:
     TextOverlay();
+    TextOverlay(TextOverlay* textOverlay);
     ~TextOverlay();
     virtual void render(RenderArgs* args);
 
@@ -59,8 +60,6 @@ public:
     float textWidth(const QString& text) const;  // Pixels
 
 private:
-    virtual void writeToClone(TextOverlay* clone);
-
     QString _text;
     xColor _backgroundColor;
     int _leftMargin;
diff --git a/interface/src/ui/overlays/Volume3DOverlay.cpp b/interface/src/ui/overlays/Volume3DOverlay.cpp
index 8ceb51bbeb..42e2263a90 100644
--- a/interface/src/ui/overlays/Volume3DOverlay.cpp
+++ b/interface/src/ui/overlays/Volume3DOverlay.cpp
@@ -28,6 +28,12 @@ Volume3DOverlay::Volume3DOverlay() :
 {
 }
 
+Volume3DOverlay::Volume3DOverlay(Volume3DOverlay* volume3DOverlay) :
+    Base3DOverlay(volume3DOverlay),
+    _dimensions(volume3DOverlay->_dimensions)
+{
+}
+
 Volume3DOverlay::~Volume3DOverlay() {
 }
 
@@ -116,7 +122,3 @@ bool Volume3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::ve
     }
     return false;
 }
-
-void Volume3DOverlay::writeToClone(Volume3DOverlay* clone) {
-    Base3DOverlay::writeToClone(clone);
-}
diff --git a/interface/src/ui/overlays/Volume3DOverlay.h b/interface/src/ui/overlays/Volume3DOverlay.h
index d08a16d708..1bdfc307b5 100644
--- a/interface/src/ui/overlays/Volume3DOverlay.h
+++ b/interface/src/ui/overlays/Volume3DOverlay.h
@@ -26,6 +26,7 @@ class Volume3DOverlay : public Base3DOverlay {
     
 public:
     Volume3DOverlay();
+    Volume3DOverlay(Volume3DOverlay* volume3DOverlay);
     ~Volume3DOverlay();
 
     // getters
@@ -43,7 +44,6 @@ public:
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
 
 protected:
-    virtual void writeToClone(Volume3DOverlay* clone);
     glm::vec3 _dimensions;
 };
 

From b948ff2dc88b6bb5da9a0d5abee3cae29117cc66 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 15:13:13 -0800
Subject: [PATCH 31/38] Move dead pieces

---
 examples/entityScripts/chessPiece.js | 29 +++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index f6a2c46d28..0c7c6da8a7 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -136,19 +136,34 @@
     Entities.editEntity(this.entityID, { position: finalPos });
   }
   this.moveDeadPiece = function() {
-    return;
      var myPos = this.getIndexPosition(this.properties.position);
-     for (var i = 0; i < this.pieces.length; i++) {
-       if (this.pieces[i].id != this.entityID.id) {
-         var piecePos = this.getIndexPosition(Entities.getEntityProperties(this.pieces[i]).position);
+     
+     for (var i = 0; i < this.boardUserData.pieces.length; i++) {
+       var piece = this.boardUserData.pieces[i];
+  
+       if (piece.id != this.entityID.id) {
+         var properties = Entities.getEntityProperties(piece);
+         
+         var isWhite = properties.modelURL.search("White") !== -1;
+         var type = (properties.modelURL.search("King") !== -1) ?  4 :
+                    (properties.modelURL.search("Queen") !== -1) ?  3 :
+                    (properties.modelURL.search("Rook") !== -1) ?  2 :
+                    (properties.modelURL.search("Knight") !== -1) ?  1 :
+                    (properties.modelURL.search("Bishop") !== -1) ?  0 :
+                    (properties.modelURL.search("Pawn") !== -1) ?  -1 : -2;
+        
+         var piecePos = this.getIndexPosition(properties.position);
          if (myPos.i === piecePos.i && myPos.j === piecePos.j) {
-           Entities.editEntity(this.pieces[i], { position: this.getAbsolutePosition({ i: 0, j: 0 })});
+           var position = this.getAbsolutePosition((isWhite) ? { i: type, j: -1 } : { i: 7 - type, j: 8 },
+                                                    properties.dimensions.y / 2.0);
+           Entities.editEntity(piece, {
+             position: position
+           });
            break;
          }
        }
      }
   }
-
   
   this.grab = function(mouseEvent) {
     if (this.active) {
@@ -165,7 +180,7 @@
     if (this.active) {
       this.updatePosition(mouseEvent);
       this.snapToGrid();
-      //this.moveDeadPiece(); TODO
+      this.moveDeadPiece();
       this.playSound();
     }
   }

From a6f57cb7e2bb31218576a8679157a7ccdedea6ea Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 15:13:54 -0800
Subject: [PATCH 32/38] Index error

---
 examples/playChess.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index 1b3c643af7..c60e1c6955 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -245,7 +245,7 @@ ChessGame.update = function() {
   if (ChessGame.pieces.length > 0) {
     var unknown = 0;
     ChessGame.board.userDataObject.pieces = new Array();
-    for(var i = 1; i < ChessGame.pieces.length; i++) {
+    for(var i = 0; i < ChessGame.pieces.length; i++) {
       ChessGame.pieces[i].entity = Entities.identifyEntity(ChessGame.pieces[i].entity);
       if (ChessGame.pieces[i].entity.isKnownID) {
         ChessGame.board.userDataObject.pieces.push(ChessGame.pieces[i].entity)

From 58796df843b43bc5e340f8f518a8d9d6054fc1a7 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 15:17:09 -0800
Subject: [PATCH 33/38] scriptEntity url

---
 examples/playChess.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/examples/playChess.js b/examples/playChess.js
index c60e1c6955..8a72e1ebb8 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -146,9 +146,11 @@ ChessGame.Piece = (function(position, dimensions, url, rotation) {
     rotation: rotation,
     dimensions: this.dimensions,
     modelURL: url,
-    //script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js",
-    //script: "https://s3-us-west-1.amazonaws.com/highfidelity-dev/scripts/chessPiece.js",
+    /**/
+    script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js",
+    /*/
     script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js",
+    /**/
     userData: this.buildUserDataString()
   }
   this.entity = null;

From 94f3f461ce24eb9b93b6389a78749d7e03a5da9b Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 15:21:34 -0800
Subject: [PATCH 34/38] Cleanup script for chess boards

---
 examples/cleanupChessboards.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 examples/cleanupChessboards.js

diff --git a/examples/cleanupChessboards.js b/examples/cleanupChessboards.js
new file mode 100644
index 0000000000..926c02b8cf
--- /dev/null
+++ b/examples/cleanupChessboards.js
@@ -0,0 +1,8 @@
+var entities = Entities.findEntities(MyAvatar.position, 10000);
+var URL = "https://s3.amazonaws.com/hifi-public/models/props/chess/";
+
+for(var i in entities) {
+  if (Entities.getEntityProperties(entities[i]).modelURL.slice(0, URL.length) === URL) {
+    Entities.deleteEntity(entities[i]);
+  }
+} 
\ No newline at end of file

From 38ed1043979c316171e8d75d2fe3b06813770c8c Mon Sep 17 00:00:00 2001
From: Thijs Wenker <me@thoys.nl>
Date: Sat, 15 Nov 2014 00:21:50 +0100
Subject: [PATCH 35/38] added const to copy constructors

---
 interface/src/ui/overlays/Base3DOverlay.cpp      | 2 +-
 interface/src/ui/overlays/Base3DOverlay.h        | 2 +-
 interface/src/ui/overlays/BillboardOverlay.cpp   | 4 ++--
 interface/src/ui/overlays/BillboardOverlay.h     | 4 ++--
 interface/src/ui/overlays/Circle3DOverlay.cpp    | 4 ++--
 interface/src/ui/overlays/Circle3DOverlay.h      | 4 ++--
 interface/src/ui/overlays/Cube3DOverlay.cpp      | 4 ++--
 interface/src/ui/overlays/Cube3DOverlay.h        | 4 ++--
 interface/src/ui/overlays/Grid3DOverlay.cpp      | 4 ++--
 interface/src/ui/overlays/Grid3DOverlay.h        | 4 ++--
 interface/src/ui/overlays/ImageOverlay.cpp       | 4 ++--
 interface/src/ui/overlays/ImageOverlay.h         | 4 ++--
 interface/src/ui/overlays/Line3DOverlay.cpp      | 4 ++--
 interface/src/ui/overlays/Line3DOverlay.h        | 4 ++--
 interface/src/ui/overlays/LocalModelsOverlay.cpp | 8 ++++----
 interface/src/ui/overlays/LocalModelsOverlay.h   | 4 ++--
 interface/src/ui/overlays/LocalVoxelsOverlay.cpp | 4 ++--
 interface/src/ui/overlays/LocalVoxelsOverlay.h   | 4 ++--
 interface/src/ui/overlays/ModelOverlay.cpp       | 4 ++--
 interface/src/ui/overlays/ModelOverlay.h         | 4 ++--
 interface/src/ui/overlays/Overlay.cpp            | 2 +-
 interface/src/ui/overlays/Overlay.h              | 4 ++--
 interface/src/ui/overlays/Overlay2D.cpp          | 2 +-
 interface/src/ui/overlays/Overlay2D.h            | 2 +-
 interface/src/ui/overlays/Planar3DOverlay.cpp    | 2 +-
 interface/src/ui/overlays/Planar3DOverlay.h      | 2 +-
 interface/src/ui/overlays/Rectangle3DOverlay.cpp | 4 ++--
 interface/src/ui/overlays/Rectangle3DOverlay.h   | 4 ++--
 interface/src/ui/overlays/Sphere3DOverlay.cpp    | 4 ++--
 interface/src/ui/overlays/Sphere3DOverlay.h      | 4 ++--
 interface/src/ui/overlays/Text3DOverlay.cpp      | 4 ++--
 interface/src/ui/overlays/Text3DOverlay.h        | 4 ++--
 interface/src/ui/overlays/TextOverlay.cpp        | 6 +++---
 interface/src/ui/overlays/TextOverlay.h          | 4 ++--
 interface/src/ui/overlays/Volume3DOverlay.cpp    | 2 +-
 interface/src/ui/overlays/Volume3DOverlay.h      | 2 +-
 36 files changed, 66 insertions(+), 66 deletions(-)

diff --git a/interface/src/ui/overlays/Base3DOverlay.cpp b/interface/src/ui/overlays/Base3DOverlay.cpp
index 7ed7079795..5a5bfcd937 100644
--- a/interface/src/ui/overlays/Base3DOverlay.cpp
+++ b/interface/src/ui/overlays/Base3DOverlay.cpp
@@ -31,7 +31,7 @@ Base3DOverlay::Base3DOverlay() :
 {
 }
 
-Base3DOverlay::Base3DOverlay(Base3DOverlay* base3DOverlay) :
+Base3DOverlay::Base3DOverlay(const Base3DOverlay* base3DOverlay) :
     Overlay(base3DOverlay),
     _position(base3DOverlay->_position),
     _lineWidth(base3DOverlay->_lineWidth),
diff --git a/interface/src/ui/overlays/Base3DOverlay.h b/interface/src/ui/overlays/Base3DOverlay.h
index 4422203566..8304883e3c 100644
--- a/interface/src/ui/overlays/Base3DOverlay.h
+++ b/interface/src/ui/overlays/Base3DOverlay.h
@@ -23,7 +23,7 @@ class Base3DOverlay : public Overlay {
     
 public:
     Base3DOverlay();
-    Base3DOverlay(Base3DOverlay* base3DOverlay);
+    Base3DOverlay(const Base3DOverlay* base3DOverlay);
     ~Base3DOverlay();
 
     // getters
diff --git a/interface/src/ui/overlays/BillboardOverlay.cpp b/interface/src/ui/overlays/BillboardOverlay.cpp
index 87c8f8bb74..dee5eceab7 100644
--- a/interface/src/ui/overlays/BillboardOverlay.cpp
+++ b/interface/src/ui/overlays/BillboardOverlay.cpp
@@ -24,7 +24,7 @@ BillboardOverlay::BillboardOverlay() :
       _isLoaded = false;
 }
 
-BillboardOverlay::BillboardOverlay(BillboardOverlay* billboardOverlay) :
+BillboardOverlay::BillboardOverlay(const BillboardOverlay* billboardOverlay) :
     Base3DOverlay(billboardOverlay),
     _newTextureNeeded(true),
     _scale(billboardOverlay->_scale),
@@ -226,6 +226,6 @@ bool BillboardOverlay::findRayIntersection(const glm::vec3& origin, const glm::v
     return false;
 }
 
-BillboardOverlay* BillboardOverlay::createClone() {
+BillboardOverlay* BillboardOverlay::createClone() const {
     return new BillboardOverlay(this);
 }
diff --git a/interface/src/ui/overlays/BillboardOverlay.h b/interface/src/ui/overlays/BillboardOverlay.h
index e8c25c8549..be947acf98 100644
--- a/interface/src/ui/overlays/BillboardOverlay.h
+++ b/interface/src/ui/overlays/BillboardOverlay.h
@@ -22,7 +22,7 @@ class BillboardOverlay : public Base3DOverlay {
     Q_OBJECT
 public:
     BillboardOverlay();
-    BillboardOverlay(BillboardOverlay* billboardOverlay);
+    BillboardOverlay(const BillboardOverlay* billboardOverlay);
 
     virtual void render(RenderArgs* args);
 
@@ -37,7 +37,7 @@ public:
 
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
     
-    virtual BillboardOverlay* createClone();
+    virtual BillboardOverlay* createClone() const;
 
 private slots:
     void replyFinished();
diff --git a/interface/src/ui/overlays/Circle3DOverlay.cpp b/interface/src/ui/overlays/Circle3DOverlay.cpp
index 6c0c82f3ec..d19297b589 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Circle3DOverlay.cpp
@@ -33,7 +33,7 @@ Circle3DOverlay::Circle3DOverlay() :
     _minorTickMarksColor.red = _minorTickMarksColor.green = _minorTickMarksColor.blue = (unsigned char)0;
 }
 
-Circle3DOverlay::Circle3DOverlay(Circle3DOverlay* circle3DOverlay) :
+Circle3DOverlay::Circle3DOverlay(const Circle3DOverlay* circle3DOverlay) :
     Planar3DOverlay(circle3DOverlay),
     _startAt(circle3DOverlay->_startAt),
     _endAt(circle3DOverlay->_endAt),
@@ -374,6 +374,6 @@ bool Circle3DOverlay::findRayIntersection(const glm::vec3& origin,
     return intersects;
 }
 
-Circle3DOverlay* Circle3DOverlay::createClone() {
+Circle3DOverlay* Circle3DOverlay::createClone() const {
     return new Circle3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Circle3DOverlay.h b/interface/src/ui/overlays/Circle3DOverlay.h
index cf9fc8e2fc..b428be7a43 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.h
+++ b/interface/src/ui/overlays/Circle3DOverlay.h
@@ -18,7 +18,7 @@ class Circle3DOverlay : public Planar3DOverlay {
     
 public:
     Circle3DOverlay();
-    Circle3DOverlay(Circle3DOverlay* circle3DOverlay);
+    Circle3DOverlay(const Circle3DOverlay* circle3DOverlay);
     ~Circle3DOverlay();
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
@@ -50,7 +50,7 @@ public:
 
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
 
-    virtual Circle3DOverlay* createClone();
+    virtual Circle3DOverlay* createClone() const;
     
 protected:
     float _startAt;
diff --git a/interface/src/ui/overlays/Cube3DOverlay.cpp b/interface/src/ui/overlays/Cube3DOverlay.cpp
index 2aa4d29f23..9c478c4465 100644
--- a/interface/src/ui/overlays/Cube3DOverlay.cpp
+++ b/interface/src/ui/overlays/Cube3DOverlay.cpp
@@ -22,7 +22,7 @@
 Cube3DOverlay::Cube3DOverlay() {
 }
 
-Cube3DOverlay::Cube3DOverlay(Cube3DOverlay* cube3DOverlay) :
+Cube3DOverlay::Cube3DOverlay(const Cube3DOverlay* cube3DOverlay) :
     Volume3DOverlay(cube3DOverlay)
 {
 }
@@ -108,6 +108,6 @@ void Cube3DOverlay::render(RenderArgs* args) {
     }
 }
 
-Cube3DOverlay* Cube3DOverlay::createClone() {
+Cube3DOverlay* Cube3DOverlay::createClone() const {
     return new Cube3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Cube3DOverlay.h b/interface/src/ui/overlays/Cube3DOverlay.h
index 4fe137b73c..9c199f2b7b 100644
--- a/interface/src/ui/overlays/Cube3DOverlay.h
+++ b/interface/src/ui/overlays/Cube3DOverlay.h
@@ -18,11 +18,11 @@ class Cube3DOverlay : public Volume3DOverlay {
     
 public:
     Cube3DOverlay();
-    Cube3DOverlay(Cube3DOverlay* cube3DOverlay);
+    Cube3DOverlay(const Cube3DOverlay* cube3DOverlay);
     ~Cube3DOverlay();
     virtual void render(RenderArgs* args);
 
-    virtual Cube3DOverlay* createClone();
+    virtual Cube3DOverlay* createClone() const;
 };
 
  
diff --git a/interface/src/ui/overlays/Grid3DOverlay.cpp b/interface/src/ui/overlays/Grid3DOverlay.cpp
index 601413226a..84610d7981 100644
--- a/interface/src/ui/overlays/Grid3DOverlay.cpp
+++ b/interface/src/ui/overlays/Grid3DOverlay.cpp
@@ -20,7 +20,7 @@ Grid3DOverlay::Grid3DOverlay() : Base3DOverlay(),
     _majorGridEvery(5) {
 }
 
-Grid3DOverlay::Grid3DOverlay(Grid3DOverlay* grid3DOverlay) :
+Grid3DOverlay::Grid3DOverlay(const Grid3DOverlay* grid3DOverlay) :
     Base3DOverlay(grid3DOverlay),
     _minorGridWidth(grid3DOverlay->_minorGridWidth),
     _majorGridEvery(grid3DOverlay->_majorGridEvery)
@@ -135,6 +135,6 @@ QScriptValue Grid3DOverlay::getProperty(const QString& property) {
     return Base3DOverlay::getProperty(property);
 }
 
-Grid3DOverlay* Grid3DOverlay::createClone() {
+Grid3DOverlay* Grid3DOverlay::createClone() const {
     return new Grid3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Grid3DOverlay.h b/interface/src/ui/overlays/Grid3DOverlay.h
index 28dfbf9de7..b162ff3d74 100644
--- a/interface/src/ui/overlays/Grid3DOverlay.h
+++ b/interface/src/ui/overlays/Grid3DOverlay.h
@@ -29,14 +29,14 @@ class Grid3DOverlay : public Base3DOverlay {
 
 public:
     Grid3DOverlay();
-    Grid3DOverlay(Grid3DOverlay* grid3DOverlay);
+    Grid3DOverlay(const Grid3DOverlay* grid3DOverlay);
     ~Grid3DOverlay();
 
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual Grid3DOverlay* createClone();
+    virtual Grid3DOverlay* createClone() const;
 
 private:
     float _minorGridWidth;
diff --git a/interface/src/ui/overlays/ImageOverlay.cpp b/interface/src/ui/overlays/ImageOverlay.cpp
index dd06ee4da2..fad19be292 100644
--- a/interface/src/ui/overlays/ImageOverlay.cpp
+++ b/interface/src/ui/overlays/ImageOverlay.cpp
@@ -27,7 +27,7 @@ ImageOverlay::ImageOverlay() :
     _isLoaded = false;
 }
 
-ImageOverlay::ImageOverlay(ImageOverlay* imageOverlay) :
+ImageOverlay::ImageOverlay(const ImageOverlay* imageOverlay) :
     Overlay2D(imageOverlay),
     _textureID(0),
     _textureBound(false),
@@ -172,6 +172,6 @@ QScriptValue ImageOverlay::getProperty(const QString& property) {
 
     return Overlay2D::getProperty(property);
 }
-ImageOverlay* ImageOverlay::createClone() {
+ImageOverlay* ImageOverlay::createClone() const {
     return new ImageOverlay(this);
 }
diff --git a/interface/src/ui/overlays/ImageOverlay.h b/interface/src/ui/overlays/ImageOverlay.h
index 9c8d48a2e2..cff557654f 100644
--- a/interface/src/ui/overlays/ImageOverlay.h
+++ b/interface/src/ui/overlays/ImageOverlay.h
@@ -33,7 +33,7 @@ class ImageOverlay : public Overlay2D {
     
 public:
     ImageOverlay();
-    ImageOverlay(ImageOverlay* imageOverlay);
+    ImageOverlay(const ImageOverlay* imageOverlay);
     ~ImageOverlay();
     virtual void render(RenderArgs* args);
 
@@ -47,7 +47,7 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual ImageOverlay* createClone();
+    virtual ImageOverlay* createClone() const;
 
 private slots:
     void replyFinished(); // we actually want to hide this...
diff --git a/interface/src/ui/overlays/Line3DOverlay.cpp b/interface/src/ui/overlays/Line3DOverlay.cpp
index aac773f08f..ae67bf9d92 100644
--- a/interface/src/ui/overlays/Line3DOverlay.cpp
+++ b/interface/src/ui/overlays/Line3DOverlay.cpp
@@ -18,7 +18,7 @@
 Line3DOverlay::Line3DOverlay() {
 }
 
-Line3DOverlay::Line3DOverlay(Line3DOverlay* line3DOverlay) :
+Line3DOverlay::Line3DOverlay(const Line3DOverlay* line3DOverlay) :
     Base3DOverlay(line3DOverlay),
     _end(line3DOverlay->_end)
 {
@@ -94,6 +94,6 @@ QScriptValue Line3DOverlay::getProperty(const QString& property) {
     return Base3DOverlay::getProperty(property);
 }
 
-Line3DOverlay* Line3DOverlay::createClone() {
+Line3DOverlay* Line3DOverlay::createClone() const {
     return new Line3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Line3DOverlay.h b/interface/src/ui/overlays/Line3DOverlay.h
index 3d481438b9..607fb0e0bb 100644
--- a/interface/src/ui/overlays/Line3DOverlay.h
+++ b/interface/src/ui/overlays/Line3DOverlay.h
@@ -18,7 +18,7 @@ class Line3DOverlay : public Base3DOverlay {
     
 public:
     Line3DOverlay();
-    Line3DOverlay(Line3DOverlay* line3DOverlay);
+    Line3DOverlay(const Line3DOverlay* line3DOverlay);
     ~Line3DOverlay();
     virtual void render(RenderArgs* args);
 
@@ -31,7 +31,7 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual Line3DOverlay* createClone();
+    virtual Line3DOverlay* createClone() const;
 
 protected:
     glm::vec3 _end;
diff --git a/interface/src/ui/overlays/LocalModelsOverlay.cpp b/interface/src/ui/overlays/LocalModelsOverlay.cpp
index 25cb0ead64..d8555c85ba 100644
--- a/interface/src/ui/overlays/LocalModelsOverlay.cpp
+++ b/interface/src/ui/overlays/LocalModelsOverlay.cpp
@@ -18,9 +18,9 @@ LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer) :
     _entityTreeRenderer(entityTreeRenderer) {
 }
 
-LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer, LocalModelsOverlay* localModelsOverlay) :
+LocalModelsOverlay::LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay) :
     Volume3DOverlay(localModelsOverlay),
-    _entityTreeRenderer(entityTreeRenderer)
+    _entityTreeRenderer(localModelsOverlay->_entityTreeRenderer)
 {
 
 }
@@ -56,6 +56,6 @@ void LocalModelsOverlay::render(RenderArgs* args) {
     }
 }
 
-LocalModelsOverlay* LocalModelsOverlay::createClone() {
-    return new LocalModelsOverlay(Application::getInstance()->getEntityClipboardRenderer(), this);
+LocalModelsOverlay* LocalModelsOverlay::createClone() const {
+    return new LocalModelsOverlay(this);
 }
diff --git a/interface/src/ui/overlays/LocalModelsOverlay.h b/interface/src/ui/overlays/LocalModelsOverlay.h
index c38bc6b2a3..39465de7f9 100644
--- a/interface/src/ui/overlays/LocalModelsOverlay.h
+++ b/interface/src/ui/overlays/LocalModelsOverlay.h
@@ -20,13 +20,13 @@ class LocalModelsOverlay : public Volume3DOverlay {
     Q_OBJECT
 public:
     LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer);
-    LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer, LocalModelsOverlay* localModelsOverlay);
+    LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay);
     ~LocalModelsOverlay();
     
     virtual void update(float deltatime);
     virtual void render(RenderArgs* args);
 
-    virtual LocalModelsOverlay* createClone();
+    virtual LocalModelsOverlay* createClone() const;
 
 private:
     EntityTreeRenderer* _entityTreeRenderer;
diff --git a/interface/src/ui/overlays/LocalVoxelsOverlay.cpp b/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
index 4c44fe6dd8..9cb3df8bf3 100644
--- a/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
+++ b/interface/src/ui/overlays/LocalVoxelsOverlay.cpp
@@ -28,7 +28,7 @@ LocalVoxelsOverlay::LocalVoxelsOverlay() :
 {
 }
 
-LocalVoxelsOverlay::LocalVoxelsOverlay(LocalVoxelsOverlay* localVoxelsOverlay) :
+LocalVoxelsOverlay::LocalVoxelsOverlay(const LocalVoxelsOverlay* localVoxelsOverlay) :
     Volume3DOverlay(localVoxelsOverlay),
     _voxelCount(localVoxelsOverlay->_voxelCount)
 {
@@ -109,7 +109,7 @@ void LocalVoxelsOverlay::setProperties(const QScriptValue &properties) {
     }
 }
 
-LocalVoxelsOverlay* LocalVoxelsOverlay::createClone() {
+LocalVoxelsOverlay* LocalVoxelsOverlay::createClone() const {
     return new LocalVoxelsOverlay(this);
 }
 
diff --git a/interface/src/ui/overlays/LocalVoxelsOverlay.h b/interface/src/ui/overlays/LocalVoxelsOverlay.h
index 3e5bbbc5b6..4afa44f9be 100644
--- a/interface/src/ui/overlays/LocalVoxelsOverlay.h
+++ b/interface/src/ui/overlays/LocalVoxelsOverlay.h
@@ -32,7 +32,7 @@ class LocalVoxelsOverlay : public Volume3DOverlay {
     Q_OBJECT
 public:
     LocalVoxelsOverlay();
-    LocalVoxelsOverlay(LocalVoxelsOverlay* localVoxelsOverlay);
+    LocalVoxelsOverlay(const LocalVoxelsOverlay* localVoxelsOverlay);
     ~LocalVoxelsOverlay();
     
     virtual void update(float deltatime);
@@ -41,7 +41,7 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual LocalVoxelsOverlay* createClone();
+    virtual LocalVoxelsOverlay* createClone() const;
 private:
     static QMap<QString, WeakVoxelSystemPointer> _voxelSystemMap; // treeName/voxelSystem
     
diff --git a/interface/src/ui/overlays/ModelOverlay.cpp b/interface/src/ui/overlays/ModelOverlay.cpp
index f1c588f45d..3594d7e828 100644
--- a/interface/src/ui/overlays/ModelOverlay.cpp
+++ b/interface/src/ui/overlays/ModelOverlay.cpp
@@ -22,7 +22,7 @@ ModelOverlay::ModelOverlay()
     _isLoaded = false;
 }
 
-ModelOverlay::ModelOverlay(ModelOverlay* modelOverlay) :
+ModelOverlay::ModelOverlay(const ModelOverlay* modelOverlay) :
     Base3DOverlay(modelOverlay),
     _model(),
     _modelTextures(QVariantMap()),
@@ -182,6 +182,6 @@ bool ModelOverlay::findRayIntersectionExtraInfo(const glm::vec3& origin, const g
     return _model.findRayIntersectionAgainstSubMeshes(origin, direction, distance, face, extraInfo);
 }
 
-ModelOverlay* ModelOverlay::createClone() {
+ModelOverlay* ModelOverlay::createClone() const {
     return new ModelOverlay(this);
 }
diff --git a/interface/src/ui/overlays/ModelOverlay.h b/interface/src/ui/overlays/ModelOverlay.h
index 393e09c78b..80b52ea27e 100644
--- a/interface/src/ui/overlays/ModelOverlay.h
+++ b/interface/src/ui/overlays/ModelOverlay.h
@@ -20,7 +20,7 @@ class ModelOverlay : public Base3DOverlay {
     Q_OBJECT
 public:
     ModelOverlay();
-    ModelOverlay(ModelOverlay* modelOverlay);
+    ModelOverlay(const ModelOverlay* modelOverlay);
 
     virtual void update(float deltatime);
     virtual void render(RenderArgs* args);
@@ -30,7 +30,7 @@ public:
     virtual bool findRayIntersectionExtraInfo(const glm::vec3& origin, const glm::vec3& direction, 
                                                     float& distance, BoxFace& face, QString& extraInfo) const;
 
-    virtual ModelOverlay* createClone();
+    virtual ModelOverlay* createClone() const;
 
 private:
 
diff --git a/interface/src/ui/overlays/Overlay.cpp b/interface/src/ui/overlays/Overlay.cpp
index e67c1572f1..549152ded0 100644
--- a/interface/src/ui/overlays/Overlay.cpp
+++ b/interface/src/ui/overlays/Overlay.cpp
@@ -39,7 +39,7 @@ Overlay::Overlay() :
 {
 }
 
-Overlay::Overlay(Overlay* overlay) :
+Overlay::Overlay(const Overlay* overlay) :
     _parent(NULL),
     _alpha(overlay->_alpha),
     _lastPulseUpdate(usecTimestampNow()),
diff --git a/interface/src/ui/overlays/Overlay.h b/interface/src/ui/overlays/Overlay.h
index 341a7b56a3..99ab588197 100644
--- a/interface/src/ui/overlays/Overlay.h
+++ b/interface/src/ui/overlays/Overlay.h
@@ -36,7 +36,7 @@ public:
     };
     
     Overlay();
-    Overlay(Overlay* overlay);
+    Overlay(const Overlay* overlay);
     ~Overlay();
     void init(QGLWidget* parent, QScriptEngine* scriptEngine);
     virtual void update(float deltatime) {}
@@ -79,7 +79,7 @@ public:
     void setAlphaPulse(float value) { _alphaPulse = value; }
 
     virtual void setProperties(const QScriptValue& properties);
-    virtual Overlay* createClone() = 0;
+    virtual Overlay* createClone() const = 0;
     virtual QScriptValue getProperty(const QString& property);
 
 protected:
diff --git a/interface/src/ui/overlays/Overlay2D.cpp b/interface/src/ui/overlays/Overlay2D.cpp
index 53ef9cdf29..df7df391eb 100644
--- a/interface/src/ui/overlays/Overlay2D.cpp
+++ b/interface/src/ui/overlays/Overlay2D.cpp
@@ -22,7 +22,7 @@
 Overlay2D::Overlay2D() {
 }
 
-Overlay2D::Overlay2D(Overlay2D* overlay2D) :
+Overlay2D::Overlay2D(const Overlay2D* overlay2D) :
     Overlay(overlay2D),
     _bounds(overlay2D->_bounds)
 {
diff --git a/interface/src/ui/overlays/Overlay2D.h b/interface/src/ui/overlays/Overlay2D.h
index ea3936c2c7..7493add905 100644
--- a/interface/src/ui/overlays/Overlay2D.h
+++ b/interface/src/ui/overlays/Overlay2D.h
@@ -28,7 +28,7 @@ class Overlay2D : public Overlay {
     
 public:
     Overlay2D();
-    Overlay2D(Overlay2D* overlay2D);
+    Overlay2D(const Overlay2D* overlay2D);
     ~Overlay2D();
     
     virtual bool is3D() const { return false; }
diff --git a/interface/src/ui/overlays/Planar3DOverlay.cpp b/interface/src/ui/overlays/Planar3DOverlay.cpp
index 390b92948c..a8288b241c 100644
--- a/interface/src/ui/overlays/Planar3DOverlay.cpp
+++ b/interface/src/ui/overlays/Planar3DOverlay.cpp
@@ -26,7 +26,7 @@ Planar3DOverlay::Planar3DOverlay() :
 {
 }
 
-Planar3DOverlay::Planar3DOverlay(Planar3DOverlay* planar3DOverlay) :
+Planar3DOverlay::Planar3DOverlay(const Planar3DOverlay* planar3DOverlay) :
     Base3DOverlay(planar3DOverlay),
     _dimensions(planar3DOverlay->_dimensions)
 {
diff --git a/interface/src/ui/overlays/Planar3DOverlay.h b/interface/src/ui/overlays/Planar3DOverlay.h
index 7de68e24b2..d34fe44ebc 100644
--- a/interface/src/ui/overlays/Planar3DOverlay.h
+++ b/interface/src/ui/overlays/Planar3DOverlay.h
@@ -26,7 +26,7 @@ class Planar3DOverlay : public Base3DOverlay {
     
 public:
     Planar3DOverlay();
-    Planar3DOverlay(Planar3DOverlay* planar3DOverlay);
+    Planar3DOverlay(const Planar3DOverlay* planar3DOverlay);
     ~Planar3DOverlay();
 
     // getters
diff --git a/interface/src/ui/overlays/Rectangle3DOverlay.cpp b/interface/src/ui/overlays/Rectangle3DOverlay.cpp
index a2043d77c1..bcca759cd4 100644
--- a/interface/src/ui/overlays/Rectangle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Rectangle3DOverlay.cpp
@@ -20,7 +20,7 @@
 Rectangle3DOverlay::Rectangle3DOverlay() {
 }
 
-Rectangle3DOverlay::Rectangle3DOverlay(Rectangle3DOverlay* rectangle3DOverlay) :
+Rectangle3DOverlay::Rectangle3DOverlay(const Rectangle3DOverlay* rectangle3DOverlay) :
     Planar3DOverlay(rectangle3DOverlay)
 {
 }
@@ -111,6 +111,6 @@ void Rectangle3DOverlay::setProperties(const QScriptValue &properties) {
     Planar3DOverlay::setProperties(properties);
 }
 
-Rectangle3DOverlay* Rectangle3DOverlay::createClone() {
+Rectangle3DOverlay* Rectangle3DOverlay::createClone() const {
     return new Rectangle3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Rectangle3DOverlay.h b/interface/src/ui/overlays/Rectangle3DOverlay.h
index 98e04324b4..5e75469f2d 100644
--- a/interface/src/ui/overlays/Rectangle3DOverlay.h
+++ b/interface/src/ui/overlays/Rectangle3DOverlay.h
@@ -18,12 +18,12 @@ class Rectangle3DOverlay : public Planar3DOverlay {
     
 public:
     Rectangle3DOverlay();
-    Rectangle3DOverlay(Rectangle3DOverlay* rectangle3DOverlay);
+    Rectangle3DOverlay(const Rectangle3DOverlay* rectangle3DOverlay);
     ~Rectangle3DOverlay();
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
 
-    virtual Rectangle3DOverlay* createClone();
+    virtual Rectangle3DOverlay* createClone() const;
 };
 
  
diff --git a/interface/src/ui/overlays/Sphere3DOverlay.cpp b/interface/src/ui/overlays/Sphere3DOverlay.cpp
index 30bb7d1c52..34064675e5 100644
--- a/interface/src/ui/overlays/Sphere3DOverlay.cpp
+++ b/interface/src/ui/overlays/Sphere3DOverlay.cpp
@@ -21,7 +21,7 @@
 Sphere3DOverlay::Sphere3DOverlay() {
 }
 
-Sphere3DOverlay::Sphere3DOverlay(Sphere3DOverlay* Sphere3DOverlay) :
+Sphere3DOverlay::Sphere3DOverlay(const Sphere3DOverlay* Sphere3DOverlay) :
     Volume3DOverlay(Sphere3DOverlay)
 {
 }
@@ -76,6 +76,6 @@ void Sphere3DOverlay::render(RenderArgs* args) {
 
 }
 
-Sphere3DOverlay* Sphere3DOverlay::createClone() {
+Sphere3DOverlay* Sphere3DOverlay::createClone() const {
     return new Sphere3DOverlay(this);
 }
diff --git a/interface/src/ui/overlays/Sphere3DOverlay.h b/interface/src/ui/overlays/Sphere3DOverlay.h
index 2f63c4fe48..3b881e5ba6 100644
--- a/interface/src/ui/overlays/Sphere3DOverlay.h
+++ b/interface/src/ui/overlays/Sphere3DOverlay.h
@@ -18,11 +18,11 @@ class Sphere3DOverlay : public Volume3DOverlay {
     
 public:
     Sphere3DOverlay();
-    Sphere3DOverlay(Sphere3DOverlay* Sphere3DOverlay);
+    Sphere3DOverlay(const Sphere3DOverlay* Sphere3DOverlay);
     ~Sphere3DOverlay();
     virtual void render(RenderArgs* args);
 
-    virtual Sphere3DOverlay* createClone();
+    virtual Sphere3DOverlay* createClone() const;
 };
 
  
diff --git a/interface/src/ui/overlays/Text3DOverlay.cpp b/interface/src/ui/overlays/Text3DOverlay.cpp
index 0a83ec80f5..88ac009ac7 100644
--- a/interface/src/ui/overlays/Text3DOverlay.cpp
+++ b/interface/src/ui/overlays/Text3DOverlay.cpp
@@ -31,7 +31,7 @@ Text3DOverlay::Text3DOverlay() :
 {
 }
 
-Text3DOverlay::Text3DOverlay(Text3DOverlay* text3DOverlay) :
+Text3DOverlay::Text3DOverlay(const Text3DOverlay* text3DOverlay) :
     Planar3DOverlay(text3DOverlay),
     _text(text3DOverlay->_text),
     _backgroundColor(text3DOverlay->_backgroundColor),
@@ -220,7 +220,7 @@ QScriptValue Text3DOverlay::getProperty(const QString& property) {
     return Planar3DOverlay::getProperty(property);
 }
 
-Text3DOverlay* Text3DOverlay::createClone() {
+Text3DOverlay* Text3DOverlay::createClone() const {
     return new Text3DOverlay(this);;
 }
 
diff --git a/interface/src/ui/overlays/Text3DOverlay.h b/interface/src/ui/overlays/Text3DOverlay.h
index c459b2eb36..c624830ac8 100644
--- a/interface/src/ui/overlays/Text3DOverlay.h
+++ b/interface/src/ui/overlays/Text3DOverlay.h
@@ -24,7 +24,7 @@ class Text3DOverlay : public Planar3DOverlay {
     
 public:
     Text3DOverlay();
-    Text3DOverlay(Text3DOverlay* text3DOverlay);
+    Text3DOverlay(const Text3DOverlay* text3DOverlay);
     ~Text3DOverlay();
     virtual void render(RenderArgs* args);
 
@@ -52,7 +52,7 @@ public:
 
     float textWidth(const QString& text) const;  // Meters
 
-    virtual Text3DOverlay* createClone();
+    virtual Text3DOverlay* createClone() const;
 
 private:
     void enableClipPlane(GLenum plane, float x, float y, float z, float w);
diff --git a/interface/src/ui/overlays/TextOverlay.cpp b/interface/src/ui/overlays/TextOverlay.cpp
index 368a604c9a..1d72cf7f05 100644
--- a/interface/src/ui/overlays/TextOverlay.cpp
+++ b/interface/src/ui/overlays/TextOverlay.cpp
@@ -25,7 +25,7 @@ TextOverlay::TextOverlay() :
 {
 }
 
-TextOverlay::TextOverlay(TextOverlay* textOverlay) :
+TextOverlay::TextOverlay(const TextOverlay* textOverlay) :
     Overlay2D(textOverlay),
     _text(textOverlay->_text),
     _backgroundColor(textOverlay->_backgroundColor),
@@ -134,8 +134,8 @@ void TextOverlay::setProperties(const QScriptValue& properties) {
     }
 }
 
-TextOverlay* TextOverlay::createClone() {
-    return new TextOverlay(this);;
+TextOverlay* TextOverlay::createClone() const {
+    return new TextOverlay(this);
 }
 
 QScriptValue TextOverlay::getProperty(const QString& property) {
diff --git a/interface/src/ui/overlays/TextOverlay.h b/interface/src/ui/overlays/TextOverlay.h
index adfd9bde17..703e15be10 100644
--- a/interface/src/ui/overlays/TextOverlay.h
+++ b/interface/src/ui/overlays/TextOverlay.h
@@ -37,7 +37,7 @@ class TextOverlay : public Overlay2D {
     
 public:
     TextOverlay();
-    TextOverlay(TextOverlay* textOverlay);
+    TextOverlay(const TextOverlay* textOverlay);
     ~TextOverlay();
     virtual void render(RenderArgs* args);
 
@@ -54,7 +54,7 @@ public:
     void setFontSize(int fontSize) { _fontSize = fontSize; }
 
     virtual void setProperties(const QScriptValue& properties);
-    virtual TextOverlay* createClone();
+    virtual TextOverlay* createClone() const;
     virtual QScriptValue getProperty(const QString& property);
 
     float textWidth(const QString& text) const;  // Pixels
diff --git a/interface/src/ui/overlays/Volume3DOverlay.cpp b/interface/src/ui/overlays/Volume3DOverlay.cpp
index 42e2263a90..c4192a15b2 100644
--- a/interface/src/ui/overlays/Volume3DOverlay.cpp
+++ b/interface/src/ui/overlays/Volume3DOverlay.cpp
@@ -28,7 +28,7 @@ Volume3DOverlay::Volume3DOverlay() :
 {
 }
 
-Volume3DOverlay::Volume3DOverlay(Volume3DOverlay* volume3DOverlay) :
+Volume3DOverlay::Volume3DOverlay(const Volume3DOverlay* volume3DOverlay) :
     Base3DOverlay(volume3DOverlay),
     _dimensions(volume3DOverlay->_dimensions)
 {
diff --git a/interface/src/ui/overlays/Volume3DOverlay.h b/interface/src/ui/overlays/Volume3DOverlay.h
index 1bdfc307b5..005646c036 100644
--- a/interface/src/ui/overlays/Volume3DOverlay.h
+++ b/interface/src/ui/overlays/Volume3DOverlay.h
@@ -26,7 +26,7 @@ class Volume3DOverlay : public Base3DOverlay {
     
 public:
     Volume3DOverlay();
-    Volume3DOverlay(Volume3DOverlay* volume3DOverlay);
+    Volume3DOverlay(const Volume3DOverlay* volume3DOverlay);
     ~Volume3DOverlay();
 
     // getters

From 87d472a5a966da0feaf9a0ffb65412f5125156ac Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 16:15:22 -0800
Subject: [PATCH 36/38] 2 space indent -> 4 space indent

---
 examples/entityScripts/chessPiece.js | 362 ++++++++++++------------
 examples/playChess.js                | 394 +++++++++++++--------------
 2 files changed, 379 insertions(+), 377 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index 0c7c6da8a7..ebe2df7e55 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -1,205 +1,207 @@
 (function(){
-  this.FIRST_TILE = null; // Global position of the first tile (1a)
-  this.TILE_SIZE = null; // Size of one tile
-  this.whitesDeadPieces = null;
-  this.blacksDeadPieces = null;
+    this.FIRST_TILE = null; // Global position of the first tile (1a)
+    this.TILE_SIZE = null; // Size of one tile
+    this.whitesDeadPieces = null;
+    this.blacksDeadPieces = null;
   
-  this.wantDebug = false;
-  this.active = false;
+    this.wantDebug = false;
+    this.active = false;
   
-  this.entityID = null;
-  this.properties = null;
-  this.boardID = null;
-  this.boardUserData = null;
+    this.entityID = null;
+    this.properties = null;
+    this.boardID = null;
+    this.boardUserData = null;
   
-  this.sound = null;
-  this.startingTile = null;
-  this.pieces = new Array();
+    this.sound = null;
+    this.startingTile = null;
+    this.pieces = new Array();
   
-  // All callbacks start by updating the properties
-  this.updateProperties = function(entityID) {
-    // Piece ID
-    if (this.entityID === null || !this.entityID.isKnownID) {
-      this.entityID = Entities.identifyEntity(entityID);
-    }
-    // Piece Properties
-    this.properties = Entities.getEntityProperties(this.entityID);
+    // All callbacks start by updating the properties
+    this.updateProperties = function(entityID) {
+        // Piece ID
+        if (this.entityID === null || !this.entityID.isKnownID) {
+            this.entityID = Entities.identifyEntity(entityID);
+        }
+        // Piece Properties
+        this.properties = Entities.getEntityProperties(this.entityID);
     
-    // Board ID
-    if (this.boardID === null) {
-      // Read user data string and update boardID
-      var userData = JSON.parse(this.properties.userData);
-      var boardID = Entities.identifyEntity(userData.boardID);
-      if (boardID.isKnownID) {
-        this.boardID = boardID;
-      } else {
-        return;
-      }
-    }
+        // Board ID
+        if (this.boardID === null) {
+            // Read user data string and update boardID
+            var userData = JSON.parse(this.properties.userData);
+            var boardID = Entities.identifyEntity(userData.boardID);
+            if (boardID.isKnownID) {
+                this.boardID = boardID;
+            } else {
+                return;
+            }
+        }
     
-    // Board User Data
-    this.updateUserData();
-  }
-  // Get an entity's user data
-  this.getEntityUserData = function(entityID) {
-    var properties = Entities.getEntityProperties(entityID);
-    
-    if (properties && properties.userData){
-      return JSON.parse(properties.userData);
-    } else {
-      print("No user data found.");
-      return null;
+        // Board User Data
+        this.updateUserData();
     }
-  }
-  // Updates user data related objects
-  this.updateUserData = function() {
-    // Get board's user data
-    if (this.boardID !== null && this.boardID.isKnownID) {
-      this.boardUserData = this.getEntityUserData(this.boardID);
-      if (!(this.boardUserData &&
-            this.boardUserData.firstTile &&
-            this.boardUserData.tileSize &&
-            this.boardUserData.whitesDeadPieces &&
-            this.boardUserData.blacksDeadPieces)) {
-        print("Incomplete boardUserData " + this.boardID.id);
-      } else {
-        this.FIRST_TILE = this.boardUserData.firstTile;
-        this.TILE_SIZE = this.boardUserData.tileSize;
-        this.whitesDeadPieces = this.boardUserData.whitesDeadPieces;
-        this.blacksDeadPieces = this.boardUserData.blacksDeadPieces;
+    // Get an entity's user data
+    this.getEntityUserData = function(entityID) {
+        var properties = Entities.getEntityProperties(entityID);
+    
+        if (properties && properties.userData){
+            return JSON.parse(properties.userData);
+        } else {
+            print("No user data found.");
+            return null;
+        }
+    }
+    // Updates user data related objects
+    this.updateUserData = function() {
+        // Get board's user data
+        if (this.boardID !== null && this.boardID.isKnownID) {
+            this.boardUserData = this.getEntityUserData(this.boardID);
+      
+            if (!(this.boardUserData &&
+                this.boardUserData.firstTile &&
+                this.boardUserData.tileSize &&
+                this.boardUserData.whitesDeadPieces &&
+                this.boardUserData.blacksDeadPieces &&
+                this.boardUserData.pieces)) {
+                print("Incomplete boardUserData " + this.boardID.id);
+            } else {
+                this.FIRST_TILE = this.boardUserData.firstTile;
+                this.TILE_SIZE = this.boardUserData.tileSize;
+                this.whitesDeadPieces = this.boardUserData.whitesDeadPieces;
+                this.blacksDeadPieces = this.boardUserData.blacksDeadPieces;
         
-        this.active = true;
-      }
-    } else {
-      print("Missing boardID:" + JSON.stringify(this.boardID));
+                this.active = true;
+            }
+        } else {
+            print("Missing boardID:" + JSON.stringify(this.boardID));
+        }
     }
-  }
-  // Returns whether pos is inside the grid or not
-  this.isOutsideGrid = function(pos) {
-    return !(pos.i >= 0 && pos.j >= 0 && pos.i < 8 && pos.j < 8);
-  }
-  // Returns the tile coordinate
-  this.getIndexPosition = function(position) {
-    var halfTile = this.TILE_SIZE / 2.0;
-    var corner = Vec3.sum(this.FIRST_TILE, { x: -halfTile, y: 0.0, z: -halfTile });
-    var relative = Vec3.subtract(position, corner);
-    return {
-      i: Math.floor(relative.x / this.TILE_SIZE),
-      j: Math.floor(relative.z / this.TILE_SIZE)
+    // Returns whether pos is inside the grid or not
+    this.isOutsideGrid = function(pos) {
+        return !(pos.i >= 0 && pos.j >= 0 && pos.i < 8 && pos.j < 8);
     }
-  }
-  // Returns the world position
-  this.getAbsolutePosition = function(pos, halfHeight) {
-    var relative = {
-      x: pos.i * this.TILE_SIZE,
-      y: halfHeight,
-      z: pos.j * this.TILE_SIZE
+    // Returns the tile coordinate
+    this.getIndexPosition = function(position) {
+        var halfTile = this.TILE_SIZE / 2.0;
+        var corner = Vec3.sum(this.FIRST_TILE, { x: -halfTile, y: 0.0, z: -halfTile });
+        var relative = Vec3.subtract(position, corner);
+        return {
+            i: Math.floor(relative.x / this.TILE_SIZE),
+            j: Math.floor(relative.z / this.TILE_SIZE)
+        }
     }
-    return Vec3.sum(this.FIRST_TILE, relative);
-  }
-  // Pr, Vr are respectively the Ray's Point of origin and Vector director
-  // Pp, Np are respectively the Plane's Point of origin and Normal vector
-  this.rayPlaneIntersection = function(Pr, Vr, Pp, Np) {
-    var d = -Vec3.dot(Pp, Np);
-    var t = -(Vec3.dot(Pr, Np) + d) / Vec3.dot(Vr, Np);
-    return Vec3.sum(Pr, Vec3.multiply(t, Vr));
-  }
-  // Download sound if needed
-  this.maybeDownloadSound = function() {
-    if (this.sound === null) {
-      this.sound = SoundCache.getSound("http://public.highfidelity.io/sounds/Footsteps/FootstepW3Left-12db.wav");
+    // Returns the world position
+    this.getAbsolutePosition = function(pos, halfHeight) {
+        var relative = {
+            x: pos.i * this.TILE_SIZE,
+            y: halfHeight,
+            z: pos.j * this.TILE_SIZE
+        }
+        return Vec3.sum(this.FIRST_TILE, relative);
     }
-  }
-  // Play drop sound
-  this.playSound = function() {
-    if (this.sound && this.sound.downloaded) {
-  		Audio.playSound(this.sound, { position: this.properties.position });
+    // Pr, Vr are respectively the Ray's Point of origin and Vector director
+    // Pp, Np are respectively the Plane's Point of origin and Normal vector
+    this.rayPlaneIntersection = function(Pr, Vr, Pp, Np) {
+        var d = -Vec3.dot(Pp, Np);
+        var t = -(Vec3.dot(Pr, Np) + d) / Vec3.dot(Vr, Np);
+        return Vec3.sum(Pr, Vec3.multiply(t, Vr));
     }
-  }
-  // updates the piece position based on mouse input
-  this.updatePosition = function(mouseEvent) {
-    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);                                 
-    // if piece outside grid then send it back to the starting tile
-    if (this.isOutsideGrid(this.getIndexPosition(intersection))) {
-      intersection = this.getAbsolutePosition(this.startingTile, this.properties.dimensions.y / 2.0);
+    // Download sound if needed
+    this.maybeDownloadSound = function() {
+        if (this.sound === null) {
+            this.sound = SoundCache.getSound("http://public.highfidelity.io/sounds/Footsteps/FootstepW3Left-12db.wav");
+        }
     }
-    Entities.editEntity(this.entityID, { position: intersection });
-  }
-  // Snap piece to the center of the tile it is on
-  this.snapToGrid = function() {
-    var pos = this.getIndexPosition(this.properties.position);
-    var finalPos = this.getAbsolutePosition((this.isOutsideGrid(pos)) ?  this.startingTile : pos,
-                                            this.properties.dimensions.y / 2.0);
-    Entities.editEntity(this.entityID, { position: finalPos });
-  }
-  this.moveDeadPiece = function() {
-     var myPos = this.getIndexPosition(this.properties.position);
+    // Play drop sound
+    this.playSound = function() {
+        if (this.sound && this.sound.downloaded) {
+            Audio.playSound(this.sound, { position: this.properties.position });
+        }
+    }
+    // updates the piece position based on mouse input
+    this.updatePosition = function(mouseEvent) {
+        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);                                 
+        // if piece outside grid then send it back to the starting tile
+        if (this.isOutsideGrid(this.getIndexPosition(intersection))) {
+            intersection = this.getAbsolutePosition(this.startingTile, this.properties.dimensions.y / 2.0);
+        }
+        Entities.editEntity(this.entityID, { position: intersection });
+    }
+    // Snap piece to the center of the tile it is on
+    this.snapToGrid = function() {
+        var pos = this.getIndexPosition(this.properties.position);
+        var finalPos = this.getAbsolutePosition((this.isOutsideGrid(pos)) ?  this.startingTile : pos,
+        this.properties.dimensions.y / 2.0);
+        Entities.editEntity(this.entityID, { position: finalPos });
+    }
+    this.moveDeadPiece = function() {
+        var myPos = this.getIndexPosition(this.properties.position);
      
-     for (var i = 0; i < this.boardUserData.pieces.length; i++) {
-       var piece = this.boardUserData.pieces[i];
+        for (var i = 0; i < this.boardUserData.pieces.length; i++) {
+            var piece = this.boardUserData.pieces[i];
   
-       if (piece.id != this.entityID.id) {
-         var properties = Entities.getEntityProperties(piece);
+            if (piece.id != this.entityID.id) {
+                var properties = Entities.getEntityProperties(piece);
          
-         var isWhite = properties.modelURL.search("White") !== -1;
-         var type = (properties.modelURL.search("King") !== -1) ?  4 :
-                    (properties.modelURL.search("Queen") !== -1) ?  3 :
-                    (properties.modelURL.search("Rook") !== -1) ?  2 :
-                    (properties.modelURL.search("Knight") !== -1) ?  1 :
-                    (properties.modelURL.search("Bishop") !== -1) ?  0 :
-                    (properties.modelURL.search("Pawn") !== -1) ?  -1 : -2;
+                var isWhite = properties.modelURL.search("White") !== -1;
+                var type = (properties.modelURL.search("King") !== -1) ?  4 :
+                (properties.modelURL.search("Queen") !== -1) ?  3 :
+                (properties.modelURL.search("Rook") !== -1) ?  2 :
+                (properties.modelURL.search("Knight") !== -1) ?  1 :
+                (properties.modelURL.search("Bishop") !== -1) ?  0 :
+                (properties.modelURL.search("Pawn") !== -1) ?  -1 : -2;
         
-         var piecePos = this.getIndexPosition(properties.position);
-         if (myPos.i === piecePos.i && myPos.j === piecePos.j) {
-           var position = this.getAbsolutePosition((isWhite) ? { i: type, j: -1 } : { i: 7 - type, j: 8 },
-                                                    properties.dimensions.y / 2.0);
-           Entities.editEntity(piece, {
-             position: position
-           });
-           break;
-         }
-       }
-     }
-  }
+                var piecePos = this.getIndexPosition(properties.position);
+                if (myPos.i === piecePos.i && myPos.j === piecePos.j) {
+                    var position = this.getAbsolutePosition((isWhite) ? { i: type, j: -1 } : { i: 7 - type, j: 8 },
+                    properties.dimensions.y / 2.0);
+                    Entities.editEntity(piece, {
+                        position: position
+                    });
+                    break;
+                }
+            }
+        }
+    }
   
-  this.grab = function(mouseEvent) {
-    if (this.active) {
-      this.startingTile = this.getIndexPosition(this.properties.position);
-      this.updatePosition(mouseEvent);
+    this.grab = function(mouseEvent) {
+        if (this.active) {
+            this.startingTile = this.getIndexPosition(this.properties.position);
+            this.updatePosition(mouseEvent);
+        }
     }
-  }
-  this.move = function(mouseEvent) {
-    if (this.active) {
-      this.updatePosition(mouseEvent);
+    this.move = function(mouseEvent) {
+        if (this.active) {
+            this.updatePosition(mouseEvent);
+        }
     }
-  }
-  this.release = function(mouseEvent) {
-    if (this.active) {
-      this.updatePosition(mouseEvent);
-      this.snapToGrid();
-      this.moveDeadPiece();
-      this.playSound();
+    this.release = function(mouseEvent) {
+        if (this.active) {
+            this.updatePosition(mouseEvent);
+            this.snapToGrid();
+            this.moveDeadPiece();
+            this.playSound();
+        }
     }
-  }
   
-  this.preload = function(entityID) {
-    this.updateProperties(entityID); // All callbacks start by updating the properties
-    this.maybeDownloadSound();
-  }
-  this.clickDownOnEntity = function(entityID, mouseEvent) {
-    this.preload(entityID); // TODO : remove
-    this.updateProperties(entityID); // All callbacks start by updating the properties
-    this.grab(mouseEvent);
-  };
-  this.holdingClickOnEntity = function(entityID, mouseEvent) {
-    this.updateProperties(entityID); // All callbacks start by updating the properties
-    this.move(mouseEvent);
-  };
-  this.clickReleaseOnEntity = function(entityID, mouseEvent) {
-    this.updateProperties(entityID); // All callbacks start by updating the properties
-    this.release(mouseEvent);
-  };
+    this.preload = function(entityID) {
+        this.updateProperties(entityID); // All callbacks start by updating the properties
+        this.maybeDownloadSound();
+    }
+    this.clickDownOnEntity = function(entityID, mouseEvent) {
+        this.preload(entityID); // TODO : remove
+        this.updateProperties(entityID); // All callbacks start by updating the properties
+        this.grab(mouseEvent);
+    };
+    this.holdingClickOnEntity = function(entityID, mouseEvent) {
+        this.updateProperties(entityID); // All callbacks start by updating the properties
+        this.move(mouseEvent);
+    };
+    this.clickReleaseOnEntity = function(entityID, mouseEvent) {
+        this.updateProperties(entityID); // All callbacks start by updating the properties
+        this.release(mouseEvent);
+    };
 })
\ No newline at end of file
diff --git a/examples/playChess.js b/examples/playChess.js
index 8a72e1ebb8..1b6882ed6e 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -14,266 +14,266 @@ var gameSize = 1.0;
 // Script namespace
 var extraDebug = extraDebug || true;
 var ChessGame = ChessGame || {
-  BOARD: {
-    modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Board.fbx",
-    dimensions: { x: 773.191, y: 20.010, z: 773.191 },
-    rotation: Quat.fromPitchYawRollDegrees(0, 90, 0),
-    numTiles: 10.0
-  },
-  KING: 0, QUEEN: 1, BISHOP: 2, KNIGHT: 3, ROOK: 4, PAWN: 5,
+    BOARD: {
+        modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/Board.fbx",
+        dimensions: { x: 773.191, y: 20.010, z: 773.191 },
+        rotation: Quat.fromPitchYawRollDegrees(0, 90, 0),
+        numTiles: 10.0
+    },
+    KING: 0, QUEEN: 1, BISHOP: 2, KNIGHT: 3, ROOK: 4, PAWN: 5,
   
-  board: null,
-  pieces: new Array()
+    board: null,
+    pieces: new Array()
 };
 
 ChessGame.getPieceInfo = function(type, isWhite) {
-  var info = {
-    modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/",
-    dimensions: { x: 1.0, y: 1.0, z: 1.0 },
-    rotation: Quat.fromPitchYawRollDegrees(0, 0, 0)
-  }
+    var info = {
+        modelURL: "https://s3.amazonaws.com/hifi-public/models/props/chess/",
+        dimensions: { x: 1.0, y: 1.0, z: 1.0 },
+        rotation: Quat.fromPitchYawRollDegrees(0, 0, 0)
+    }
   
-  switch(type) {
-  case ChessGame.KING:
-    info.modelURL += "King";
-    info.dimensions = { x: 110.496, y: 306.713, z: 110.496 };
-    info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
-    break;
-  case ChessGame.QUEEN:
-    info.modelURL += "Queen";
-    info.dimensions = { x: 110.496, y: 257.459, z: 110.496 };
-    break;
-  case ChessGame.BISHOP:
-    info.modelURL += "Bishop";
-    info.dimensions = { x: 102.002, y: 213.941, z: 102.002 };
-    info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
-    break;
-  case ChessGame.KNIGHT:
-    info.modelURL += "Knight";
-    info.dimensions = { x: 95.602, y: 186.939, z: 95.602 };
-    info.rotation = Quat.fromPitchYawRollDegrees(0, 180, 0);
-    break;
-  case ChessGame.ROOK:
-    info.modelURL += "Rook";
-    info.dimensions = { x: 101.024, y: 167.523, z: 101.024 };
-    break;
-  case ChessGame.PAWN:
-    info.modelURL += "Pawn";
-    info.dimensions = { x: 93.317, y: 138.747, z: 93.317 };
-    break;
-  }
-  info.modelURL += ((isWhite) ? "_White" : "_Black") + ".fbx"
+    switch(type) {
+    case ChessGame.KING:
+        info.modelURL += "King";
+        info.dimensions = { x: 110.496, y: 306.713, z: 110.496 };
+        info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
+        break;
+    case ChessGame.QUEEN:
+        info.modelURL += "Queen";
+        info.dimensions = { x: 110.496, y: 257.459, z: 110.496 };
+        break;
+    case ChessGame.BISHOP:
+        info.modelURL += "Bishop";
+        info.dimensions = { x: 102.002, y: 213.941, z: 102.002 };
+        info.rotation = Quat.fromPitchYawRollDegrees(0, 90, 0);
+        break;
+    case ChessGame.KNIGHT:
+        info.modelURL += "Knight";
+        info.dimensions = { x: 95.602, y: 186.939, z: 95.602 };
+        info.rotation = Quat.fromPitchYawRollDegrees(0, 180, 0);
+        break;
+    case ChessGame.ROOK:
+        info.modelURL += "Rook";
+        info.dimensions = { x: 101.024, y: 167.523, z: 101.024 };
+        break;
+    case ChessGame.PAWN:
+        info.modelURL += "Pawn";
+        info.dimensions = { x: 93.317, y: 138.747, z: 93.317 };
+        break;
+    }
+    info.modelURL += ((isWhite) ? "_White" : "_Black") + ".fbx"
   
-  return info;
+    return info;
 }
 
 
 // Board class
 ChessGame.Board = (function(position, scale) {
-  this.dimensions = Vec3.multiply(1.0 / ChessGame.BOARD.dimensions.x, ChessGame.BOARD.dimensions); // 1 by 1
-  this.dimensions = Vec3.multiply(scale, this.dimensions); // scale by scale
-  this.position = position
-  this.tileSize = scale / ChessGame.BOARD.numTiles;
+    this.dimensions = Vec3.multiply(1.0 / ChessGame.BOARD.dimensions.x, ChessGame.BOARD.dimensions); // 1 by 1
+    this.dimensions = Vec3.multiply(scale, this.dimensions); // scale by scale
+    this.position = position
+    this.tileSize = scale / ChessGame.BOARD.numTiles;
   
-  this.userDataObject = {
-    firstTile: this.tilePosition(1, 1),
-    tileSize: this.tileSize,
-    whitesDeadPieces: this.tilePosition(0,0),
-    blacksDeadPieces: this.tilePosition(9,9),
-    pieces: new Array()
-  }
-  this.entityProperties = {
-    type: "Model",
-    modelURL: ChessGame.BOARD.modelURL,
-    position: this.position,
-    dimensions: this.dimensions,
-    userData: this.buildUserDataString()
-  }
-  this.entity = null;
+    this.userDataObject = {
+        firstTile: this.tilePosition(1, 1),
+        tileSize: this.tileSize,
+        whitesDeadPieces: this.tilePosition(0,0),
+        blacksDeadPieces: this.tilePosition(9,9),
+        pieces: new Array()
+    }
+    this.entityProperties = {
+        type: "Model",
+        modelURL: ChessGame.BOARD.modelURL,
+        position: this.position,
+        dimensions: this.dimensions,
+        userData: this.buildUserDataString()
+    }
+    this.entity = null;
 });
 // Returns the top center point of tile i,j
 ChessGame.Board.prototype.tilePosition = function(i, j) {
-  if (!(this.position || this.dimensions || this.tileSize || ChessGame.BOARD.numTiles)) {
-    print("ChessGame.Board.prototype.tilePosition(): Called before proper initialisation, bailing.");
-    return null;
-  }
-  return {
-    x: this.position.x + (i - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize,
-    y: this.position.y + this.dimensions.y / 2.0,
-    z: this.position.z + (j - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize
-  };
+    if (!(this.position || this.dimensions || this.tileSize || ChessGame.BOARD.numTiles)) {
+        print("ChessGame.Board.prototype.tilePosition(): Called before proper initialisation, bailing.");
+        return null;
+    }
+    return {
+        x: this.position.x + (i - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize,
+        y: this.position.y + this.dimensions.y / 2.0,
+        z: this.position.z + (j - ChessGame.BOARD.numTiles / 2.0 + 0.5) * this.tileSize
+    };
 }
 // Checks the color of the tile
 ChessGame.Board.prototype.isWhite = function(i, j) {
-  return (i + j) % 2 != 0;
+    return (i + j) % 2 != 0;
 }
 // Build the user data string
 ChessGame.Board.prototype.buildUserDataString = function() {
-  return JSON.stringify(this.userDataObject);
+    return JSON.stringify(this.userDataObject);
 }
 // Updates the user data stored by the board
 ChessGame.Board.prototype.updateUserData = function() {
-  var userDataString = this.buildUserDataString();
-  this.entityProperties.userData = userDataString;
-  Entities.editEntity(this.entity, { userData: userDataString });
+    var userDataString = this.buildUserDataString();
+    this.entityProperties.userData = userDataString;
+    Entities.editEntity(this.entity, { userData: userDataString });
 }
 // Spawns the board using entities
 ChessGame.Board.prototype.spawn = function() {
-  if (extraDebug) {
-    print("Spawning board...");
-  }
-  this.entity = Entities.addEntity(this.entityProperties);
-  print("Board spawned");
+    if (extraDebug) {
+        print("Spawning board...");
+    }
+    this.entity = Entities.addEntity(this.entityProperties);
+    print("Board spawned");
 }
 // Cleans up the entities of the board
 ChessGame.Board.prototype.cleanup = function() {
-  if (extraDebug) {
-    print("Cleaning up board...");
-  }
-  Entities.deleteEntity(this.entity);
-  print("Board cleaned up");
+    if (extraDebug) {
+        print("Cleaning up board...");
+    }
+    Entities.deleteEntity(this.entity);
+    print("Board cleaned up");
 }
 
 // Piece class
 ChessGame.Piece = (function(position, dimensions, url, rotation) {
-  this.dimensions = dimensions;
-  this.position = position;
-  this.position.y += this.dimensions.y / 2.0;
+    this.dimensions = dimensions;
+    this.position = position;
+    this.position.y += this.dimensions.y / 2.0;
   
-  this.entityProperties = {
-    type: "Model",
-    position: this.position,
-    rotation: rotation,
-    dimensions: this.dimensions,
-    modelURL: url,
-    /**/
-    script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js",
-    /*/
-    script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js",
-    /**/
-    userData: this.buildUserDataString()
-  }
-  this.entity = null;
+    this.entityProperties = {
+        type: "Model",
+        position: this.position,
+        rotation: rotation,
+        dimensions: this.dimensions,
+        modelURL: url,
+        /**/
+        script: "https://s3.amazonaws.com/hifi-public/scripts/entityScripts/chessPiece.js",
+        /*/
+        script: "file:/Users/clement/hifi/examples/entityScripts/chessPiece.js",
+        /**/
+        userData: this.buildUserDataString()
+    }
+    this.entity = null;
 });
 // Build the user data string
 ChessGame.Piece.prototype.buildUserDataString = function() {
-  if (!(ChessGame.board !== null || ChessGame.board.entity.isKnownID)) {
-    print("ChessGame.Piece.prototype.buildUserDataString(): Called before proper initialization, bailing.");
-    return null;
-  }
-  var userDataObject = {
-    boardID: ChessGame.board.entity,
-  };
-  return JSON.stringify(userDataObject);
+    if (!(ChessGame.board !== null || ChessGame.board.entity.isKnownID)) {
+        print("ChessGame.Piece.prototype.buildUserDataString(): Called before proper initialization, bailing.");
+        return null;
+    }
+    var userDataObject = {
+        boardID: ChessGame.board.entity,
+    };
+    return JSON.stringify(userDataObject);
 }
 // Spawns the piece
 ChessGame.Piece.prototype.spawn = function() {
-  this.entity = Entities.addEntity(this.entityProperties);
+    this.entity = Entities.addEntity(this.entityProperties);
 }
 // Cleans up the piece
 ChessGame.Piece.prototype.cleanup = function() {
-  Entities.deleteEntity(this.entity);
+    Entities.deleteEntity(this.entity);
 }
 ChessGame.makePiece = function(piece, i, j, isWhite) {
-  var info = ChessGame.getPieceInfo(piece, isWhite);
-  var url = info.modelURL; 
-  var size = Vec3.multiply(0.5 * (1.0 / ChessGame.BOARD.dimensions.x), info.dimensions);
-  var rotation = (isWhite) ? info.rotation
-                           : Quat.multiply(Quat.fromPitchYawRollDegrees(0, 180, 0),
-                                           info.rotation);
-  var position = ChessGame.board.tilePosition(i, j);
+    var info = ChessGame.getPieceInfo(piece, isWhite);
+    var url = info.modelURL; 
+    var size = Vec3.multiply(0.5 * (1.0 / ChessGame.BOARD.dimensions.x), info.dimensions);
+    var rotation = (isWhite) ? info.rotation
+    : Quat.multiply(Quat.fromPitchYawRollDegrees(0, 180, 0),
+    info.rotation);
+    var position = ChessGame.board.tilePosition(i, j);
                 
-  var piece = new ChessGame.Piece(position, size, url, rotation);
-  piece.spawn();
-  ChessGame.pieces.push(piece);
-  return piece;
+    var piece = new ChessGame.Piece(position, size, url, rotation);
+    piece.spawn();
+    ChessGame.pieces.push(piece);
+    return piece;
 }
 
 ChessGame.scriptStarting = function() {
-  print("playChess.js started");
-  gamePosition = Vec3.sum(MyAvatar.position,
-                          Vec3.multiplyQbyV(MyAvatar.orientation,
-                                            { x: 0, y: 0, z: -1 }));
-  // Setup board
-  ChessGame.board = new ChessGame.Board(gamePosition, gameSize);
-  ChessGame.board.spawn();
+    print("playChess.js started");
+    gamePosition = Vec3.sum(MyAvatar.position,
+        Vec3.multiplyQbyV(MyAvatar.orientation,
+                          { x: 0, y: 0, z: -1 }));
+    // Setup board
+    ChessGame.board = new ChessGame.Board(gamePosition, gameSize);
+    ChessGame.board.spawn();
 }
 
 ChessGame.update = function() {
-  ChessGame.board.entity = Entities.identifyEntity(ChessGame.board.entity);
+    ChessGame.board.entity = Entities.identifyEntity(ChessGame.board.entity);
   
-  if (ChessGame.board.entity.isKnownID && ChessGame.pieces.length == 0) {
-    // Setup white pieces
-    var isWhite = true;
-    var row = 1;
-    // King
-    ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
-    // Queen
-    ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
-    // Bishop
-    ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
-    ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
-    // Knight
-    ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
-    ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
-    // Rook
-    ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
-    ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
-    for(var j = 1; j <= 8; j++) {
-      ChessGame.makePiece(ChessGame.PAWN, row + 1, j, isWhite);
+    if (ChessGame.board.entity.isKnownID && ChessGame.pieces.length == 0) {
+        // Setup white pieces
+        var isWhite = true;
+        var row = 1;
+        // King
+        ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
+        // Queen
+        ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
+        // Bishop
+        ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
+        ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
+        // Knight
+        ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
+        ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
+        // Rook
+        ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
+        ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
+        for(var j = 1; j <= 8; j++) {
+            ChessGame.makePiece(ChessGame.PAWN, row + 1, j, isWhite);
+        }
+  
+        // Setup black pieces
+        isWhite = false;
+        row = 8;
+        // King
+        ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
+        // Queen
+        ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
+        // Bishop
+        ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
+        ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
+        // Knight
+        ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
+        ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
+        // Rook
+        ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
+        ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
+        for(var j = 1; j <= 8; j++) {
+            ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
+        }
     }
   
-    // Setup black pieces
-    isWhite = false;
-    row = 8;
-    // King
-    ChessGame.makePiece(ChessGame.KING, row, 5, isWhite);
-    // Queen
-    ChessGame.makePiece(ChessGame.QUEEN, row, 4, isWhite);
-    // Bishop
-    ChessGame.makePiece(ChessGame.BISHOP, row, 3, isWhite);
-    ChessGame.makePiece(ChessGame.BISHOP, row, 6, isWhite);
-    // Knight
-    ChessGame.makePiece(ChessGame.KNIGHT, row, 2, isWhite);
-    ChessGame.makePiece(ChessGame.KNIGHT, row, 7, isWhite);
-    // Rook
-    ChessGame.makePiece(ChessGame.ROOK, row, 1, isWhite);
-    ChessGame.makePiece(ChessGame.ROOK, row, 8, isWhite);
-    for(var j = 1; j <= 8; j++) {
-      ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
-    }
-  }
-  
-  if (ChessGame.pieces.length > 0) {
-    var unknown = 0;
-    ChessGame.board.userDataObject.pieces = new Array();
-    for(var i = 0; i < ChessGame.pieces.length; i++) {
-      ChessGame.pieces[i].entity = Entities.identifyEntity(ChessGame.pieces[i].entity);
-      if (ChessGame.pieces[i].entity.isKnownID) {
-        ChessGame.board.userDataObject.pieces.push(ChessGame.pieces[i].entity)
-      } else {
-        unknown++;
-      }
-    }
-    ChessGame.board.updateUserData();
+    if (ChessGame.pieces.length > 0) {
+        var unknown = 0;
+        ChessGame.board.userDataObject.pieces = new Array();
+        for(var i = 0; i < ChessGame.pieces.length; i++) {
+            ChessGame.pieces[i].entity = Entities.identifyEntity(ChessGame.pieces[i].entity);
+            if (ChessGame.pieces[i].entity.isKnownID) {
+                ChessGame.board.userDataObject.pieces.push(ChessGame.pieces[i].entity)
+            } else {
+                unknown++;
+            }
+        }
+        ChessGame.board.updateUserData();
     
-    if (unknown === 0) {
-      print("Board complete");
-      Script.update.disconnect(ChessGame.update);      
+        if (unknown === 0) {
+            print("Board complete");
+            Script.update.disconnect(ChessGame.update);      
+        }
     }
-  }
 }
 
 ChessGame.scriptEnding = function() {
-  // Cleaning up board
-  ChessGame.board.cleanup();
+    // Cleaning up board
+    ChessGame.board.cleanup();
   
-  // Cleaning up pieces
-  for(var i in ChessGame.pieces) {
-    ChessGame.pieces[i].cleanup();
-  }
+    // Cleaning up pieces
+    for(var i in ChessGame.pieces) {
+        ChessGame.pieces[i].cleanup();
+    }
   
-  print("playChess.js finished");
+    print("playChess.js finished");
 }
 
 Script.scriptEnding.connect(ChessGame.scriptEnding);

From b1d29cf888745c847e3332b938936464405404f7 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 17:27:33 -0800
Subject: [PATCH 37/38] user data cleanup

---
 examples/entityScripts/chessPiece.js | 16 +++++-----------
 examples/playChess.js                | 23 ++---------------------
 2 files changed, 7 insertions(+), 32 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index ebe2df7e55..f3e2c2aef3 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -1,8 +1,6 @@
 (function(){
     this.FIRST_TILE = null; // Global position of the first tile (1a)
     this.TILE_SIZE = null; // Size of one tile
-    this.whitesDeadPieces = null;
-    this.blacksDeadPieces = null;
   
     this.wantDebug = false;
     this.active = false;
@@ -59,16 +57,11 @@
       
             if (!(this.boardUserData &&
                 this.boardUserData.firstTile &&
-                this.boardUserData.tileSize &&
-                this.boardUserData.whitesDeadPieces &&
-                this.boardUserData.blacksDeadPieces &&
-                this.boardUserData.pieces)) {
+                this.boardUserData.tileSize)) {
                 print("Incomplete boardUserData " + this.boardID.id);
             } else {
                 this.FIRST_TILE = this.boardUserData.firstTile;
                 this.TILE_SIZE = this.boardUserData.tileSize;
-                this.whitesDeadPieces = this.boardUserData.whitesDeadPieces;
-                this.blacksDeadPieces = this.boardUserData.blacksDeadPieces;
         
                 this.active = true;
             }
@@ -139,9 +132,10 @@
     }
     this.moveDeadPiece = function() {
         var myPos = this.getIndexPosition(this.properties.position);
-     
-        for (var i = 0; i < this.boardUserData.pieces.length; i++) {
-            var piece = this.boardUserData.pieces[i];
+        var others = Entities.findEntities(this.properties.position, this.properties.dimensions.y);
+        
+        for (var i = 0; i < others.length; i++) {
+            var piece = others[i];
   
             if (piece.id != this.entityID.id) {
                 var properties = Entities.getEntityProperties(piece);
diff --git a/examples/playChess.js b/examples/playChess.js
index 1b6882ed6e..57ed24f342 100644
--- a/examples/playChess.js
+++ b/examples/playChess.js
@@ -79,8 +79,7 @@ ChessGame.Board = (function(position, scale) {
         firstTile: this.tilePosition(1, 1),
         tileSize: this.tileSize,
         whitesDeadPieces: this.tilePosition(0,0),
-        blacksDeadPieces: this.tilePosition(9,9),
-        pieces: new Array()
+        blacksDeadPieces: this.tilePosition(9,9)
     }
     this.entityProperties = {
         type: "Model",
@@ -242,25 +241,7 @@ ChessGame.update = function() {
         for(var j = 1; j <= 8; j++) {
             ChessGame.makePiece(ChessGame.PAWN, row - 1, j, isWhite);
         }
-    }
-  
-    if (ChessGame.pieces.length > 0) {
-        var unknown = 0;
-        ChessGame.board.userDataObject.pieces = new Array();
-        for(var i = 0; i < ChessGame.pieces.length; i++) {
-            ChessGame.pieces[i].entity = Entities.identifyEntity(ChessGame.pieces[i].entity);
-            if (ChessGame.pieces[i].entity.isKnownID) {
-                ChessGame.board.userDataObject.pieces.push(ChessGame.pieces[i].entity)
-            } else {
-                unknown++;
-            }
-        }
-        ChessGame.board.updateUserData();
-    
-        if (unknown === 0) {
-            print("Board complete");
-            Script.update.disconnect(ChessGame.update);      
-        }
+        Script.update.disconnect(ChessGame.update);
     }
 }
 

From 4d7c5f2d4f2aca58f66e29576a5ebe6df5e20cc0 Mon Sep 17 00:00:00 2001
From: Atlante45 <clement.brisset@gmail.com>
Date: Fri, 14 Nov 2014 17:35:20 -0800
Subject: [PATCH 38/38] Protect board from pieces

---
 examples/entityScripts/chessPiece.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index f3e2c2aef3..4d3fc5cc3d 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -147,9 +147,9 @@
                 (properties.modelURL.search("Knight") !== -1) ?  1 :
                 (properties.modelURL.search("Bishop") !== -1) ?  0 :
                 (properties.modelURL.search("Pawn") !== -1) ?  -1 : -2;
-        
+                
                 var piecePos = this.getIndexPosition(properties.position);
-                if (myPos.i === piecePos.i && myPos.j === piecePos.j) {
+                if (myPos.i === piecePos.i && myPos.j === piecePos.j && type !== -2) {
                     var position = this.getAbsolutePosition((isWhite) ? { i: type, j: -1 } : { i: 7 - type, j: 8 },
                     properties.dimensions.y / 2.0);
                     Entities.editEntity(piece, {