diff --git a/server/src/vbox.rs b/server/src/vbox.rs
index ff67e59a..1f27928b 100644
--- a/server/src/vbox.rs
+++ b/server/src/vbox.rs
@@ -30,11 +30,30 @@ pub enum Var {
     Buff,
     Debuff,
 
-    Strike,
+    Amplify,
+    Banish,
     Blast,
+    Curse,
+    Empower,
+    Haste,
     Heal,
-    Throw,
     Hex,
+    Parry,
+    Purge,
+    Purify,
+    Reflect,
+    Ruin,
+    Shield,
+    Silence,
+    Slay,
+    Slow,
+    Snare,
+    Strangle,
+    Strike,
+    Taunt,
+    Throw,
+    Toxic,
+    Triage,
 }
 
 impl Var {
@@ -51,22 +70,47 @@ impl Var {
 
     fn skill(&self) -> Result<Skill, Error> {
         match self {
-            Var::Attack => Ok(Skill::Attack),
-            Var::Block => Ok(Skill::Attack),
-            Var::Stun => Ok(Skill::Attack),
-            Var::Buff => Ok(Skill::Attack),
-            Var::Debuff => Ok(Skill::Attack),
-
-            Var::Strike => Ok(Skill::Attack),
+            Var::Amplify => Ok(Skill::Amplify),
+            Var::Banish => Ok(Skill::Banish),
             Var::Blast => Ok(Skill::Blast),
+            Var::Curse => Ok(Skill::Curse),
+            Var::Empower => Ok(Skill::Empower),
+            Var::Haste => Ok(Skill::Haste),
             Var::Heal => Ok(Skill::Heal),
-            Var::Throw => Ok(Skill::Throw),
             Var::Hex => Ok(Skill::Hex),
+            Var::Parry => Ok(Skill::Parry),
+            Var::Purge => Ok(Skill::Purge),
+            Var::Purify => Ok(Skill::Purify),
+            // Var::Reflect => Ok(Skill::Reflect),
+            Var::Ruin => Ok(Skill::Ruin),
+            Var::Shield => Ok(Skill::Shield),
+            Var::Silence => Ok(Skill::Silence),
+            Var::Slay => Ok(Skill::Slay),
+            Var::Slow => Ok(Skill::Slow),
+            Var::Snare => Ok(Skill::Snare),
+            Var::Strangle => Ok(Skill::Strangle),
+            // Var::Strike => Ok(Skill::Strike),
+            // Var::Taunt => Ok(Skill::Taunt),
+            Var::Throw => Ok(Skill::Throw),
+            // Var::Toxic => Ok(Skill::Toxic),
+            Var::Triage => Ok(Skill::Triage),
+
+
             _ => Err(err_msg("not a usable var"))
         }
     }
 }
 
+#[derive(Debug,Clone,Copy,PartialEq,Eq,Ord,PartialOrd,Serialize,Deserialize)]
+enum ColourCode {
+    RR,
+    GG,
+    BB,
+    RG,
+    BR,
+    GB,
+}
+
 #[derive(Debug,Clone,Serialize,Deserialize)]
 pub struct Vbox {
     pub id: Uuid,
@@ -115,14 +159,11 @@ impl Vbox {
     }
 
     pub fn accept(&mut self, i: usize) -> Result<&mut Vbox, Error> {
-        if self.bound.len() > 8 {
+        if self.bound.len() >= 9 {
             return Err(err_msg("too many vars bound"));
         }
 
-        println!("{:?}", self.free);
-
         self.free.get(i).ok_or(format_err!("no var at index {:?}", i))?;
-
         self.bound.push(self.free.remove(i));
 
         Ok(self)
@@ -176,60 +217,55 @@ impl Vbox {
             });
 
         let colour_code = match colours {
-            [2,0,0] => "rr",
-            [0,2,0] => "gg",
-            [0,0,2] => "bb",
-            [1,1,0] => "rg",
-            [0,1,1] => "gb",
-            [1,0,1] => "rb",
+            [2,0,0] => ColourCode::RR,
+            [0,2,0] => ColourCode::GG,
+            [0,0,2] => ColourCode::BB,
+            [1,1,0] => ColourCode::RG,
+            [0,1,1] => ColourCode::GB,
+            [1,0,1] => ColourCode::BR,
             _ => return Err(err_msg("not a combo")),
         };
 
         let new = match base {
             Var::Attack => match colour_code {
-                "rr" => Var::Strangle,
-                "gg" => Var::Heal,
-                "bb" => Var::Blast,
-                "rg" => Var::Slay,
-                "gb" => Var::Attack, // TBA
-                "rb" => Var::Banish,
-                _ => panic!("missing colour code {:?}", colour_code),
+                ColourCode::RR => Var::Strike,
+                ColourCode::GG => Var::Heal,
+                ColourCode::BB => Var::Blast,
+                ColourCode::RG => Var::Slay, //
+                ColourCode::GB => return Err(err_msg("unhandled skill combo")),
+                ColourCode::BR => Var::Banish, //
             },
             Var::Block => match colour_code {
-                "rr" => Var::Parry,
-                "gg" => Var::Reflect, // NYI
-                "bb" => Var::PlagueBarrier, // NYI
-                "rg" => Var::Shield,
-                "gb" => Var::Attack, // TBA
-                "rb" => Var::Taunt,
-                _ => panic!("missing colour code {:?}", colour_code),
+                ColourCode::RR => Var::Parry,
+                ColourCode::GG => Var::Reflect,
+                ColourCode::BB => Var::Toxic,
+                ColourCode::RG => Var::Shield, //
+                ColourCode::GB => return Err(err_msg("unhandled skill combo")),
+                ColourCode::BR => Var::Taunt,
             },
             Var::Buff => match colour_code {
-                "rr" => Var::Regenerate, // NYI heal red defense
-                "gg" => Var::Triage,
-                "bb" => Var::Amplify,
-                "rg" => Var::Purify,
-                "gb" => Var::Attack, // TBA
-                "rb" => Var::Haste,
-                _ => panic!("missing colour code {:?}", colour_code),
+                ColourCode::RR => Var::Empower,
+                ColourCode::GG => Var::Triage,
+                ColourCode::BB => Var::Amplify,
+                ColourCode::RG => return Err(err_msg("unhandled skill combo")),
+                ColourCode::GB => Var::Purify,
+                ColourCode::BR => Var::Haste,
             },
             Var::Debuff => match colour_code {
-                "rr" => Var::Snare,
-                "gg" => Var::Purge,
-                "bb" => Var::Curse,
-                "rg" => Var::Attack, // TBA
-                "gb" => Var::Attack,
-                "rb" => Var::Slow,
-                _ => panic!("missing colour code {:?}", colour_code),
+                ColourCode::RR => Var::Snare,
+                ColourCode::GG => Var::Purge,
+                ColourCode::BB => Var::Curse,
+                ColourCode::RG => return Err(err_msg("unhandled skill combo")),
+                ColourCode::GB => return Err(err_msg("unhandled skill combo")),
+                ColourCode::BR => Var::Slow, //
             },
             Var::Stun => match colour_code {
-                "rr" => Var::Strangle,
-                "gg" => Var::Throw,
-                "bb" => Var::Ruin,
-                "rg" => Var::Silence,
-                "gb" => Var::Attack, // TBA
-                "rb" => Var::Taunt,
-                _ => panic!("missing colour code {:?}", colour_code),
+                ColourCode::RR => Var::Strangle,
+                ColourCode::GG => Var::Throw,
+                ColourCode::BB => Var::Ruin,
+                ColourCode::RG => Var::Silence, //
+                ColourCode::GB => return Err(err_msg("unhandled skill combo")),
+                ColourCode::BR => Var::Hex, //
             },
             _ => panic!("wrong base {:?}", base),
         };