diff --git a/VERSION b/VERSION
index e1df5de7..03e5161d 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.4.4
\ No newline at end of file
+1.4.5
\ No newline at end of file
diff --git a/acp/package.json b/acp/package.json
index da7908ae..2d6bcc99 100644
--- a/acp/package.json
+++ b/acp/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mnml-client",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "",
   "main": "index.js",
   "scripts": {
diff --git a/client/assets/styles/controls.less b/client/assets/styles/controls.less
index eebcc6c6..58bc0b9f 100644
--- a/client/assets/styles/controls.less
+++ b/client/assets/styles/controls.less
@@ -53,7 +53,7 @@ aside {
             border-color: forestgreen;
         }
 
-        &:active, &:focus {
+        &:active, &:focus, &.enabled {
             background: forestgreen;
             color: black;
             border-color: forestgreen;
diff --git a/client/assets/styles/styles.less b/client/assets/styles/styles.less
index 66bdb2cd..83ab40d9 100644
--- a/client/assets/styles/styles.less
+++ b/client/assets/styles/styles.less
@@ -286,3 +286,9 @@ li {
     background-repeat: no-repeat;
     background-position: center;
 }
+
+#clipboard {
+  width: 1px;
+  height: 1px;
+  padding: 0px;
+}
\ No newline at end of file
diff --git a/client/package.json b/client/package.json
index 2897558c..f03cab0e 100644
--- a/client/package.json
+++ b/client/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mnml-client",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -29,6 +29,7 @@
     "preact-compat": "^3.19.0",
     "preact-context": "^1.1.3",
     "preact-redux": "^2.1.0",
+    "query-string": "^6.8.3",
     "react-string-replace": "^0.4.4",
     "react-stripe-elements": "^3.0.0",
     "redux": "^4.0.0"
diff --git a/client/src/actions.jsx b/client/src/actions.jsx
index d4fe0dc8..ccfadcaa 100644
--- a/client/src/actions.jsx
+++ b/client/src/actions.jsx
@@ -19,6 +19,7 @@ export const setConstructRename = value => ({ type: 'SET_CONSTRUCT_RENAME', valu
 export const setGame = value => ({ type: 'SET_GAME', value });
 export const setInfo = value => ({ type: 'SET_INFO', value });
 export const setEmail = value => ({ type: 'SET_EMAIL', value });
+export const setInvite = value => ({ type: 'SET_INVITE', value });
 export const setInstance = value => ({ type: 'SET_INSTANCE', value });
 export const setInstances = value => ({ type: 'SET_INSTANCES', value });
 export const setItemEquip = value => ({ type: 'SET_ITEM_EQUIP', value });
diff --git a/client/src/components/anims/banish.jsx b/client/src/components/anims/banish.jsx
index 62d3096a..12ae365a 100644
--- a/client/src/components/anims/banish.jsx
+++ b/client/src/components/anims/banish.jsx
@@ -2,7 +2,7 @@ const anime = require('animejs').default;
 
 const { TIMES } = require('../../constants');
 
-function Banish(id) {
+function Banish(id, idle) {
     return anime({
         targets: [document.getElementById(id)],
         scaleY: 0,
@@ -11,6 +11,8 @@ function Banish(id) {
         delay: TIMES.TARGET_DELAY_MS,
         duration: TIMES.TARGET_DURATION_MS * 0.45,
         direction: 'alternate',
+        begin: idle.pause,
+        complete: idle.play,
     });
 }
 
diff --git a/client/src/components/anims/invert.jsx b/client/src/components/anims/invert.jsx
index 57a787d8..ac083bea 100644
--- a/client/src/components/anims/invert.jsx
+++ b/client/src/components/anims/invert.jsx
@@ -2,7 +2,7 @@ const anime = require('animejs').default;
 
 const { TIMES } = require('../../constants');
 
-function Invert(id) {
+function Invert(id, idle) {
     return anime({
         targets: [document.getElementById(id)],
         rotate: 180,
@@ -10,6 +10,8 @@ function Invert(id) {
         duration: TIMES.TARGET_DURATION_MS * 0.45,
         easing: 'easeInOutElastic',
         direction: 'alternate',
+        begin: idle.pause,
+        complete: idle.play,
     });
 }
 
diff --git a/client/src/components/anims/source.cast.jsx b/client/src/components/anims/source.cast.jsx
index 25cb8ae8..74a17184 100644
--- a/client/src/components/anims/source.cast.jsx
+++ b/client/src/components/anims/source.cast.jsx
@@ -2,15 +2,17 @@ const anime = require('animejs').default;
 
 const { TIMES } = require('../../constants');
 
-function sourceCast(id, direction) {
+function sourceCast(id, direction, idle) {
     const { x, y } = direction;
     return anime({
         targets: [document.getElementById(id)],
-        translateX: [0, x * 200],
-        translateY: [0, y * 200],
+        translateX: x * window.screen.width * 0.15,
+        translateY: y * window.screen.height * 0.15,
         easing: 'easeInOutElastic',
         direction: 'alternate',
         duration: TIMES.SOURCE_DURATION_MS,
+        begin: idle.pause,
+        complete: idle.play,
     });
 }
 
diff --git a/client/src/components/construct.jsx b/client/src/components/construct.jsx
index 17e97349..964da49c 100644
--- a/client/src/components/construct.jsx
+++ b/client/src/components/construct.jsx
@@ -37,73 +37,8 @@ class ConstructAvatar extends Component {
     }
 
     componentDidMount() {
-        const { animSource, animTarget, construct } = this.props;
-
-        // back to idle
-        if (!animTarget && !animSource) {
-            if (!this.idle) {
-                this.idle = idleAnimation(this.props.construct.id);
-                return this.animations.push(this.idle);
-            }
-
-            return this.idle.play();
-        }
-
-        const isSource = animSource && animSource.constructId === construct.id;
-
-        const selectAnim = () => {
-            if (isSource) {
-                console.warn(construct.name, animSource);
-                return sourceCast(animSource.constructId, animSource.direction);
-            }
-
-            switch (animTarget.skill) {
-            case 'banish': return banish(construct.id);
-            case 'invert': return invert(construct.id);
-            default: return null;
-            }
-        };
-
-        const anim = selectAnim();
-        if (!anim) return false;
-
-        this.idle.pause();
-        this.animations.push(anim);
-        return true;
-    }
-
-    componentDidUpdate(prevProps) {
-        const { animSource, animTarget, construct } = this.props;
-
-        // back to idle
-        if (!animTarget && !animSource) {
-            if (!this.idle) {
-                this.idle = idleAnimation(this.props.construct.id);
-                return this.animations.push(this.idle);
-            }
-            return this.idle.play();
-        }
-
-        const isSource = animSource && animSource.constructId === construct.id;
-
-        const selectAnim = () => {
-            if (isSource) {
-                return sourceCast(animSource.constructId, animSource.direction);
-            }
-
-            switch (animTarget.skill) {
-            case 'Banish': return banish(construct.id);
-            case 'Invert': return invert(construct.id);
-            default: return null;
-            }
-        };
-
-        const anim = selectAnim();
-        if (!anim) return false;
-
-        this.idle.pause();
-        this.animations.push(anim);
-        return true;
+        this.idle = idleAnimation(this.props.construct.id);
+        return this.animations.push(this.idle);
     }
 
     resetAnimations() {
@@ -132,24 +67,19 @@ class ConstructAvatar extends Component {
         // this is the source
         if (animSource && animSource.constructId === construct.id) {
             // console.warn(construct.name, 'should update')
-            return true;
+            return sourceCast(animSource.constructId, animSource.direction, this.idle);
         }
 
         // this is the target
         if (animTarget && animTarget.constructId.includes(construct.id)) {
             // console.warn(construct.name, 'should update')
-            return true;
+            switch (animTarget.skill) {
+            case 'Banish': return banish(construct.id, this.idle);
+            case 'Invert': return invert(construct.id, this.idle);
+            default: return null;
+            }
         }
 
-        // we were previously doing src anim
-        const prevSrc = this.props.animSource && this.props.animSource.constructId === construct.id;
-        if (prevSrc && !animSource) return true;
-
-        const prevTarget = this.props.animTarget && this.props.animTarget.constructId.includes(construct.id);
-        if (prevTarget && !animTarget) return true;
-
-        // console.warn(construct.name, 'not updating');
-
         return false;
     }
 }
diff --git a/client/src/components/instance.ctrl.jsx b/client/src/components/instance.ctrl.jsx
index faa38afb..329eea45 100644
--- a/client/src/components/instance.ctrl.jsx
+++ b/client/src/components/instance.ctrl.jsx
@@ -76,11 +76,13 @@ function Controls(args) {
         background: displayColour,
     };
 
-    const timer = (
-        <div class="timer-container">
-            <div class="timer" style={timerStyles} >&nbsp;</div>
-        </div>
-    );
+    const timer = instance.phase !== 'InProgress'
+        ? null
+        : (
+            <div class="timer-container">
+                <div class="timer" style={timerStyles} >&nbsp;</div>
+            </div>
+        );
 
     const ready = instance.phase !== 'Finished'
         ? <button class="ready" onClick={() => sendReady()}>Ready</button>
diff --git a/client/src/components/play.ctrl.jsx b/client/src/components/play.ctrl.jsx
index e87e01e5..0df4f4d0 100644
--- a/client/src/components/play.ctrl.jsx
+++ b/client/src/components/play.ctrl.jsx
@@ -1,11 +1,14 @@
 const preact = require('preact');
 const { connect } = require('preact-redux');
 
+const { errorToast, infoToast } = require('../utils');
+
 const addState = connect(
     function receiveState(state) {
         const {
             ws,
             instances,
+            invite,
         } = state;
 
         function sendInstanceState(id) {
@@ -20,12 +23,18 @@ const addState = connect(
             ws.sendInstanceQueue();
         }
 
+        function sendInstanceInvite() {
+            ws.sendInstanceInvite();
+        }
+
         return {
             instances,
+            invite,
 
             sendInstanceState,
             sendInstanceQueue,
             sendInstancePractice,
+            sendInstanceInvite,
         };
     }
 );
@@ -33,10 +42,12 @@ const addState = connect(
 function JoinButtons(args) {
     const {
         instances,
+        invite,
 
         sendInstanceState,
         sendInstanceQueue,
         sendInstancePractice,
+        sendInstanceInvite,
     } = args;
 
     if (instances.length) {
@@ -55,6 +66,48 @@ function JoinButtons(args) {
         );
     }
 
+    const inviteBtn = () => {
+        if (!invite) {
+            return (
+                <button
+                    class='pvp ready'
+                    onClick={() => sendInstanceInvite()}
+                    type="submit">
+                    Invite
+                </button>
+            );
+        }
+
+        function copyClick(e) {
+            const link = `${document.location.origin}#join=${invite}`;
+            const textArea = document.createElement('textarea', { id: '#clipboard' });
+            textArea.value = link;
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+
+            try {
+                document.execCommand('copy');
+                infoToast('Invite link copied.');
+            } catch (err) {
+                console.error('link copy error', err);
+                errorToast('Invite link copy error.');
+            }
+
+            document.body.removeChild(textArea);
+            return true;
+        }
+
+        return (
+            <button
+                class='pvp ready enabled'
+                onClick={copyClick}
+                type="submit">
+                Copy Link
+            </button>
+        );
+    };
+
     return (
         <aside class='play-ctrl'>
             <div class="timer-container"></div>
@@ -65,6 +118,7 @@ function JoinButtons(args) {
                     type="submit">
                     PVP
                 </button>
+                {inviteBtn()}
                 <button
                     class='practice ready'
                     onClick={() => sendInstancePractice()}
diff --git a/client/src/events.jsx b/client/src/events.jsx
index 242e2888..79b6eed6 100644
--- a/client/src/events.jsx
+++ b/client/src/events.jsx
@@ -1,3 +1,5 @@
+const querystring = require('query-string');
+
 const eachSeries = require('async/eachSeries');
 const sample = require('lodash/sample');
 
@@ -168,9 +170,20 @@ function registerEvents(store) {
         return store.dispatch(actions.setInstances(v));
     }
 
+    function setInvite(code) {
+        if (!code) return store.dispatch(actions.setInvite(null));
+
+        navigator.clipboard.writeText(code).then(() => {
+            notify(`your invite code ${code} was copied to the clipboard.`);
+        }, () => {});
+
+        return store.dispatch(actions.setInvite(code));
+    }
+
     function setInstance(v) {
         const { account, instance, ws } = store.getState();
         if (v) {
+            setInvite(null);
             const player = v.players.find(p => p.id === account.id);
             store.dispatch(actions.setPlayer(player));
 
@@ -272,6 +285,16 @@ function registerEvents(store) {
     } */
     // setup / localstorage
 
+    function urlHashChange() {
+        const { ws } = store.getState();
+        const cmds = querystring.parse(location.hash);
+
+        if (cmds.join) ws.sendInstanceJoin(cmds.join);
+        return true;
+    }
+
+    window.addEventListener('hashchange', urlHashChange, false);
+
     return {
         clearCombiner,
         clearConstructRename,
@@ -289,12 +312,15 @@ function registerEvents(store) {
         setEmail,
         setInstance,
         setItemInfo,
+        setInvite,
         setPing,
         setShop,
         setTeam,
         setSubscription,
         setWs,
 
+        urlHashChange,
+
         notify,
     };
 }
diff --git a/client/src/reducers.jsx b/client/src/reducers.jsx
index cfc6dad5..349d6e91 100644
--- a/client/src/reducers.jsx
+++ b/client/src/reducers.jsx
@@ -31,6 +31,7 @@ module.exports = {
     constructRename:    createReducer(null, 'SET_CONSTRUCT_RENAME'),
     game:               createReducer(null, 'SET_GAME'),
     email:              createReducer(null, 'SET_EMAIL'),
+    invite:             createReducer(null, 'SET_INVITE'),
     info:               createReducer(null, 'SET_INFO'),
     instance:           createReducer(null, 'SET_INSTANCE'),
     instances:          createReducer([], 'SET_INSTANCES'),
diff --git a/client/src/socket.jsx b/client/src/socket.jsx
index 74140922..1c6f6f37 100644
--- a/client/src/socket.jsx
+++ b/client/src/socket.jsx
@@ -126,6 +126,14 @@ function createSocket(events) {
         send(['InstanceQueue', {}]);
     }
 
+    function sendInstanceInvite() {
+        send(['InstanceInvite', {}]);
+    }
+
+    function sendInstanceJoin(code) {
+        send(['InstanceJoin', { code }]);
+    }
+
     function sendInstanceReady(instanceId) {
         send(['InstanceReady', { instance_id: instanceId }]);
     }
@@ -239,6 +247,9 @@ function createSocket(events) {
 
         QueueRequested: () => events.notify('pvp queue request received'),
         QueueJoined: () => events.notify('you have joined the pvp queue'),
+        InviteRequested: () => events.notify('pvp queue request received'),
+        Invite: code => events.setInvite(code),
+        Joining: () => events.notify('searching for instance...'),
 
         Error: errHandler,
     };
@@ -284,6 +295,8 @@ function createSocket(events) {
         sendPing();
         sendItemInfo();
 
+        events.urlHashChange();
+
         return true;
     }
 
@@ -318,6 +331,7 @@ function createSocket(events) {
         ws.addEventListener('message', onMessage);
         ws.addEventListener('error', onError);
         ws.addEventListener('close', onClose);
+
         return ws;
     }
 
@@ -338,6 +352,8 @@ function createSocket(events) {
         sendInstancePractice,
         sendInstanceQueue,
         sendInstanceState,
+        sendInstanceInvite,
+        sendInstanceJoin,
 
         sendVboxAccept,
         sendVboxApply,
diff --git a/ops/package.json b/ops/package.json
index 642d45e1..5314c598 100755
--- a/ops/package.json
+++ b/ops/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mnml-ops",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "",
   "main": "index.js",
   "scripts": {
diff --git a/server/Cargo.toml b/server/Cargo.toml
index 67096284..d3970fb5 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mnml"
-version = "1.4.4"
+version = "1.4.5"
 authors = ["ntr <ntr@smokestack.io>"]
 
 [dependencies]
diff --git a/server/src/events.rs b/server/src/events.rs
index da9fe692..ad3d898f 100644
--- a/server/src/events.rs
+++ b/server/src/events.rs
@@ -12,6 +12,7 @@ use account;
 use account::Account;
 use game;
 use instance;
+use names;
 
 use pg::{Db, PgPool};
 use rpc::RpcMessage;
@@ -54,6 +55,9 @@ pub enum Event {
 
     // client events
     Queue(Id),
+    Invite(Id),
+    Join(Id, String),
+    Joined(Id),
 }
 
 struct WsClient {
@@ -62,6 +66,7 @@ struct WsClient {
     tx: Sender<RpcMessage>,
     subs: HashSet<Uuid>,
     pvp: bool,
+    invite: Option<String>,
 }
 
 impl Events {
@@ -115,7 +120,7 @@ impl Events {
                     None => None,
                 };
 
-                let client = WsClient { id, tx, account: account_id, subs: HashSet::new(), pvp: false };
+                let client = WsClient { id, tx, account: account_id, subs: HashSet::new(), pvp: false, invite: None };
                 self.clients.insert(id, client);
 
                 info!("clients={:?}", self.clients.len());
@@ -223,6 +228,59 @@ impl Events {
                 info!("joined game queue id={:?} account={:?}", requester.id, requester.account);
                 return Ok(());
             },
+
+            Event::Invite(id) => {
+                // check whether request is valid
+                let c = self.clients.get_mut(&id)
+                    .ok_or(format_err!("connection not found id={:?}", id))?;
+
+                if let None = c.account {
+                    return Err(err_msg("cannot join pvp queue anonymously"));
+                }
+
+                let code = names::name().split_whitespace().collect::<Vec<&str>>().join("-");
+                info!("pvp invite request id={:?} account={:?} code={:?}", c.id, c.account, code);
+                c.invite = Some(code.clone());
+                c.tx.send(RpcMessage::Invite(code))?;
+                return Ok(());
+            },
+
+            Event::Join(id, code) => {
+                // check whether request is valid
+                let c = self.clients.get(&id)
+                    .ok_or(format_err!("connection not found id={:?}", id))?;
+
+                if let None = c.account {
+                    return Err(err_msg("cannot join pvp queue anonymously"));
+                }
+
+                info!("pvp join request id={:?} account={:?} code={:?}", c.id, c.account, code);
+
+                let inv = self.clients.iter()
+                    .filter(|(_id, c)| c.invite.is_some())
+                    .find(|(_id, c)| match c.invite {
+                        Some(ref c) => *c == code,
+                        None => false,
+                    })
+                    .map(|(_id, c)| PvpRequest { id: c.id, account: c.account.unwrap(), tx: c.tx.clone() })
+                    .ok_or(format_err!("invite not found code={:?}", code))?;
+
+                let join = PvpRequest { id: c.id, account: c.account.unwrap(), tx: c.tx.clone() };
+
+                self.warden.send(GameEvent::Match((join, inv)))?;
+                return Ok(());
+            },
+
+            Event::Joined(id) => {
+                // check whether request is valid
+                let c = self.clients.get_mut(&id)
+                    .ok_or(format_err!("connection not found id={:?}", id))?;
+
+                c.pvp = false;
+                c.invite = None;
+                return Ok(());
+            },
+
         }
     }
 }
diff --git a/server/src/img.rs b/server/src/img.rs
index e3584c20..3fc746b3 100644
--- a/server/src/img.rs
+++ b/server/src/img.rs
@@ -117,7 +117,7 @@ pub fn shapes_write(id: Uuid) -> Result<Uuid, Error> {
         (ConstructShapes::Circle,    10),
         (ConstructShapes::Line,      10),
         (ConstructShapes::V,         10),
-        // (ConstructShapes::Tri,       3),
+        (ConstructShapes::Tri,       10),
         // (ConstructShapes::Plus,      5),
         (ConstructShapes::Blank,     1),
     ];
@@ -155,6 +155,9 @@ pub fn shapes_write(id: Uuid) -> Result<Uuid, Error> {
                 let size = rng.gen_range(20.0, 50.0);
                 write!(&mut svg, "<rect fill=\"{fill}\" x=\"-{x}\" y=\"-{y}\" width=\"{width}\" height=\"{height}\" transform=\"translate({x_t}, {y_t}) rotate({rotation})\" />",
                     fill = colour, x = size / 2.0, y = size / 2.0, width = size, height = size, x_t = x_translate, y_t = y_translate, rotation = rotation)?;
+                if scalar == 0.0 && rng.gen_bool(0.5) {
+                    continue;
+                }
                 write!(&mut svg, "<rect fill=\"{fill}\" x=\"-{x}\" y=\"-{y}\" width=\"{width}\" height=\"{height}\" transform=\"translate({x_t}, {y_t}) rotate({rotation})\" />",
                     fill = colour, x = size / 2.0, y = size / 2.0, width = size, height = size, x_t = -x_translate, y_t = -y_translate, rotation = rotation)?;
             },
@@ -163,6 +166,9 @@ pub fn shapes_write(id: Uuid) -> Result<Uuid, Error> {
                 let b = rng.gen_range(20.0, 50.0);
                 write!(&mut svg, "<polygon fill=\"{fill}\" x=\"{x}\" y=\"{y}\" points=\"{x0} {y0}, {x1} {y1}, {x2} {y2}\" transform=\"translate({x_translate}, {y_translate}) rotate({rotation})\" />",
                     fill = colour, x = -b / 2.0, y = h / 2.0, x0 = -b / 2.0, y0 = -h / 2.0, x1 = 0, y1 = b / 2.0, x2 = b / 2.0, y2 = -h / 2.0, rotation = rotation, x_translate = x_translate, y_translate = y_translate)?;
+                if scalar == 0.0 && rng.gen_bool(0.5) {
+                    continue;
+                }
                 write!(&mut svg, "<polygon fill=\"{fill}\" x=\"{x}\" y=\"{y}\" points=\"{x0} {y0}, {x1} {y1}, {x2} {y2}\" transform=\"translate({x_translate}, {y_translate}) rotate({rotation})\" />",
                     fill = colour, x = -b / 2.0, y = h / 2.0, x0 = -b / 2.0, y0 = -h / 2.0, x1 = 0, y1 = b / 2.0, x2 = b / 2.0, y2 = -h / 2.0, rotation = rotation + 180, x_translate = -x_translate, y_translate = -y_translate)?;
             },
@@ -178,6 +184,9 @@ pub fn shapes_write(id: Uuid) -> Result<Uuid, Error> {
                 let height = rng.gen_range(20.0, 50.0);
                 write!(&mut svg, "<rect fill=\"{fill}\" x=\"-{x}\" y=\"-{y}\" width=\"{width}\" height=\"{height}\" transform=\"translate({x_t}, {y_t}) rotate({rotation})\" />",
                     fill = colour, x = width / 2.0, y = height / 2.0, width = width, height = height, x_t = x_translate, y_t = y_translate, rotation = rotation)?;
+                if scalar == 0.0 && rng.gen_bool(0.5) {
+                    continue;
+                }
                 write!(&mut svg, "<rect fill=\"{fill}\" x=\"-{x}\" y=\"-{y}\" width=\"{width}\" height=\"{height}\" transform=\"translate({x_t}, {y_t}) rotate({rotation})\" />",
                     fill = colour, x = width / 2.0, y = height / 2.0, width = width, height = height, x_t = -x_translate, y_t = -y_translate, rotation = rotation)?;
             },
@@ -188,11 +197,30 @@ pub fn shapes_write(id: Uuid) -> Result<Uuid, Error> {
 
                 write!(&mut svg, "<polyline fill=\"none\" stroke=\"{fill}\" stroke-width=\"{width}\" x=\"{x}\" y=\"{y}\" points=\"{x0} {y0}, {x1} {y1}, {x2} {y2}\" transform=\"translate({x_translate}, {y_translate}) rotate({rotation})\" />",
                     fill = colour, width = width, x = -b / 2.0, y = h / 2.0, x0 = -b / 2.0, y0 = -h / 2.0, x1 = 0, y1 = b / 2.0, x2 = b / 2.0, y2 = -h / 2.0, rotation = rotation, x_translate = x_translate, y_translate = y_translate)?;
+                if scalar == 0.0 && rng.gen_bool(0.5) {
+                    continue;
+                }
                 write!(&mut svg, "<polyline fill=\"none\" stroke=\"{fill}\" stroke-width=\"{width}\" x=\"{x}\" y=\"{y}\" points=\"{x0} {y0}, {x1} {y1}, {x2} {y2}\" transform=\"translate({x_translate}, {y_translate}) rotate({rotation})\" />",
                     fill = colour, width = width, x = -b / 2.0, y = h / 2.0, x0 = -b / 2.0, y0 = -h / 2.0, x1 = 0, y1 = b / 2.0, x2 = b / 2.0, y2 = -h / 2.0, rotation = rotation + 180, x_translate = -x_translate, y_translate = -y_translate)?;
             },
             ConstructShapes::Tri => {
+                let width = rng.gen_range(2.0, 4.0);
+                let length = rng.gen_range(12.5, 25.0);
 
+                let x0 = (0.0 as f64).cos() * length;
+                let y0 = (0.0 as f64).sin() * length;
+                let x1 = ((f64::consts::PI * 2.0) / 3.0).cos() * length;
+                let y1 = ((f64::consts::PI * 2.0) / 3.0).sin() * length;
+                let x2 = ((f64::consts::PI * 4.0) / 3.0).cos() * length;
+                let y2 = ((f64::consts::PI * 4.0) / 3.0).sin() * length;
+
+                write!(&mut svg, "<path stroke=\"{fill}\" stroke-width=\"{width}\" d=\"M{x0} {y0}L 0 0 M{x1} {y1}L 0 0 M{x2} {y2}L 0 0 \" transform=\"translate({x_translate}, {y_translate}) rotate({rotation})\" />",
+                    fill = colour, width = width, x0 = x0, y0 = y0, x1 = x1, y1 = y1, x2 = x2, y2 = y2, rotation = rotation, x_translate = x_translate, y_translate = y_translate)?;
+                if scalar == 0.0 && rng.gen_bool(0.5) {
+                    continue;
+                }
+                write!(&mut svg, "<path stroke=\"{fill}\" stroke-width=\"{width}\" d=\"M{x0} {y0}L 0 0 M{x1} {y1}L 0 0 M{x2} {y2}L 0 0 \" transform=\"translate({x_translate}, {y_translate}) rotate({rotation})\" />",
+                    fill = colour, width = width, x0 = x0, y0 = y0, x1 = x1, y1 = y1, x2 = x2, y2 = y2, rotation = rotation, x_translate = -x_translate, y_translate = -y_translate)?;
             },
             ConstructShapes::Plus => {
 
diff --git a/server/src/rpc.rs b/server/src/rpc.rs
index d3955988..3439a6c4 100644
--- a/server/src/rpc.rs
+++ b/server/src/rpc.rs
@@ -62,6 +62,10 @@ pub enum RpcMessage {
     QueueJoined(()),
     QueueCancelled(()),
 
+    InviteRequested(()),
+    Invite(String),
+    Joining(()),
+
     Error(String),
 }
 
@@ -91,6 +95,8 @@ pub enum RpcRequest {
     SubscriptionState {},
     EmailState {},
 
+    InstanceInvite {},
+    InstanceJoin { code: String },
     InstanceQueue {},
     InstancePractice {},
     InstanceAbandon { instance_id: Uuid },
@@ -136,99 +142,108 @@ impl Connection {
                     None => return Err(err_msg("auth required")),
                 };
 
-                // evented but authorization required
-                match v {
-                    RpcRequest::InstanceQueue {} => {
-                        self.events.send(Event::Queue(self.id))?;
-                        return Ok(RpcMessage::QueueRequested(()));
-                    },
-                    _ => (),
-                };
-
-                // all good, let's make a tx and process
-                let mut tx = db.transaction()?;
-
                 let request = v.clone();
 
                 let response = match v {
-                    RpcRequest::AccountState {} =>
-                        Ok(RpcMessage::AccountState(account.clone())),
-                    RpcRequest::AccountConstructs {} =>
-                        Ok(RpcMessage::AccountConstructs(account::constructs(&mut tx, &account)?)),
-                    RpcRequest::AccountInstances {} =>
-                        Ok(RpcMessage::AccountInstances(account::account_instances(&mut tx, account)?)),
-                    RpcRequest::AccountSetTeam { ids } =>
-                        Ok(RpcMessage::AccountTeam(account::set_team(&mut tx, &account, ids)?)),
+                    // evented but authorization required
+                    RpcRequest::InstanceQueue {} => {
+                        self.events.send(Event::Queue(self.id))?;
+                        Ok(RpcMessage::QueueRequested(()))
+                    },
+                    RpcRequest::InstanceInvite {} => {
+                        self.events.send(Event::Invite(self.id))?;
+                        Ok(RpcMessage::InviteRequested(()))
+                    },
+                    RpcRequest::InstanceJoin { code } => {
+                        self.events.send(Event::Join(self.id, code))?;
+                        Ok(RpcMessage::Joining(()))
+                    },
+                    _ => {
+                        // all good, let's make a tx and process
+                        let mut tx = db.transaction()?;
 
-                    RpcRequest::EmailState {} =>
-                        Ok(RpcMessage::EmailState(mail::select_account(&db, account.id)?)),
+                        let res = match v {
+                            RpcRequest::AccountState {} =>
+                                Ok(RpcMessage::AccountState(account.clone())),
+                            RpcRequest::AccountConstructs {} =>
+                                Ok(RpcMessage::AccountConstructs(account::constructs(&mut tx, &account)?)),
+                            RpcRequest::AccountInstances {} =>
+                                Ok(RpcMessage::AccountInstances(account::account_instances(&mut tx, account)?)),
+                            RpcRequest::AccountSetTeam { ids } =>
+                                Ok(RpcMessage::AccountTeam(account::set_team(&mut tx, &account, ids)?)),
 
-                    RpcRequest::SubscriptionState {} =>
-                        Ok(RpcMessage::SubscriptionState(payments::account_subscription(&db, &self.stripe, &account)?)),
+                            RpcRequest::EmailState {} =>
+                                Ok(RpcMessage::EmailState(mail::select_account(&db, account.id)?)),
 
-                    // RpcRequest::AccountShop {} =>
-                    //     Ok(RpcMessage::AccountShop(mtx::account_shop(&mut tx, &account)?)),
+                            RpcRequest::SubscriptionState {} =>
+                                Ok(RpcMessage::SubscriptionState(payments::account_subscription(&db, &self.stripe, &account)?)),
 
-                    // RpcRequest::ConstructDelete" => handle_construct_delete(data, &mut tx, account),
+                            // RpcRequest::AccountShop {} =>
+                            //     Ok(RpcMessage::AccountShop(mtx::account_shop(&mut tx, &account)?)),
 
-                    RpcRequest::GameState { id } =>
-                        Ok(RpcMessage::GameState(game_state(&mut tx, account, id)?)),
+                            // RpcRequest::ConstructDelete" => handle_construct_delete(data, &mut tx, account),
 
-                    RpcRequest::GameSkill { game_id, construct_id, target_construct_id, skill } =>
-                        Ok(RpcMessage::GameState(game_skill(&mut tx, account, game_id, construct_id, target_construct_id, skill)?)),
+                            RpcRequest::GameState { id } =>
+                                Ok(RpcMessage::GameState(game_state(&mut tx, account, id)?)),
 
-                    RpcRequest::GameSkillClear { game_id } =>
-                        Ok(RpcMessage::GameState(game_skill_clear(&mut tx, account, game_id)?)),
+                            RpcRequest::GameSkill { game_id, construct_id, target_construct_id, skill } =>
+                                Ok(RpcMessage::GameState(game_skill(&mut tx, account, game_id, construct_id, target_construct_id, skill)?)),
 
-                    RpcRequest::GameReady { id } =>
-                        Ok(RpcMessage::GameState(game_ready(&mut tx, account, id)?)),
+                            RpcRequest::GameSkillClear { game_id } =>
+                                Ok(RpcMessage::GameState(game_skill_clear(&mut tx, account, game_id)?)),
 
-                    RpcRequest::InstancePractice {} =>
-                        Ok(RpcMessage::InstanceState(instance_practice(&mut tx, account)?)),
+                            RpcRequest::GameReady { id } =>
+                                Ok(RpcMessage::GameState(game_ready(&mut tx, account, id)?)),
 
-                    // these two can return GameState or InstanceState
-                    RpcRequest::InstanceReady { instance_id } =>
-                        Ok(instance_ready(&mut tx, account, instance_id)?),
-                    RpcRequest::InstanceState { instance_id } =>
-                        Ok(instance_state(&mut tx, instance_id)?),
-                    RpcRequest::InstanceAbandon { instance_id } =>
-                        Ok(instance_abandon(&mut tx, account, instance_id)?),
+                            RpcRequest::InstancePractice {} =>
+                                Ok(RpcMessage::InstanceState(instance_practice(&mut tx, account)?)),
 
-                    RpcRequest::VboxAccept { instance_id, group, index } =>
-                        Ok(RpcMessage::InstanceState(vbox_accept(&mut tx, account, instance_id, group, index)?)),
+                            // these two can return GameState or InstanceState
+                            RpcRequest::InstanceReady { instance_id } =>
+                                Ok(instance_ready(&mut tx, account, instance_id)?),
+                            RpcRequest::InstanceState { instance_id } =>
+                                Ok(instance_state(&mut tx, instance_id)?),
+                            RpcRequest::InstanceAbandon { instance_id } =>
+                                Ok(instance_abandon(&mut tx, account, instance_id)?),
 
-                    RpcRequest::VboxApply { instance_id, construct_id, index } =>
-                        Ok(RpcMessage::InstanceState(vbox_apply(&mut tx, account, instance_id, construct_id, index)?)),
+                            RpcRequest::VboxAccept { instance_id, group, index } =>
+                                Ok(RpcMessage::InstanceState(vbox_accept(&mut tx, account, instance_id, group, index)?)),
 
-                    RpcRequest::VboxCombine { instance_id, indices } =>
-                        Ok(RpcMessage::InstanceState(vbox_combine(&mut tx, account, instance_id, indices)?)),
+                            RpcRequest::VboxApply { instance_id, construct_id, index } =>
+                                Ok(RpcMessage::InstanceState(vbox_apply(&mut tx, account, instance_id, construct_id, index)?)),
 
-                    RpcRequest::VboxDiscard { instance_id } =>
-                        Ok(RpcMessage::InstanceState(vbox_discard(&mut tx, account, instance_id)?)),
+                            RpcRequest::VboxCombine { instance_id, indices } =>
+                                Ok(RpcMessage::InstanceState(vbox_combine(&mut tx, account, instance_id, indices)?)),
 
-                    RpcRequest::VboxReclaim { instance_id, index } =>
-                        Ok(RpcMessage::InstanceState(vbox_reclaim(&mut tx, account, instance_id, index)?)),
+                            RpcRequest::VboxDiscard { instance_id } =>
+                                Ok(RpcMessage::InstanceState(vbox_discard(&mut tx, account, instance_id)?)),
 
-                    RpcRequest::VboxUnequip { instance_id, construct_id, target } =>
-                        Ok(RpcMessage::InstanceState(vbox_unequip(&mut tx, account, instance_id, construct_id, target)?)),
+                            RpcRequest::VboxReclaim { instance_id, index } =>
+                                Ok(RpcMessage::InstanceState(vbox_reclaim(&mut tx, account, instance_id, index)?)),
 
-                    RpcRequest::MtxConstructSpawn {} =>
-                        Ok(RpcMessage::ConstructSpawn(mtx::new_construct(&mut tx, account)?)),
+                            RpcRequest::VboxUnequip { instance_id, construct_id, target } =>
+                                Ok(RpcMessage::InstanceState(vbox_unequip(&mut tx, account, instance_id, construct_id, target)?)),
 
-                    RpcRequest::MtxConstructApply { mtx, construct_id, name } =>
-                        Ok(RpcMessage::AccountTeam(mtx::apply(&mut tx, account, mtx, construct_id, name)?)),
+                            RpcRequest::MtxConstructSpawn {} =>
+                                Ok(RpcMessage::ConstructSpawn(mtx::new_construct(&mut tx, account)?)),
 
-                    RpcRequest::MtxBuy { mtx } =>
-                        Ok(RpcMessage::AccountShop(mtx::buy(&mut tx, account, mtx)?)),
+                            RpcRequest::MtxConstructApply { mtx, construct_id, name } =>
+                                Ok(RpcMessage::AccountTeam(mtx::apply(&mut tx, account, mtx, construct_id, name)?)),
 
-                    RpcRequest::SubscriptionEnding { ending } =>
-                        Ok(RpcMessage::SubscriptionState(payments::subscription_ending(&mut tx, &self.stripe, account, ending)?)),
+                            RpcRequest::MtxBuy { mtx } =>
+                                Ok(RpcMessage::AccountShop(mtx::buy(&mut tx, account, mtx)?)),
 
-                    _ => Err(format_err!("unknown request request={:?}", request)),
+                            RpcRequest::SubscriptionEnding { ending } =>
+                                Ok(RpcMessage::SubscriptionState(payments::subscription_ending(&mut tx, &self.stripe, account, ending)?)),
+
+                            _ => Err(format_err!("unknown request request={:?}", request)),
+                        };
+
+                        tx.commit()?;
+                        res
+                    }
                 };
 
-                tx.commit()?;
-
                 info!("request={:?} account={:?} duration={:?}", request, account.name, begin.elapsed());
 
                 return response;
diff --git a/server/src/warden.rs b/server/src/warden.rs
index 9d58e678..262f6187 100644
--- a/server/src/warden.rs
+++ b/server/src/warden.rs
@@ -90,6 +90,10 @@ impl Warden {
     fn on_match(&mut self, pair: Pair) -> Result<(), Error> {
         info!("received pair={:?}", pair);
 
+        // clear pvp status
+        self.events.send(Event::Joined(pair.0.id))?;
+        self.events.send(Event::Joined(pair.1.id))?;
+
         let db = self.pool.get()?;
         let mut tx = db.transaction()?;