diff --git a/src/main/scala/net/psforever/objects/ExplosiveDeployable.scala b/src/main/scala/net/psforever/objects/ExplosiveDeployable.scala
index 56ed5fca..c291b448 100644
--- a/src/main/scala/net/psforever/objects/ExplosiveDeployable.scala
+++ b/src/main/scala/net/psforever/objects/ExplosiveDeployable.scala
@@ -7,6 +7,7 @@ import net.psforever.objects.ce._
 import net.psforever.objects.definition.{ComplexDeployableDefinition, SimpleDeployableDefinition}
 import net.psforever.objects.definition.converter.SmallDeployableConverter
 import net.psforever.objects.equipment.JammableUnit
+import net.psforever.objects.geometry.Geometry3D
 import net.psforever.objects.serverobject.affinity.FactionAffinity
 import net.psforever.objects.serverobject.{CommonMessages, PlanetSideServerObject}
 import net.psforever.objects.serverobject.damage.{Damageable, DamageableEntity}
@@ -118,11 +119,11 @@ class ExplosiveDeployableControl(mine: ExplosiveDeployable) extends Actor with D
     *        `false`, otherwise
     */
   def CanDetonate(obj: Vitality with FactionAffinity, damage: Int, data: DamageInteraction): Boolean = {
-    if (damage == 0 && data.cause.source.SympatheticExplosion) {
+    !mine.Destroyed && (if (damage == 0 && data.cause.source.SympatheticExplosion) {
       Damageable.CanDamageOrJammer(mine, damage = 1, data)
     } else {
       Damageable.CanDamageOrJammer(mine, damage, data)
-    }
+    })
   }
 }
 
@@ -169,7 +170,7 @@ object ExplosiveDeployableControl {
     val zone = target.Zone
     zone.Activity ! Zone.HotSpot.Activity(cause)
     zone.LocalEvents ! LocalServiceMessage(zone.id, LocalAction.Detonate(target.GUID, target))
-    Zone.causeExplosion(zone, target, Some(cause))
+    Zone.causeExplosion(zone, target, Some(cause), ExplosiveDeployableControl.detectionForExplosiveSource(target))
   }
 
   /**
@@ -196,4 +197,48 @@ object ExplosiveDeployableControl {
       )
     }
   }
+
+  /**
+    * Two game entities are considered "near" each other if they are within a certain distance of one another.
+    * For explosives, the source of the explosion is always typically constant.
+    * @see `detectsTarget`
+    * @see `ObjectDefinition.Geometry`
+    * @see `Vector3.relativeUp`
+    * @param obj a game entity that explodes
+    * @return a function that resolves a potential target as detected
+    */
+  def detectionForExplosiveSource(obj: PlanetSideGameObject): (PlanetSideGameObject, PlanetSideGameObject, Float) => Boolean = {
+    val up = Vector3.relativeUp(obj.Orientation) //check relativeUp; rotate as little as necessary!
+    val g1 = obj.Definition.Geometry(obj)
+    detectTarget(g1, up)
+  }
+
+  /**
+    * Two game entities are considered "near" each other if they are within a certain distance of one another.
+    * For explosives, targets in the damage radius in the direction of the blast (above the explosive) are valid targets.
+    * Targets that are ~0.5916f units in the opposite direction of the blast (below the explosive) are also selected.
+    * @see `ObjectDefinition.Geometry`
+    * @see `PrimitiveGeometry.pointOnOutside`
+    * @see `Vector3.DistanceSquared`
+    * @see `Vector3.neg`
+    * @see `Vector3.relativeUp`
+    * @see `Vector3.ScalarProjection`
+    * @see `Vector3.Unit`
+    * @param g1 a cached geometric representation that should belong to `obj1`
+    * @param up a cached vector in the direction of "above `obj1`'s geometric representation"
+    * @param obj1 a game entity that explodes
+    * @param obj2 a game entity that suffers the explosion
+    * @param maxDistance the square of the maximum distance permissible between game entities
+    *                    before they are no longer considered "near"
+    * @return `true`, if the target entities are near enough to each other;
+    *        `false`, otherwise
+    */
+  def detectTarget(g1: Geometry3D, up: Vector3)(obj1: PlanetSideGameObject, obj2: PlanetSideGameObject, maxDistance: Float) : Boolean = {
+    val g2 = obj2.Definition.Geometry(obj2)
+    val dir = g2.center.asVector3 - g1.center.asVector3
+    val scalar = Vector3.ScalarProjection(dir, up)
+    val point1 = g1.pointOnOutside(dir).asVector3
+    val point2 = g2.pointOnOutside(Vector3.neg(dir)).asVector3
+    (scalar >= 0 || Vector3.MagnitudeSquared(up * scalar) < 0.35f) && Vector3.DistanceSquared(point1, point2) <= maxDistance
+  }
 }
diff --git a/src/main/scala/net/psforever/objects/GlobalDefinitions.scala b/src/main/scala/net/psforever/objects/GlobalDefinitions.scala
index 62373100..11463740 100644
--- a/src/main/scala/net/psforever/objects/GlobalDefinitions.scala
+++ b/src/main/scala/net/psforever/objects/GlobalDefinitions.scala
@@ -7,6 +7,7 @@ import net.psforever.objects.ce.{DeployableCategory, DeployedItem}
 import net.psforever.objects.definition._
 import net.psforever.objects.definition.converter._
 import net.psforever.objects.equipment._
+import net.psforever.objects.geometry.GeometryForm
 import net.psforever.objects.inventory.InventoryTile
 import net.psforever.objects.serverobject.aura.Aura
 import net.psforever.objects.serverobject.doors.DoorDefinition
@@ -5602,6 +5603,11 @@ object GlobalDefinitions {
     * Initialize `VehicleDefinition` globals.
     */
   private def init_vehicles(): Unit = {
+    val atvForm = GeometryForm.representByCylinder(radius = 1.1797f, height = 1.1875f) _
+    val delivererForm = GeometryForm.representByCylinder(radius = 2.46095f, height = 2.40626f) _ //TODO hexahedron
+    val apcForm = GeometryForm.representByCylinder(radius = 4.6211f, height = 3.90626f) _ //TODO hexahedron
+    val liberatorForm = GeometryForm.representByCylinder(radius = 3.74615f, height = 2.51563f) _
+
     fury.Name = "fury"
     fury.MaxHealth = 650
     fury.Damageable = true
@@ -5632,6 +5638,7 @@ object GlobalDefinitions {
     fury.DrownAtMaxDepth = true
     fury.MaxDepth = 1.3f
     fury.UnderwaterLifespan(suffocation = 5000L, recovery = 2500L)
+    fury.Geometry = atvForm
 
     quadassault.Name = "quadassault" // Basilisk
     quadassault.MaxHealth = 650
@@ -5663,6 +5670,7 @@ object GlobalDefinitions {
     quadassault.DrownAtMaxDepth = true
     quadassault.MaxDepth = 1.3f
     quadassault.UnderwaterLifespan(suffocation = 5000L, recovery = 2500L)
+    quadassault.Geometry = atvForm
 
     quadstealth.Name = "quadstealth" // Wraith
     quadstealth.MaxHealth = 650
@@ -5694,6 +5702,7 @@ object GlobalDefinitions {
     quadstealth.DrownAtMaxDepth = true
     quadstealth.MaxDepth = 1.25f
     quadstealth.UnderwaterLifespan(suffocation = 5000L, recovery = 2500L)
+    quadstealth.Geometry = atvForm
 
     two_man_assault_buggy.Name = "two_man_assault_buggy" // Harasser
     two_man_assault_buggy.MaxHealth = 1250
@@ -5727,6 +5736,7 @@ object GlobalDefinitions {
     two_man_assault_buggy.DrownAtMaxDepth = true
     two_man_assault_buggy.MaxDepth = 1.5f
     two_man_assault_buggy.UnderwaterLifespan(suffocation = 5000L, recovery = 2500L)
+    two_man_assault_buggy.Geometry = GeometryForm.representByCylinder(radius = 2.10545f, height = 1.59376f)
 
     skyguard.Name = "skyguard"
     skyguard.MaxHealth = 1000
@@ -5749,7 +5759,6 @@ object GlobalDefinitions {
     skyguard.AutoPilotSpeeds = (22, 8)
     skyguard.DestroyedModel = Some(DestroyedVehicle.Skyguard)
     skyguard.JackingDuration = Array(0, 15, 5, 3)
-
     skyguard.explodes = true
     skyguard.innateDamage = new DamageWithPosition {
       CausesDamageType = DamageType.One
@@ -5762,6 +5771,7 @@ object GlobalDefinitions {
     skyguard.DrownAtMaxDepth = true
     skyguard.MaxDepth = 1.5f
     skyguard.UnderwaterLifespan(suffocation = 5000L, recovery = 2500L)
+    skyguard.Geometry = GeometryForm.representByCylinder(radius = 1.8867f, height = 1.4375f)
 
     threemanheavybuggy.Name = "threemanheavybuggy" // Marauder
     threemanheavybuggy.MaxHealth = 1700
@@ -5801,6 +5811,7 @@ object GlobalDefinitions {
     threemanheavybuggy.DrownAtMaxDepth = true
     threemanheavybuggy.MaxDepth = 1.83f
     threemanheavybuggy.UnderwaterLifespan(suffocation = 5000L, recovery = 2500L)
+    threemanheavybuggy.Geometry = GeometryForm.representByCylinder(radius = 2.1953f, height = 2.03125f)
 
     twomanheavybuggy.Name = "twomanheavybuggy" // Enforcer
     twomanheavybuggy.MaxHealth = 1800
@@ -5835,6 +5846,7 @@ object GlobalDefinitions {
     twomanheavybuggy.DrownAtMaxDepth = true
     twomanheavybuggy.MaxDepth = 1.95f
     twomanheavybuggy.UnderwaterLifespan(suffocation = 5000L, recovery = 2500L)
+    twomanheavybuggy.Geometry = GeometryForm.representByCylinder(radius = 2.60935f, height = 1.79688f)
 
     twomanhoverbuggy.Name = "twomanhoverbuggy" // Thresher
     twomanhoverbuggy.MaxHealth = 1600
@@ -5868,6 +5880,7 @@ object GlobalDefinitions {
     }
     twomanhoverbuggy.DrownAtMaxDepth = true
     twomanhoverbuggy.UnderwaterLifespan(suffocation = 45000L, recovery = 5000L) //but the thresher hovers over water, so ...?
+    twomanhoverbuggy.Geometry = GeometryForm.representByCylinder(radius = 2.1875f, height = 2.01563f)
 
     mediumtransport.Name = "mediumtransport" // Deliverer
     mediumtransport.MaxHealth = 2500
@@ -5909,6 +5922,7 @@ object GlobalDefinitions {
     mediumtransport.DrownAtMaxDepth = false
     mediumtransport.MaxDepth = 1.2f
     mediumtransport.UnderwaterLifespan(suffocation = -1, recovery = -1)
+    mediumtransport.Geometry = delivererForm
 
     battlewagon.Name = "battlewagon" // Raider
     battlewagon.MaxHealth = 2500
@@ -5953,6 +5967,7 @@ object GlobalDefinitions {
     battlewagon.DrownAtMaxDepth = true
     battlewagon.MaxDepth = 1.2f
     battlewagon.UnderwaterLifespan(suffocation = -1, recovery = -1)
+    battlewagon.Geometry = delivererForm
 
     thunderer.Name = "thunderer"
     thunderer.MaxHealth = 2500
@@ -5994,6 +6009,7 @@ object GlobalDefinitions {
     thunderer.DrownAtMaxDepth = true
     thunderer.MaxDepth = 1.2f
     thunderer.UnderwaterLifespan(suffocation = -1, recovery = -1)
+    thunderer.Geometry = delivererForm
 
     aurora.Name = "aurora"
     aurora.MaxHealth = 2500
@@ -6035,6 +6051,7 @@ object GlobalDefinitions {
     aurora.DrownAtMaxDepth = true
     aurora.MaxDepth = 1.2f
     aurora.UnderwaterLifespan(suffocation = -1, recovery = -1)
+    aurora.Geometry = delivererForm
 
     apc_tr.Name = "apc_tr" // Juggernaut
     apc_tr.MaxHealth = 6000
@@ -6099,6 +6116,7 @@ object GlobalDefinitions {
     apc_tr.DrownAtMaxDepth = true
     apc_tr.MaxDepth = 3
     apc_tr.UnderwaterLifespan(suffocation = 15000L, recovery = 7500L)
+    apc_tr.Geometry = apcForm
 
     apc_nc.Name = "apc_nc" // Vindicator
     apc_nc.MaxHealth = 6000
@@ -6163,6 +6181,7 @@ object GlobalDefinitions {
     apc_nc.DrownAtMaxDepth = true
     apc_nc.MaxDepth = 3
     apc_nc.UnderwaterLifespan(suffocation = 15000L, recovery = 7500L)
+    apc_nc.Geometry = apcForm
 
     apc_vs.Name = "apc_vs" // Leviathan
     apc_vs.MaxHealth = 6000
@@ -6227,6 +6246,7 @@ object GlobalDefinitions {
     apc_vs.DrownAtMaxDepth = true
     apc_vs.MaxDepth = 3
     apc_vs.UnderwaterLifespan(suffocation = 15000L, recovery = 7500L)
+    apc_vs.Geometry = apcForm
 
     lightning.Name = "lightning"
     lightning.MaxHealth = 2000
@@ -6259,6 +6279,7 @@ object GlobalDefinitions {
     lightning.DrownAtMaxDepth = true
     lightning.MaxDepth = 1.38f
     lightning.UnderwaterLifespan(suffocation = 12000L, recovery = 6000L)
+    lightning.Geometry = GeometryForm.representByCylinder(radius = 2.5078f, height = 1.79688f)
 
     prowler.Name = "prowler"
     prowler.MaxHealth = 4800
@@ -6296,6 +6317,7 @@ object GlobalDefinitions {
     prowler.DrownAtMaxDepth = true
     prowler.MaxDepth = 3
     prowler.UnderwaterLifespan(suffocation = 12000L, recovery = 6000L)
+    prowler.Geometry = GeometryForm.representByCylinder(radius = 3.461f, height = 3.48438f)
 
     vanguard.Name = "vanguard"
     vanguard.MaxHealth = 5400
@@ -6329,6 +6351,7 @@ object GlobalDefinitions {
     vanguard.DrownAtMaxDepth = true
     vanguard.MaxDepth = 2.7f
     vanguard.UnderwaterLifespan(suffocation = 12000L, recovery = 6000L)
+    vanguard.Geometry = GeometryForm.representByCylinder(radius = 3.8554f, height = 2.60938f)
 
     magrider.Name = "magrider"
     magrider.MaxHealth = 4200
@@ -6364,6 +6387,7 @@ object GlobalDefinitions {
     magrider.DrownAtMaxDepth = true
     magrider.MaxDepth = 2
     magrider.UnderwaterLifespan(suffocation = 45000L, recovery = 5000L) //but the magrider hovers over water, so ...?
+    magrider.Geometry = GeometryForm.representByCylinder(radius = 3.3008f, height = 3.26562f)
 
     val utilityConverter = new UtilityVehicleConverter
     ant.Name = "ant"
@@ -6397,6 +6421,7 @@ object GlobalDefinitions {
     ant.DrownAtMaxDepth = true
     ant.MaxDepth = 2
     ant.UnderwaterLifespan(suffocation = 12000L, recovery = 6000L)
+    ant.Geometry = GeometryForm.representByCylinder(radius = 2.16795f, height = 2.09376f) //TODO hexahedron
 
     ams.Name = "ams"
     ams.MaxHealth = 5000 // Temporary - original value is 3000
@@ -6433,6 +6458,7 @@ object GlobalDefinitions {
     ams.DrownAtMaxDepth = true
     ams.MaxDepth = 3
     ams.UnderwaterLifespan(suffocation = 5000L, recovery = 5000L)
+    ams.Geometry = GeometryForm.representByCylinder(radius = 3.0117f, height = 3.39062f) //TODO hexahedron
 
     val variantConverter = new VariantVehicleConverter
     router.Name = "router"
@@ -6469,6 +6495,7 @@ object GlobalDefinitions {
     router.DrownAtMaxDepth = true
     router.MaxDepth = 2
     router.UnderwaterLifespan(suffocation = 45000L, recovery = 5000L) //but the router hovers over water, so ...?
+    router.Geometry = GeometryForm.representByCylinder(radius = 3.64845f, height = 3.51563f) //TODO hexahedron
 
     switchblade.Name = "switchblade"
     switchblade.MaxHealth = 1750
@@ -6505,6 +6532,7 @@ object GlobalDefinitions {
     switchblade.DrownAtMaxDepth = true
     switchblade.MaxDepth = 2
     switchblade.UnderwaterLifespan(suffocation = 45000L, recovery = 5000L) //but the switchblade hovers over water, so ...?
+    switchblade.Geometry = GeometryForm.representByCylinder(radius = 2.4335f, height = 2.73438f)
 
     flail.Name = "flail"
     flail.MaxHealth = 2400
@@ -6539,6 +6567,7 @@ object GlobalDefinitions {
     flail.DrownAtMaxDepth = true
     flail.MaxDepth = 2
     flail.UnderwaterLifespan(suffocation = 45000L, recovery = 5000L) //but the flail hovers over water, so ...?
+    flail.Geometry = GeometryForm.representByCylinder(radius = 2.1875f, height = 2.21875f)
 
     mosquito.Name = "mosquito"
     mosquito.MaxHealth = 665
@@ -6572,6 +6601,7 @@ object GlobalDefinitions {
     }
     mosquito.DrownAtMaxDepth = true
     mosquito.MaxDepth = 2 //flying vehicles will automatically disable
+    mosquito.Geometry = GeometryForm.representByCylinder(radius = 2.72108f, height = 2.5f)
 
     lightgunship.Name = "lightgunship" // Reaver
     lightgunship.MaxHealth = 1000
@@ -6606,6 +6636,7 @@ object GlobalDefinitions {
     }
     lightgunship.DrownAtMaxDepth = true
     lightgunship.MaxDepth = 2 //flying vehicles will automatically disable
+    lightgunship.Geometry = GeometryForm.representByCylinder(radius = 2.375f, height = 1.98438f)
 
     wasp.Name = "wasp"
     wasp.MaxHealth = 515
@@ -6639,6 +6670,7 @@ object GlobalDefinitions {
     }
     wasp.DrownAtMaxDepth = true
     wasp.MaxDepth = 2 //flying vehicles will automatically disable
+    wasp.Geometry = GeometryForm.representByCylinder(radius = 2.88675f, height = 2.5f)
 
     liberator.Name = "liberator"
     liberator.MaxHealth = 2500
@@ -6680,6 +6712,7 @@ object GlobalDefinitions {
     }
     liberator.DrownAtMaxDepth = true
     liberator.MaxDepth = 2 //flying vehicles will automatically disable
+    liberator.Geometry = liberatorForm
 
     vulture.Name = "vulture"
     vulture.MaxHealth = 2500
@@ -6722,6 +6755,7 @@ object GlobalDefinitions {
     }
     vulture.DrownAtMaxDepth = true
     vulture.MaxDepth = 2 //flying vehicles will automatically disable
+    vulture.Geometry = liberatorForm
 
     dropship.Name = "dropship" // Galaxy
     dropship.MaxHealth = 5000
@@ -6796,6 +6830,7 @@ object GlobalDefinitions {
     }
     dropship.DrownAtMaxDepth = true
     dropship.MaxDepth = 2
+    dropship.Geometry = GeometryForm.representByCylinder(radius = 10.52202f, height = 6.23438f)
 
     galaxy_gunship.Name = "galaxy_gunship"
     galaxy_gunship.MaxHealth = 6000
@@ -6849,6 +6884,7 @@ object GlobalDefinitions {
     }
     galaxy_gunship.DrownAtMaxDepth = true
     galaxy_gunship.MaxDepth = 2
+    galaxy_gunship.Geometry = GeometryForm.representByCylinder(radius = 9.2382f, height = 5.01562f)
 
     lodestar.Name = "lodestar"
     lodestar.MaxHealth = 5000
@@ -6890,6 +6926,7 @@ object GlobalDefinitions {
     }
     lodestar.DrownAtMaxDepth = true
     lodestar.MaxDepth = 2
+    lodestar.Geometry = GeometryForm.representByCylinder(radius = 7.8671f, height = 6.79688f) //TODO hexahedron
 
     phantasm.Name = "phantasm"
     phantasm.MaxHealth = 2500
@@ -6932,6 +6969,7 @@ object GlobalDefinitions {
     }
     phantasm.DrownAtMaxDepth = true
     phantasm.MaxDepth = 2
+    phantasm.Geometry = GeometryForm.representByCylinder(radius = 5.2618f, height = 3f)
 
     droppod.Name = "droppod"
     droppod.MaxHealth = 20000
@@ -6945,12 +6983,18 @@ object GlobalDefinitions {
     droppod.DestroyedModel = None //the adb calls out a droppod; the cyclic nature of this confounds me
     droppod.DamageUsing = DamageCalculations.AgainstAircraft
     droppod.DrownAtMaxDepth = false
+    //TODO geometry?
   }
 
   /**
     * Initialize `Deployable` globals.
     */
   private def init_deployables(): Unit = {
+    val mine = GeometryForm.representByCylinder(radius = 0.1914f, height = 0.0957f) _
+    val smallTurret = GeometryForm.representByCylinder(radius = 0.48435f, height = 1.23438f) _
+    val sensor = GeometryForm.representByCylinder(radius = 0.1914f, height = 1.21875f) _
+    val largeTurret = GeometryForm.representByCylinder(radius = 0.8437f, height = 2.29687f) _
+
     boomer.Name = "boomer"
     boomer.Descriptor = "Boomers"
     boomer.MaxHealth = 100
@@ -6972,6 +7016,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.1f
       Modifiers = ExplodingRadialDegrade
     }
+    boomer.Geometry = mine
 
     he_mine.Name = "he_mine"
     he_mine.Descriptor = "Mines"
@@ -6993,6 +7038,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.25f
       Modifiers = ExplodingRadialDegrade
     }
+    he_mine.Geometry = mine
 
     jammer_mine.Name = "jammer_mine"
     jammer_mine.Descriptor = "JammerMines"
@@ -7002,6 +7048,7 @@ object GlobalDefinitions {
     jammer_mine.Repairable = false
     jammer_mine.DeployTime = Duration.create(1000, "ms")
     jammer_mine.DetonateOnJamming = false
+    jammer_mine.Geometry = mine
 
     spitfire_turret.Name = "spitfire_turret"
     spitfire_turret.Descriptor = "Spitfires"
@@ -7025,6 +7072,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.2f
       Modifiers = ExplodingRadialDegrade
     }
+    spitfire_turret.Geometry = smallTurret
 
     spitfire_cloaked.Name = "spitfire_cloaked"
     spitfire_cloaked.Descriptor = "CloakingSpitfires"
@@ -7047,6 +7095,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.2f
       Modifiers = ExplodingRadialDegrade
     }
+    spitfire_cloaked.Geometry = smallTurret
 
     spitfire_aa.Name = "spitfire_aa"
     spitfire_aa.Descriptor = "FlakSpitfires"
@@ -7069,6 +7118,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.2f
       Modifiers = ExplodingRadialDegrade
     }
+    spitfire_aa.Geometry = smallTurret
 
     motionalarmsensor.Name = "motionalarmsensor"
     motionalarmsensor.Descriptor = "MotionSensors"
@@ -7077,6 +7127,7 @@ object GlobalDefinitions {
     motionalarmsensor.Repairable = true
     motionalarmsensor.RepairIfDestroyed = false
     motionalarmsensor.DeployTime = Duration.create(1000, "ms")
+    motionalarmsensor.Geometry = sensor
 
     sensor_shield.Name = "sensor_shield"
     sensor_shield.Descriptor = "SensorShields"
@@ -7085,6 +7136,7 @@ object GlobalDefinitions {
     sensor_shield.Repairable = true
     sensor_shield.RepairIfDestroyed = false
     sensor_shield.DeployTime = Duration.create(5000, "ms")
+    sensor_shield.Geometry = sensor
 
     tank_traps.Name = "tank_traps"
     tank_traps.Descriptor = "TankTraps"
@@ -7103,6 +7155,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.2f
       Modifiers = ExplodingRadialDegrade
     }
+    tank_traps.Geometry = GeometryForm.representByCylinder(radius = 2.89680997f, height = 3.57812f)
 
     val fieldTurretConverter = new FieldTurretConverter
     portable_manned_turret.Name = "portable_manned_turret"
@@ -7130,6 +7183,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.1f
       Modifiers = ExplodingRadialDegrade
     }
+    portable_manned_turret.Geometry = largeTurret
 
     portable_manned_turret_nc.Name = "portable_manned_turret_nc"
     portable_manned_turret_nc.Descriptor = "FieldTurrets"
@@ -7156,6 +7210,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.1f
       Modifiers = ExplodingRadialDegrade
     }
+    portable_manned_turret_nc.Geometry = largeTurret
 
     portable_manned_turret_tr.Name = "portable_manned_turret_tr"
     portable_manned_turret_tr.Descriptor = "FieldTurrets"
@@ -7182,6 +7237,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.1f
       Modifiers = ExplodingRadialDegrade
     }
+    portable_manned_turret_tr.Geometry = largeTurret
 
     portable_manned_turret_vs.Name = "portable_manned_turret_vs"
     portable_manned_turret_vs.Descriptor = "FieldTurrets"
@@ -7208,6 +7264,7 @@ object GlobalDefinitions {
       DamageAtEdge = 0.1f
       Modifiers = ExplodingRadialDegrade
     }
+    portable_manned_turret_vs.Geometry = largeTurret
 
     deployable_shield_generator.Name = "deployable_shield_generator"
     deployable_shield_generator.Descriptor = "ShieldGenerators"
@@ -7217,6 +7274,7 @@ object GlobalDefinitions {
     deployable_shield_generator.RepairIfDestroyed = false
     deployable_shield_generator.DeployTime = Duration.create(6000, "ms")
     deployable_shield_generator.Model = ComplexDeployableResolutions.calculate
+    deployable_shield_generator.Geometry = GeometryForm.representByCylinder(radius = 0.6562f, height = 2.17188f)
 
     router_telepad_deployable.Name = "router_telepad_deployable"
     router_telepad_deployable.MaxHealth = 100
@@ -7226,6 +7284,7 @@ object GlobalDefinitions {
     router_telepad_deployable.DeployCategory = DeployableCategory.Telepads
     router_telepad_deployable.Packet = new TelepadDeployableConverter
     router_telepad_deployable.Model = SimpleResolutions.calculate
+    router_telepad_deployable.Geometry = GeometryForm.representByRaisedSphere(radius = 1.2344f)
 
     internal_router_telepad_deployable.Name = "router_telepad_deployable"
     internal_router_telepad_deployable.MaxHealth = 1
@@ -7240,6 +7299,8 @@ object GlobalDefinitions {
     * Initialize `Miscellaneous` globals.
     */
   private def initMiscellaneous(): Unit = {
+    val vterm = GeometryForm.representByCylinder(radius = 1.03515f, height = 1.09374f) _
+
     ams_respawn_tube.Name = "ams_respawn_tube"
     ams_respawn_tube.Delay = 10
     ams_respawn_tube.SpecificPointFunc = SpawnPoint.AMS
@@ -7280,9 +7341,10 @@ object GlobalDefinitions {
     order_terminal.MaxHealth = 500
     order_terminal.Damageable = true
     order_terminal.Repairable = true
-    order_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    order_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     order_terminal.RepairIfDestroyed = true
     order_terminal.Subtract.Damage1 = 8
+    order_terminal.Geometry = GeometryForm.representByCylinder(radius = 0.8438f, height = 1.3f)
 
     order_terminala.Name = "order_terminala"
     order_terminala.Tab += 0 -> OrderTerminalDefinition.EquipmentPage(
@@ -7344,16 +7406,18 @@ object GlobalDefinitions {
     cert_terminal.MaxHealth = 500
     cert_terminal.Damageable = true
     cert_terminal.Repairable = true
-    cert_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    cert_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     cert_terminal.RepairIfDestroyed = true
     cert_terminal.Subtract.Damage1 = 8
+    cert_terminal.Geometry = GeometryForm.representByCylinder(radius = 0.66405f, height = 1.09374f)
 
     implant_terminal_mech.Name = "implant_terminal_mech"
     implant_terminal_mech.MaxHealth = 1500 //TODO 1000; right now, 1000 (mech) + 500 (interface)
     implant_terminal_mech.Damageable = true
     implant_terminal_mech.Repairable = true
-    implant_terminal_mech.autoRepair = AutoRepairStats(1.6f, 5000, 2400, 0.5f) //ori. 1, 5000, 2400, 0.5f
+    implant_terminal_mech.autoRepair = AutoRepairStats(1.6f, 5000, 2400, 0.5f)
     implant_terminal_mech.RepairIfDestroyed = true
+    implant_terminal_mech.Geometry = GeometryForm.representByCylinder(radius = 2.7813f, height = 6.4375f)
 
     implant_terminal_interface.Name = "implant_terminal_interface"
     implant_terminal_interface.Tab += 0 -> OrderTerminalDefinition.ImplantPage(ImplantTerminalDefinition.implants)
@@ -7362,6 +7426,7 @@ object GlobalDefinitions {
     implant_terminal_interface.Repairable = true
     implant_terminal_interface.autoRepair = AutoRepairStats(1, 5000, 200, 1) //TODO amount and drain are default? undefined?
     implant_terminal_interface.RepairIfDestroyed = true
+    //TODO will need geometry when Damageable = true
 
     ground_vehicle_terminal.Name = "ground_vehicle_terminal"
     ground_vehicle_terminal.Tab += 46769 -> OrderTerminalDefinition.VehiclePage(
@@ -7372,9 +7437,10 @@ object GlobalDefinitions {
     ground_vehicle_terminal.MaxHealth = 500
     ground_vehicle_terminal.Damageable = true
     ground_vehicle_terminal.Repairable = true
-    ground_vehicle_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    ground_vehicle_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     ground_vehicle_terminal.RepairIfDestroyed = true
     ground_vehicle_terminal.Subtract.Damage1 = 8
+    ground_vehicle_terminal.Geometry = vterm
 
     air_vehicle_terminal.Name = "air_vehicle_terminal"
     air_vehicle_terminal.Tab += 46769 -> OrderTerminalDefinition.VehiclePage(
@@ -7385,9 +7451,10 @@ object GlobalDefinitions {
     air_vehicle_terminal.MaxHealth = 500
     air_vehicle_terminal.Damageable = true
     air_vehicle_terminal.Repairable = true
-    air_vehicle_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    air_vehicle_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     air_vehicle_terminal.RepairIfDestroyed = true
     air_vehicle_terminal.Subtract.Damage1 = 8
+    air_vehicle_terminal.Geometry = vterm
 
     dropship_vehicle_terminal.Name = "dropship_vehicle_terminal"
     dropship_vehicle_terminal.Tab += 46769 -> OrderTerminalDefinition.VehiclePage(
@@ -7398,9 +7465,10 @@ object GlobalDefinitions {
     dropship_vehicle_terminal.MaxHealth = 500
     dropship_vehicle_terminal.Damageable = true
     dropship_vehicle_terminal.Repairable = true
-    dropship_vehicle_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    dropship_vehicle_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     dropship_vehicle_terminal.RepairIfDestroyed = true
     dropship_vehicle_terminal.Subtract.Damage1 = 8
+    dropship_vehicle_terminal.Geometry = vterm
 
     vehicle_terminal_combined.Name = "vehicle_terminal_combined"
     vehicle_terminal_combined.Tab += 46769 -> OrderTerminalDefinition.VehiclePage(
@@ -7411,9 +7479,10 @@ object GlobalDefinitions {
     vehicle_terminal_combined.MaxHealth = 500
     vehicle_terminal_combined.Damageable = true
     vehicle_terminal_combined.Repairable = true
-    vehicle_terminal_combined.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    vehicle_terminal_combined.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     vehicle_terminal_combined.RepairIfDestroyed = true
     vehicle_terminal_combined.Subtract.Damage1 = 8
+    vehicle_terminal_combined.Geometry = vterm
 
     vanu_air_vehicle_term.Name = "vanu_air_vehicle_term"
     vanu_air_vehicle_term.Tab += 46769 -> OrderTerminalDefinition.VehiclePage(
@@ -7424,7 +7493,7 @@ object GlobalDefinitions {
     vanu_air_vehicle_term.MaxHealth = 500
     vanu_air_vehicle_term.Damageable = true
     vanu_air_vehicle_term.Repairable = true
-    vanu_air_vehicle_term.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    vanu_air_vehicle_term.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     vanu_air_vehicle_term.RepairIfDestroyed = true
     vanu_air_vehicle_term.Subtract.Damage1 = 8
 
@@ -7437,7 +7506,7 @@ object GlobalDefinitions {
     vanu_vehicle_term.MaxHealth = 500
     vanu_vehicle_term.Damageable = true
     vanu_vehicle_term.Repairable = true
-    vanu_vehicle_term.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    vanu_vehicle_term.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     vanu_vehicle_term.RepairIfDestroyed = true
     vanu_vehicle_term.Subtract.Damage1 = 8
 
@@ -7450,9 +7519,10 @@ object GlobalDefinitions {
     bfr_terminal.MaxHealth = 500
     bfr_terminal.Damageable = true
     bfr_terminal.Repairable = true
-    bfr_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    bfr_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     bfr_terminal.RepairIfDestroyed = true
     bfr_terminal.Subtract.Damage1 = 8
+    bfr_terminal.Geometry = GeometryForm.representByCylinder(radius = 0.92185f, height = 2.64693f)
 
     respawn_tube.Name = "respawn_tube"
     respawn_tube.Delay = 10
@@ -7461,9 +7531,10 @@ object GlobalDefinitions {
     respawn_tube.Damageable = true
     respawn_tube.DamageableByFriendlyFire = false
     respawn_tube.Repairable = true
-    respawn_tube.autoRepair = AutoRepairStats(1.6f, 10000, 2400, 1) //orig. 1, 10000, 2400, 1
+    respawn_tube.autoRepair = AutoRepairStats(1.6f, 10000, 2400, 1) 
     respawn_tube.RepairIfDestroyed = true
     respawn_tube.Subtract.Damage1 = 8
+    respawn_tube.Geometry = GeometryForm.representByCylinder(radius = 0.9336f, height = 2.84375f)
 
     respawn_tube_sanctuary.Name = "respawn_tube"
     respawn_tube_sanctuary.Delay = 10
@@ -7472,7 +7543,8 @@ object GlobalDefinitions {
     respawn_tube_sanctuary.Damageable = false //true?
     respawn_tube_sanctuary.DamageableByFriendlyFire = false
     respawn_tube_sanctuary.Repairable = true
-    respawn_tube_sanctuary.autoRepair = AutoRepairStats(1.6f, 10000, 2400, 1) //orig. 1, 10000, 2400, 1
+    respawn_tube_sanctuary.autoRepair = AutoRepairStats(1.6f, 10000, 2400, 1)
+    //TODO will need geometry when Damageable = true
 
     respawn_tube_tower.Name = "respawn_tube_tower"
     respawn_tube_tower.Delay = 10
@@ -7481,9 +7553,10 @@ object GlobalDefinitions {
     respawn_tube_tower.Damageable = true
     respawn_tube_tower.DamageableByFriendlyFire = false
     respawn_tube_tower.Repairable = true
-    respawn_tube_tower.autoRepair = AutoRepairStats(1.6f, 10000, 2400, 1) //orig. 1, 10000, 2400, 1
+    respawn_tube_tower.autoRepair = AutoRepairStats(1.6f, 10000, 2400, 1) 
     respawn_tube_tower.RepairIfDestroyed = true
     respawn_tube_tower.Subtract.Damage1 = 8
+    respawn_tube_tower.Geometry = GeometryForm.representByCylinder(radius = 0.9336f, height = 2.84375f)
 
     teleportpad_terminal.Name = "teleportpad_terminal"
     teleportpad_terminal.Tab += 0 -> OrderTerminalDefinition.EquipmentPage(EquipmentTerminalDefinition.routerTerminal)
@@ -7499,8 +7572,9 @@ object GlobalDefinitions {
     medical_terminal.MaxHealth = 500
     medical_terminal.Damageable = true
     medical_terminal.Repairable = true
-    medical_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    medical_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
     medical_terminal.RepairIfDestroyed = true
+    medical_terminal.Geometry = GeometryForm.representByCylinder(radius = 0.711f, height = 1.75f)
 
     adv_med_terminal.Name = "adv_med_terminal"
     adv_med_terminal.Interval = 500
@@ -7511,8 +7585,9 @@ object GlobalDefinitions {
     adv_med_terminal.MaxHealth = 750
     adv_med_terminal.Damageable = true
     adv_med_terminal.Repairable = true
-    adv_med_terminal.autoRepair = AutoRepairStats(1.57894f, 5000, 2400, 0.5f) //orig. 1, 5000, 2400, 0.5f
+    adv_med_terminal.autoRepair = AutoRepairStats(1.57894f, 5000, 2400, 0.5f) 
     adv_med_terminal.RepairIfDestroyed = true
+    adv_med_terminal.Geometry = GeometryForm.representByCylinder(radius = 0.8662125f, height = 3.47f)
 
     crystals_health_a.Name = "crystals_health_a"
     crystals_health_a.Interval = 500
@@ -7539,7 +7614,7 @@ object GlobalDefinitions {
     portable_med_terminal.MaxHealth = 500
     portable_med_terminal.Damageable = false //TODO actually true
     portable_med_terminal.Repairable = false
-    portable_med_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) //orig. 1, 5000, 3500, 0.5f
+    portable_med_terminal.autoRepair = AutoRepairStats(2.24215f, 5000, 3500, 0.5f) 
 
     pad_landing_frame.Name = "pad_landing_frame"
     pad_landing_frame.Interval = 1000
@@ -7653,7 +7728,7 @@ object GlobalDefinitions {
     manned_turret.Damageable = true
     manned_turret.DamageDisablesAt = 0
     manned_turret.Repairable = true
-    manned_turret.autoRepair = AutoRepairStats(1.0909f, 10000, 1600, 0.5f) //orig. 1, 10000, 1600, 0.5f
+    manned_turret.autoRepair = AutoRepairStats(1.0909f, 10000, 1600, 0.5f) 
     manned_turret.RepairIfDestroyed = true
     manned_turret.Weapons += 1                          -> new mutable.HashMap()
     manned_turret.Weapons(1) += TurretUpgrade.None      -> phalanx_sgl_hevgatcan
@@ -7671,13 +7746,14 @@ object GlobalDefinitions {
       DamageAtEdge = 0.1f
       Modifiers = ExplodingRadialDegrade
     }
+    manned_turret.Geometry = GeometryForm.representByCylinder(radius = 1.2695f, height = 2.6875f)
 
     vanu_sentry_turret.Name = "vanu_sentry_turret"
     vanu_sentry_turret.MaxHealth = 1500
     vanu_sentry_turret.Damageable = true
     vanu_sentry_turret.DamageDisablesAt = 0
     vanu_sentry_turret.Repairable = true
-    vanu_sentry_turret.autoRepair = AutoRepairStats(3.27272f, 10000, 1000, 0.5f) //orig. 3, 10000, 1000, 0.5f
+    vanu_sentry_turret.autoRepair = AutoRepairStats(3.27272f, 10000, 1000, 0.5f) 
     vanu_sentry_turret.RepairIfDestroyed = true
     vanu_sentry_turret.Weapons += 1                     -> new mutable.HashMap()
     vanu_sentry_turret.Weapons(1) += TurretUpgrade.None -> vanu_sentry_turret_weapon
@@ -7685,6 +7761,7 @@ object GlobalDefinitions {
     vanu_sentry_turret.MountPoints += 2                 -> 0
     vanu_sentry_turret.FactionLocked = false
     vanu_sentry_turret.ReserveAmmunition = false
+    vanu_sentry_turret.Geometry = GeometryForm.representByCylinder(radius = 1.76311f, height = 3.984375f)
 
     painbox.Name = "painbox"
     painbox.alwaysOn = false
@@ -7759,7 +7836,7 @@ object GlobalDefinitions {
     generator.Damageable = true
     generator.DamageableByFriendlyFire = false
     generator.Repairable = true
-    generator.autoRepair = AutoRepairStats(0.77775f, 5000, 875, 1) //orig. 1, 5000, 875, 1
+    generator.autoRepair = AutoRepairStats(0.77775f, 5000, 875, 1) 
     generator.RepairDistance = 13.5f
     generator.RepairIfDestroyed = true
     generator.Subtract.Damage1 = 9
@@ -7774,5 +7851,6 @@ object GlobalDefinitions {
       Modifiers = ExplodingRadialDegrade
       //damage is 99999 at 14m, dropping rapidly to ~1 at 15.75m
     }
+    generator.Geometry = GeometryForm.representByCylinder(radius = 1.2617f, height = 9.14063f)
   }
 }
diff --git a/src/main/scala/net/psforever/objects/geometry/Closest.scala b/src/main/scala/net/psforever/objects/geometry/Closest.scala
deleted file mode 100644
index 4b3dc6eb..00000000
--- a/src/main/scala/net/psforever/objects/geometry/Closest.scala
+++ /dev/null
@@ -1,280 +0,0 @@
-// Copyright (c) 2021 PSForever
-package net.psforever.objects.geometry
-
-import net.psforever.types.Vector3
-
-object Closest {
-  object Distance {
-    def apply(point : Vector3, seg : Segment2D) : Float = {
-      val segdx = seg.p2.x - seg.p1.x
-      val segdy = seg.p2.y - seg.p1.y
-      ((point.x - seg.p1.x) * segdx + (point.y - seg.p1.y) * segdy) /
-      Vector3.MagnitudeSquared(Vector3(segdx, segdy, 0))
-    }
-
-    def apply(line1 : Line2D, line2 : Line2D) : Float = {
-      if (Intersection.Test(line1, line2)) { //intersecting lines
-        0f
-      } else {
-        math.abs(
-          Vector3.DotProduct(
-            Vector3(line2.p.x - line1.p.x, line2.p.y - line1.p.y, 0),
-            Vector3(-1/line1.d.y, 1/line1.d.x, 0)
-          )
-        )
-      }
-    }
-
-    def apply(seg1: Segment2D, seg2: Segment2D): Float = {
-      if (Intersection.Test(seg1, seg2)) { //intersecting line segments
-        0f
-      } else {
-        val v1a = Vector3(seg1.p1.x, seg1.p1.y, 0)
-        val v2a = Vector3(seg2.p1.x, seg2.p1.y, 0)
-        val v1b = Vector3(seg1.p2.x, seg1.p2.y, 0)
-        val v2b = Vector3(seg2.p2.x, seg2.p2.y, 0)
-        math.min(
-          apply(v1a, seg2),
-          math.min(
-            apply(v1b, seg2),
-            math.min(
-              apply(v2a, seg1),
-              apply(v2b, seg1)
-            )
-          )
-        )
-      }
-    }
-
-    def apply(c1: Circle, c2 : Circle): Float = {
-      math.max(0, Vector3.Magnitude(Vector3(c1.p.x - c2.p.x, c1.p.y - c2.p.y, 0)) - c1.radius - c2.radius)
-    }
-
-    /**
-      * na
-      * @param line1 na
-      * @param line2 na
-      * @return the shortest distance between the lines;
-      *         if parallel, the common perpendicular distance between the lines;
-      *         if coincidental, this distance will be 0
-      */
-    def apply(line1: Line3D, line2: Line3D): Float = {
-      val cross = Vector3.CrossProduct(line1.d, line2.d)
-      if(cross != Vector3.Zero) {
-        math.abs(
-          Vector3.DotProduct(cross, Vector3(line1.p.x - line2.p.x, line1.p.y - line2.p.y, line1.p.z - line2.p.z))
-        ) / Vector3.Magnitude(cross)
-      } else {
-        // lines are parallel or coincidental
-        // construct a right triangle with one leg on line1 and the hypotenuse between the line's known points
-        val hypotenuse = Vector3(line2.p.x - line1.p.x, line2.p.y - line1.p.y, line2.p.z - line1.p.z)
-        val legOnLine1 = line1.d * Vector3.DotProduct(hypotenuse, line1.d)
-        Vector3.Magnitude(hypotenuse - legOnLine1)
-      }
-    }
-
-    def apply(seg1: Segment3D, seg2: Segment3D): Float = {
-      //TODO make not as expensive as finding the plotted closest distance segment
-      Segment(seg1, seg2) match {
-        case Some(seg) => seg.length
-        case None      => Float.MaxValue
-      }
-    }
-
-    def apply(s1: Sphere, s2 : Sphere): Float = {
-      math.max(0, Vector3.Magnitude(Vector3(s1.p.x - s2.p.x, s1.p.y - s2.p.y, s1.p.z - s2.p.z)) - s1.radius - s2.radius)
-    }
-  }
-
-  object Segment {
-    /**
-      * na
-      * @param c1 na
-      * @param c2 na
-      * @return a line segment that represents the closest distance between the circle's circumferences;
-      *         `None`, if the circles have no distance between them (overlapping)
-      */
-    def apply(c1 : Circle, c2 : Circle): Option[Segment2D] = {
-      val distance = Distance(c1, c2)
-      if (distance > 0) {
-        val c1x = c1.p.x
-        val c1y = c1.p.y
-        val v = Vector3.Unit(Vector3(c2.p.x - c1x, c2.p.y - c1y, 0f))
-        val c1d = v * c1.radius
-        val c2d = v * c2.radius
-        Some(
-          Segment2D(
-            c1x + c1d.x, c1y + c1d.y,
-            c1x + c2d.x, c1y + c2d.y,
-          )
-        )
-      } else {
-        None
-      }
-    }
-
-    /**
-      * na
-      * @param line1 na
-      * @param line2 na
-      * @return a line segment representing the closest distance between the two not intersecting lines;
-      *         in the case of parallel lines, one of infinite closest distances is plotted;
-      *         `None`, if the lines intersect with each other
-      */
-    def apply(line1 : Line3D, line2 : Line3D): Option[Segment3D] = {
-      val p1 = Vector3(line1.p.x, line1.p.y, line1.p.z)
-      val p3 = Vector3(line2.p.x, line2.p.y, line2.p.z)
-      val p13 = p1 - p3 // vector between point on first line and point on second line
-      val p43 = line2.d
-      val p21 = line1.d
-      if (Vector3.MagnitudeSquared(p43) < Float.MinPositiveValue ||
-          Vector3.MagnitudeSquared(p21) < Float.MinPositiveValue) {
-        None
-      } else {
-        val d2121 = Vector3.MagnitudeSquared(p21)
-        val d4343 = Vector3.MagnitudeSquared(p43)
-        val d4321 = Vector3.DotProduct(p43, p21)
-        val denom = d2121 * d4343 - d4321 * d4321 // n where d = (m/n) and a(x,y,z) + d * V<u,v,w> = b(x,y,z) for line1
-        if (math.abs(denom) < Float.MinPositiveValue) {
-          // without a denominator, we have no cross product solution
-          val p13u = Vector3.Unit(p13)
-          if (p21 == p13u || p21 == Vector3.neg(p13u)) { //coincidental lines overlap / intersect
-            None
-          } else { //parallel lines
-            val connecting = Vector3(line2.p.x - line1.p.x, line2.p.y - line1.p.y, line2.p.z - line1.p.z)
-            val legOnLine1 = line1.d * Vector3.DotProduct(connecting, line1.d)
-            val v = connecting - legOnLine1
-            Some(Segment3D(
-              line1.p.x, line1.p.y, line1.p.z,
-              line1.p.x + v.x, line1.p.y + v.y, line1.p.z + v.z
-            ))
-          }
-        } else {
-          val d1343 = Vector3.DotProduct(p13, p43)
-          val numer = d1343 * d4321 -d4343 * Vector3.DotProduct(p13, p21) // m where d = (m/n) and ..., etc.
-          val mua = numer / denom
-          val mub = (d1343 + d4321 * mua) / d4343
-          Some(Segment3D(
-            p1.x + mua * p21.x,
-            p1.y + mua * p21.y,
-            p1.z + mua * p21.z,
-            p3.x + mub * p43.x,
-            p3.y + mub * p43.y,
-            p3.z + mub * p43.z
-          ))
-        }
-      }
-    }
-
-    def apply(line1 : Segment3D, line2 : Segment3D): Option[Segment3D] = {
-      val uline1 =  Vector3.Unit(line1.d)
-      val uline2 =  Vector3.Unit(line2.d)
-      apply(Line3D(line1.p1.x, line1.p1.y, line1.p1.z, uline1), Line3D(line2.p1.x, line2.p1.y, line2.p1.z, uline2)) match {
-        case Some(seg: Segment3D) => // common skew lines and parallel lines
-          val sega = Vector3(seg.p1.x, seg.p1.y, seg.p1.z)
-          val p1 = Vector3(line1.p1.x, line1.p1.y, line1.p1.z)
-          val d1 = sega - p1
-          val out1 = if (!Geometry.equalVectors(Vector3.Unit(d1), uline1)) { //clamp seg.a(xyz) to segment line1's bounds
-            p1
-          } else if (Vector3.MagnitudeSquared(d1) > Vector3.MagnitudeSquared(line1.d)) {
-            Vector3(line1.p2.x, line1.p2.y, line1.p2.z)
-          } else {
-            sega
-          }
-          val segb = Vector3(seg.p2.x, seg.p2.y, seg.p2.z)
-          val p2 = Vector3(line2.p1.x, line2.p1.y, line2.p1.z)
-          val d2 = segb - p2
-          val out2 = if (!Geometry.equalVectors(Vector3.Unit(d2), uline2)) { //clamp seg.b(xyz) to segment line2's bounds
-            p2
-          } else if (Vector3.MagnitudeSquared(d2) > Vector3.MagnitudeSquared(line2.d)) {
-            Vector3(line2.p2.x, line2.p2.y, line2.p2.z)
-          } else {
-            segb
-          }
-          Some(Segment3D(
-            out1.x, out1.y, out1.z,
-            out2.x, out2.y, out2.z
-          ))
-        case None =>
-          val connectingU = Vector3.Unit(Vector3(line2.p1.x - line1.p1.x, line2.p1.y - line1.p1.y, line2.p1.z - line1.p1.z))
-          if (uline1 == connectingU || uline1 == Vector3.neg(connectingU)) { // coincidental line segments
-            val line1a = Vector3(line1.p1.x, line1.p1.y, line1.p1.z)
-            val line1b = Vector3(line1.p2.x, line1.p2.y, line1.p2.z)
-            val line2a = Vector3(line2.p1.x, line2.p1.y, line2.p1.z)
-            val line2b = Vector3(line2.p2.x, line2.p2.y, line2.p2.z)
-            if (Vector3.Unit(line2a - line1a) != Vector3.Unit(line2b - line1a) ||
-                Vector3.Unit(line2a - line1b) != Vector3.Unit(line2b - line1b) ||
-                Vector3.Unit(line1a - line2a) != Vector3.Unit(line1b - line2a) ||
-                Vector3.Unit(line1a - line2b) != Vector3.Unit(line1b - line2b)) {
-              Some(Segment3D(
-                line1.p1.x, line1.p1.y, line1a.z,
-                line1.p1.x, line1.p1.y, line1a.z
-              )) // overlap regions
-            }
-            else {
-              val segs = List((line1a, line2a), (line1a, line2b), (line2a, line1b))
-              val (a, b) = segs({
-                //val dist = segs.map { case (_a, _b) => Vector3.DistanceSquared(_a, _b) }
-                //dist.indexOf(dist.min)
-                var index = 0
-                var minDist = Vector3.DistanceSquared(segs.head._1, segs.head._2)
-                (1 to 2).foreach { i =>
-                  val dist = Vector3.DistanceSquared(segs(i)._1, segs(i)._2)
-                  if (minDist < dist) {
-                    index = i
-                    minDist = dist
-                  }
-                }
-                index
-              })
-              Some(Segment3D(a.x, a.y, a.z, b.x, b.y, b.z)) // connecting across the smallest gap
-            }
-          } else {
-            None
-          }
-      }
-    }
-
-    /**
-      * na
-      * @param s1 na
-      * @param s2 na
-      * @return a line segment that represents the closest distance between the sphere's surface areas;
-      *         `None`, if the spheres have no distance between them (overlapping)
-      */
-    def apply(s1 : Sphere, s2 : Sphere): Option[Segment3D] = {
-      val distance = Distance(s1, s2)
-      if (distance > 0) {
-        val s1x = s1.p.x
-        val s1y = s1.p.y
-        val s1z = s1.p.z
-        val v = Vector3.Unit(Vector3(s2.p.x - s1x, s2.p.y - s1y, s2.p.z - s1z))
-        val s1d = v * s1.radius
-        val s2d = v * (s1.radius + distance)
-        Some(Segment3D(s1x + s1d.x, s1y + s1d.y, s1y + s1d.y, s1x + s2d.x, s1y + s2d.y, s1y + s2d.y))
-      } else {
-        None
-      }
-    }
-
-    def apply(line : Line3D, sphere : Sphere): Option[Segment3D] = {
-      val sphereAsPoint = Vector3(sphere.p.x, sphere.p.y, sphere.p.z)
-      val lineAsPoint = Vector3(line.p.x, line.p.y, line.p.z)
-      val direct = sphereAsPoint - lineAsPoint
-      val projectionOfDirect = line.d * Vector3.DotProduct(direct, line.d)
-      val heightFromProjection = projectionOfDirect - direct
-      val heightFromProjectionDist = Vector3.Magnitude(heightFromProjection)
-      if (heightFromProjectionDist <= sphere.radius) { //intersection
-        None
-      } else {
-        val pointOnLine = lineAsPoint + projectionOfDirect
-        val pointOnSphere = pointOnLine +
-                            Vector3.Unit(heightFromProjection) * (heightFromProjectionDist - sphere.radius)
-        Some(Segment3D(
-          pointOnLine.x, pointOnLine.y, pointOnLine.z,
-          pointOnSphere.x, pointOnSphere.y, pointOnSphere.z
-        ))
-      }
-    }
-  }
-}
diff --git a/src/main/scala/net/psforever/objects/geometry/Geometry.scala b/src/main/scala/net/psforever/objects/geometry/Geometry.scala
index 3cd47c06..70ac40ec 100644
--- a/src/main/scala/net/psforever/objects/geometry/Geometry.scala
+++ b/src/main/scala/net/psforever/objects/geometry/Geometry.scala
@@ -3,229 +3,6 @@ package net.psforever.objects.geometry
 
 import net.psforever.types.Vector3
 
-trait PrimitiveGeometry {
-  def center: Point
-
-  def pointOnOutside(line: Line) : Point = pointOnOutside(line.d)
-
-  def pointOnOutside(v: Vector3) : Point
-}
-
-trait Geometry2D extends PrimitiveGeometry {
-  def center: Point2D
-
-  def pointOnOutside(v: Vector3): Point2D = center
-}
-
-trait Geometry3D extends PrimitiveGeometry {
-  def center: Point3D
-
-  def pointOnOutside(v: Vector3): Point3D = center
-}
-
-trait Point {
-  def asVector3: Vector3
-}
-
-trait Slope {
-  def d: Vector3
-
-  def length: Float
-}
-
-trait Line extends Slope {
-  assert({
-    val mag = Vector3.Magnitude(d)
-    mag - 0.05f < 1f && mag + 0.05f > 1f
-  }, "not a unit vector")
-
-  def p: Point
-
-  def length: Float = Float.PositiveInfinity
-}
-
-trait Segment extends Slope {
-  def p1: Point
-
-  def p2: Point
-
-  def length: Float = Vector3.Magnitude(d)
-
-  def asLine: PrimitiveGeometry
-}
-
-final case class Point2D(x: Float, y: Float) extends Geometry2D with Point {
-  def center: Point2D = this
-
-  def asVector3: Vector3 = Vector3(x, y, 0)
-}
-
-object Point2D {
-  def apply(): Point2D = Point2D(0, 0)
-
-  def apply(v: Vector3): Point2D = Point2D(v.x, v.y)
-}
-
-final case class Ray2D(p: Point2D, d: Vector3) extends Geometry2D with Line {
-  def center: Point2D = p
-}
-
-object Ray2D {
-  def apply(x: Float, y: Float, d: Vector3): Ray2D = Ray2D(Point2D(x, y), d)
-}
-
-final case class Line2D(p: Point2D, d: Vector3) extends Geometry2D with Line {
-  def center: Point2D = p
-}
-
-object Line2D {
-  def apply(ax: Float, ay: Float, d: Vector3): Line2D = {
-    Line2D(Point2D(ax, ay), d)
-  }
-
-  def apply(ax: Float, ay: Float, bx: Float, by: Float): Line2D = {
-    Line2D(Point2D(ax, ay), Vector3.Unit(Vector3(bx-ax, by-ay, 0)))
-  }
-
-  def apply(p1: Point2D, p2: Point2D): Line2D = {
-    Line2D(p1, Vector3.Unit(Vector3(p2.x-p1.x, p2.y-p1.y, 0)))
-  }
-}
-
-final case class Segment2D(p1: Point2D, p2: Point2D) extends Geometry2D with Segment {
-  def center: Point2D = Point2D(d * 0.5f)
-
-  def d: Vector3 = p2.asVector3 - p1.asVector3
-
-  def asLine: Line2D = Line2D(p1, Vector3.Unit(d))
-}
-
-object Segment2D {
-  def apply(ax: Float, ay: Float, bx: Float, by: Float): Segment2D = {
-    Segment2D(Point2D(ax, ay), Point2D(bx, by))
-  }
-
-  def apply(x: Float, y: Float, d: Vector3): Segment2D = {
-    Segment2D(x, y, x + d.x, y + d.y)
-  }
-}
-
-final case class Circle(p: Point2D, radius: Float) extends Geometry2D {
-  def center : Point2D = p
-
-  override def pointOnOutside(v: Vector3) : Point2D = {
-    val slope = Vector3.Unit(v)
-    val pointOnRim = p.asVector3 + slope * radius
-    Point2D(pointOnRim.x, pointOnRim.y)
-  }
-}
-
-object Circle {
-  def apply(radius: Float): Circle = Circle(Point2D(), radius)
-
-  def apply(x: Float, y: Float, radius: Float): Circle = Circle(Point2D(x, y), radius)
-}
-
-
-final case class Point3D(x: Float, y: Float, z: Float) extends Geometry3D with Point {
-  def center: Point3D = this
-
-  def asVector3: Vector3 = Vector3(x, y, z)
-}
-
-object Point3D {
-  def apply(): Point3D = Point3D(0,0,0)
-
-  def apply(v: Vector3): Point3D = Point3D(v.x, v.y, v.z)
-}
-
-final case class Ray3D(p: Point3D, d: Vector3) extends Geometry3D with Line {
-  def center: Point3D = p
-}
-
-object Ray3D {
-  def apply(x: Float, y: Float, z: Float, d: Vector3): Ray3D = Ray3D(Point3D(x,y,z), d)
-}
-
-final case class Line3D(p: Point3D, d: Vector3) extends Geometry3D with Line {
-  def center: Point3D = p
-}
-
-object Line3D {
-  def apply(x: Float, y: Float, z: Float, d: Vector3): Line3D = {
-    Line3D(Point3D(x,y,z), d)
-  }
-
-  def apply(ax: Float, ay: Float, az: Float, bx: Float, by: Float, bz: Float): Line3D = {
-    Line3D(Point3D(ax, ay, az), Vector3.Unit(Vector3(bx-ax, by-ay, bz-az)))
-  }
-
-  def apply(p1: Point3D, p2: Point3D): Line3D = {
-    Line3D(p1, Vector3.Unit(Vector3(p2.x-p1.x, p2.y-p1.y, p2.z-p1.z)))
-  }
-}
-
-final case class Segment3D(p1: Point3D, p2: Point3D) extends Geometry3D with Segment {
-  def center: Point3D = Point3D(d * 0.5f)
-
-  def d: Vector3 = p2.asVector3 - p1.asVector3
-
-  def asLine: Line3D = Line3D(p1, Vector3.Unit(d))
-}
-
-object Segment3D {
-  def apply(ax: Float, ay: Float, az: Float, bx: Float, by: Float, bz: Float): Segment3D = {
-    Segment3D(Point3D(ax, ay, az), Point3D(bx, by, bz))
-  }
-
-  def apply(x: Float, y: Float, z: Float, d: Vector3): Segment3D = {
-    Segment3D(Point3D(x, y, z), Point3D(x + d.x, y + d.y, z + d.z))
-  }
-}
-
-final case class Sphere(p: Point3D, radius: Float) extends Geometry3D {
-  def center: Point3D = p
-
-  override def pointOnOutside(v: Vector3): Point3D = {
-    val slope = Vector3.Unit(v)
-    val mult = radius / math.sqrt(slope.x * slope.x + slope.y * slope.y + slope.z * slope.z)
-    val pointOnSurface = center.asVector3 + slope * mult.toFloat
-    Point3D(pointOnSurface.x, pointOnSurface.y, pointOnSurface.z)
-  }
-}
-
-object Sphere {
-  def apply(radius: Float): Sphere = Sphere(Point3D(), radius)
-
-  def apply(x: Float, y: Float, z: Float, radius: Float): Sphere = Sphere(Point3D(x,y,z), radius)
-
-  def apply(v: Vector3, radius: Float): Sphere = Sphere(Point3D(v), radius)
-}
-
-final case class Cylinder(circle: Circle, z: Float, height: Float) extends Geometry3D {
-  def center: Point3D = Point3D(circle.p.x, circle.p.y, z + height * 0.5f)
-
-  override def pointOnOutside(v: Vector3): Point3D = {
-    val centerVector = center.asVector3
-    val slope = Vector3.Unit(v)
-    val mult = circle.radius / math.sqrt(slope.x * slope.x + slope.y * slope.y)
-    val pointOnRim = centerVector + slope * mult.toFloat
-    val point = if (z >= pointOnRim.z && pointOnRim.z <= height) { //side
-      pointOnRim
-    } else { //top or base
-      val rise = height * 0.5f / slope.z
-      centerVector + slope * rise
-    }
-    Point3D(point.x, point.y, point.z)
-  }
-}
-
-object Cylinder {
-  def apply(x: Float, y: Float, z: Float, radius: Float, height: Float): Cylinder = {
-    Cylinder(Circle(x, y, radius), z, height)
-  }
-}
-
 object Geometry {
   def equalFloats(value1: Float, value2: Float, off: Float = 0.001f): Boolean = {
     val diff = value1 - value2
diff --git a/src/main/scala/net/psforever/objects/geometry/GeometryForm.scala b/src/main/scala/net/psforever/objects/geometry/GeometryForm.scala
index 3b053916..8614163e 100644
--- a/src/main/scala/net/psforever/objects/geometry/GeometryForm.scala
+++ b/src/main/scala/net/psforever/objects/geometry/GeometryForm.scala
@@ -3,15 +3,13 @@ package net.psforever.objects.geometry
 
 import net.psforever.objects.ballistics.{PlayerSource, SourceEntry}
 import net.psforever.objects.{GlobalDefinitions, PlanetSideGameObject, Player}
-import net.psforever.types.ExoSuitType
+import net.psforever.types.{ExoSuitType, Vector3}
 
 object GeometryForm {
   /** this point can not be used for purposes of geometric representation */
   lazy val invalidPoint: Point3D     = Point3D(Float.MinValue, Float.MinValue, Float.MinValue)
-  /** this circle can not be used for purposes of geometric representation */
-  lazy val invalidCircle: Circle     = Circle(Point2D(invalidPoint.asVector3), 0)
   /** this cylinder can not be used for purposes of geometric representation */
-  lazy val invalidCylinder: Cylinder = Cylinder(invalidCircle, Float.MinValue, 0)
+  lazy val invalidCylinder: Cylinder = Cylinder(invalidPoint.asVector3, Vector3.Zero, Float.MinValue, 0)
 
   /**
     * The geometric representation is the entity's centroid.
@@ -27,21 +25,43 @@ object GeometryForm {
   }
 
   /**
-    * The geometric representation is the a sphere around the entity's centroid.
+    * The geometric representation is a sphere around the entity's centroid
+    * positioned following the axis of rotation (the entity's base).
     * @param radius how wide a hemisphere is
     * @param o the entity
     * @return the representation
     */
   def representBySphere(radius: Float)(o: Any): Geometry3D = {
     o match {
-      case p: PlanetSideGameObject => Sphere(p.Position, radius)
-      case s: SourceEntry          => Sphere(s.Position, radius)
-      case _                       => Sphere(invalidPoint, radius)
+      case p: PlanetSideGameObject =>
+        Sphere(p.Position, radius)
+      case s: SourceEntry          =>
+        Sphere(s.Position, radius)
+      case _                       =>
+        Sphere(invalidPoint, radius)
     }
   }
 
   /**
-    * The geometric representation is the a cylinder around the entity's base.
+    * The geometric representation is a sphere around the entity's centroid
+    * positioned following the axis of rotation (the entity's base).
+    * @param radius how wide a hemisphere is
+    * @param o the entity
+    * @return the representation
+    */
+  def representByRaisedSphere(radius: Float)(o: Any): Geometry3D = {
+    o match {
+      case p: PlanetSideGameObject =>
+        Sphere(p.Position + Vector3.relativeUp(p.Orientation) * radius, radius)
+      case s: SourceEntry          =>
+        Sphere(s.Position + Vector3.relativeUp(s.Orientation) * radius, radius)
+      case _                       =>
+        Sphere(invalidPoint, radius)
+    }
+  }
+
+  /**
+    * The geometric representation is a cylinder around the entity's base.
     * @param radius half the distance across
     * @param height how tall the cylinder is (the distance of the top to the base)
     * @param o the entity
@@ -49,14 +69,14 @@ object GeometryForm {
     */
   def representByCylinder(radius: Float, height: Float)(o: Any): Geometry3D = {
     o match {
-      case p: PlanetSideGameObject => Cylinder(Circle(p.Position.x, p.Position.y, radius), p.Position.z, height)
-      case s: SourceEntry          => Cylinder(Circle(s.Position.x, s.Position.y, radius), s.Position.z, height)
+      case p: PlanetSideGameObject => Cylinder(p.Position, Vector3.relativeUp(p.Orientation), radius, height)
+      case s: SourceEntry          => Cylinder(s.Position, Vector3.relativeUp(s.Orientation), radius, height)
       case _                       => invalidCylinder
     }
   }
 
   /**
-    * The geometric representation is the a cylinder around the entity's base
+    * The geometric representation is a cylinder around the entity's base
     * if the target represents a player entity.
     * @param radius a measure of the player's bulk
     * @param o the entity
@@ -67,16 +87,17 @@ object GeometryForm {
       case p: Player =>
         val radialOffset = if(p.ExoSuit == ExoSuitType.MAX) 0.25f else 0f
         Cylinder(
-          Circle(p.Position.x, p.Position.y, radius + radialOffset),
-          p.Position.z,
+          p.Position,
+          radius + radialOffset,
           GlobalDefinitions.MaxDepth(p)
         )
       case p: PlayerSource =>
-        val radialOffset = if(p.ExoSuit == ExoSuitType.MAX) 0.25f else 0f
+        val radialOffset = if(p.ExoSuit == ExoSuitType.MAX) 0.125f else 0f
+        val heightOffset = if(p.crouching) 1.093750f else GlobalDefinitions.avatar.MaxDepth
         Cylinder(
-          Circle(p.Position.x, p.Position.y, radius + radialOffset),
-          p.Position.z,
-          GlobalDefinitions.avatar.MaxDepth
+          p.Position,
+          radius + radialOffset,
+          heightOffset
         )
       case _ =>
         invalidCylinder
@@ -84,7 +105,7 @@ object GeometryForm {
   }
 
   /**
-    * The geometric representation is the a cylinder around the entity's base
+    * The geometric representation is a cylinder around the entity's base
     * as if the target is displaced from the ground at an expected (fixed?) distance.
     * @param radius half the distance across
     * @param height how tall the cylinder is (the distance of the top to the base)
@@ -95,17 +116,9 @@ object GeometryForm {
   def representHoveringEntityByCylinder(radius: Float, height: Float, hoversAt: Float)(o: Any): Geometry3D = {
     o match {
       case p: PlanetSideGameObject =>
-        Cylinder(
-          Circle(p.Position.x, p.Position.y, radius),
-          p.Position.z + hoversAt,
-          height
-        )
+        Cylinder(p.Position, Vector3.relativeUp(p.Orientation), radius, height)
       case s: SourceEntry =>
-        Cylinder(
-          Circle(s.Position.x, s.Position.y, radius),
-          s.Position.z + hoversAt,
-          height
-        )
+        Cylinder(s.Position, Vector3.relativeUp(s.Orientation), radius, height)
       case _ =>
         invalidCylinder
     }
diff --git a/src/main/scala/net/psforever/objects/geometry/Intersection.scala b/src/main/scala/net/psforever/objects/geometry/Intersection.scala
deleted file mode 100644
index cda1f31c..00000000
--- a/src/main/scala/net/psforever/objects/geometry/Intersection.scala
+++ /dev/null
@@ -1,158 +0,0 @@
-// Copyright (c) 2021 PSForever
-package net.psforever.objects.geometry
-
-import net.psforever.types.Vector3
-
-object Intersection {
-  object Test {
-    /**
-      * Do these two lines intersect?
-      * Lines in 2D space will always intersect unless they are parallel or antiparallel.
-      * In that case, however, they can still "intersect" if provided that the lines are coincidental.
-      */
-    def apply(line1: Line2D, line2: Line2D): Boolean = {
-      line1.d != line2.d || {
-        //parallel or antiparallel?
-        val u = Vector3.Unit(Vector3(line2.p.x - line1.p.x, line2.p.y - line1.p.y, 0))
-        u == Vector3.Zero || line1.d == u || line1.d == Vector3.neg(u)
-      }
-    }
-
-    private def pointOnSegment(ax: Float, ay: Float, px: Float, py: Float, bx: Float, by: Float): Boolean = {
-      px <= math.max(ax, bx) && px >= math.min(ax, bx) && py <= math.max(ay, by) && py >= math.min(ay, by)
-    }
-
-    object PointTripleOrientation extends Enumeration {
-      val Colinear, Clockwise, Counterclockwise = Value
-    }
-
-    /**
-      * Determine the orientation of the given three two-dimensional points.
-      * Any triple has one of three orientations:
-      * clockwise - the third point is to the right side of a line plotted by the first two points;
-      * counterclockwise - the third point is to the left side of a line plotted by the first two points;
-      * and, colinear - the third point is reachable along the line plotted by the first two points.
-      * @param ax x-coordinate of the first point
-      * @param ay y-coordinate of the first point
-      * @param px x-coordinate of the second point
-      * @param py y-coordinate of the second point
-      * @param bx x-coordinate of the third point
-      * @param by y-coordinate of the third point
-      * @return the orientation value
-      */
-    private def orientationOfPoints(
-                                     ax: Float, ay: Float,
-                                     px: Float, py: Float,
-                                     bx: Float, by: Float
-                                   ): PointTripleOrientation.Value = {
-      val out = (py - ay) * (bx - px) - (px - ax) * (by - py)
-      if (out == 0) PointTripleOrientation.Colinear
-      else if (out > 0) PointTripleOrientation.Clockwise
-      else PointTripleOrientation.Counterclockwise
-    }
-
-    /**
-      * Do these two line segments intersect?
-      * Intersection of two two-dimensional line segments can be determined by the orientation of their endpoints.
-      * If a test of multiple ordered triple points reveals that certain triples have different orientations,
-      * then we can safely assume the intersection state of the segments.
-      */
-    def apply(line1: Segment2D, line2: Segment2D): Boolean = {
-      //setup
-      val ln1ax = line1.p1.x
-      val ln1ay = line1.p1.y
-      val ln1bx = line1.p2.x
-      val ln1by = line1.p2.y
-      val ln2ax = line2.p1.x
-      val ln2ay = line2.p1.y
-      val ln2bx = line2.p2.x
-      val ln2by = line2.p2.y
-      val ln1_ln2a = orientationOfPoints(ln1ax, ln1ay, ln1bx, ln1by, ln2ax, ln2ay)
-      val ln1_ln2b = orientationOfPoints(ln1ax, ln1ay, ln1bx, ln1by, ln2bx, ln2by)
-      val ln2_ln1a = orientationOfPoints(ln2ax, ln2ay, ln2bx, ln2by, ln1ax, ln1ay)
-      val ln2_ln1b = orientationOfPoints(ln2ax, ln2ay, ln2bx, ln2by, ln1bx, ln1by)
-      //results
-      import PointTripleOrientation._
-      (ln1_ln2a != ln1_ln2b && ln2_ln1a != ln2_ln1b) ||
-      (ln1_ln2a == Colinear && pointOnSegment(ln1ax, ln1ay, ln2ax, ln2ay, ln1bx, ln1by)) || // line2 A is on line1
-      (ln1_ln2b == Colinear && pointOnSegment(ln1ax, ln1ay, ln2bx, ln2by, ln1bx, ln1by)) || // line2 B is on line1
-      (ln2_ln1a == Colinear && pointOnSegment(ln2ax, ln2ay, ln1ax, ln1ay, ln2bx, ln2by)) || // line1 A is on line2
-      (ln2_ln1b == Colinear && pointOnSegment(ln2ax, ln2ay, ln1bx, ln1by, ln2bx, ln2by))    // line1 B is on line2
-    }
-
-    /**
-      * Do these two lines intersect?
-      * Actual mathematically-sound intersection between lines and line segments in 3D-space is terribly uncommon.
-      * Instead, check that the closest distance between two line segments is below a threshold value.
-      */
-    def apply(line1: Line3D, line2: Line3D): Boolean = {
-      apply(line1, line2, 0.15f)
-    }
-    def apply(line1: Line3D, line2: Line3D, threshold: Float): Boolean = {
-      Closest.Distance(line1, line2) < threshold
-    }
-
-    def apply(c1: Circle, c2 : Circle): Boolean = {
-      Vector3.Magnitude(Vector3(c1.p.x - c2.p.x, c1.p.y - c2.p.y, 0)) <= c1.radius + c2.radius
-    }
-
-    /**
-      * Do these two line segments intersect?
-      * Actual mathematically-sound intersection between lines and line segments in 3D-space is terribly uncommon.
-      * Instead, check that the closest distance between two line segments is below a threshold value.
-      */
-    def apply(seg1: Segment3D, seg2: Segment3D): Boolean = {
-      apply(seg1, seg2, 0.15f)
-    }
-    def apply(seg1: Segment3D, seg2: Segment3D, threshold: Float): Boolean = {
-      Closest.Distance(seg1, seg2) < threshold
-    }
-
-    def apply(s1: Sphere, s2 : Sphere): Boolean = {
-      Vector3.Magnitude(
-        Vector3(
-          s1.p.x - s2.p.x,
-          s1.p.y - s2.p.y,
-          s1.p.z - s2.p.z
-        )
-      ) <= s1.radius + s2.radius
-    }
-
-    def apply(c1: Cylinder, c2: Cylinder): Boolean = {
-      apply(c1.circle, c2.circle) &&
-      ((c1.height >= c2.z && c1.z <= c2.height) || (c2.height >= c1.z && c2.z <= c1.height))
-    }
-
-    def apply(cylinder: Cylinder, sphere: Sphere): Boolean = {
-      val cylinderCircle = cylinder.circle
-      val cylinderCircleRadius = cylinderCircle.radius
-      val cylinderTop = cylinder.z + cylinder.height
-      val sphereRadius = sphere.radius
-      val sphereBase = sphere.p.z - sphereRadius
-      val sphereTop = sphere.p.z + sphereRadius
-      if (apply(cylinderCircle, Circle(sphere.p.x, sphere.p.y, sphereRadius)) &&
-          ((sphereTop >= cylinder.z && sphereBase <= cylinderTop) ||
-           (cylinderTop >= sphereBase && cylinder.z <= sphereTop))) {
-        // potential intersection ...
-        val sphereAsPoint = Vector3(sphere.p.x, sphere.p.y, sphere.p.z)
-        val cylinderAsPoint = Vector3(cylinderCircle.p.x, cylinderCircle.p.y, cylinder.z)
-        val segmentFromCylinderToSphere = sphereAsPoint - cylinderAsPoint
-        val segmentFromCylinderToSphereXY = segmentFromCylinderToSphere.xy
-        if ((cylinder.z <= sphere.p.z && sphere.p.z <= cylinderTop) ||
-            Vector3.MagnitudeSquared(segmentFromCylinderToSphereXY) <= cylinderCircleRadius * cylinderCircleRadius) {
-          true // top or bottom of sphere, or widest part of the sphere, must interact with the cylinder
-        } else {
-          // only option left is the curves of the sphere interacting with the cylinder's rim, top or base
-          val directionFromCylinderToSphere = Vector3.Unit(segmentFromCylinderToSphereXY)
-          val pointOnCylinderRimBase = cylinderAsPoint + directionFromCylinderToSphere * cylinderCircleRadius
-          val pointOnCylinderRimTop = pointOnCylinderRimBase + Vector3.z(cylinder.height)
-          val sqSphereRadius = sphereRadius * sphereRadius
-          Vector3.DistanceSquared(sphereAsPoint, pointOnCylinderRimTop) <= sqSphereRadius ||
-          Vector3.DistanceSquared(sphereAsPoint, pointOnCylinderRimBase) <= sqSphereRadius
-        }
-      } else {
-        false
-      }
-    }
-  }
-}
diff --git a/src/main/scala/net/psforever/objects/geometry/PrimitiveShape.scala b/src/main/scala/net/psforever/objects/geometry/PrimitiveShape.scala
new file mode 100644
index 00000000..5aef779f
--- /dev/null
+++ b/src/main/scala/net/psforever/objects/geometry/PrimitiveShape.scala
@@ -0,0 +1,165 @@
+// Copyright (c) 2021 PSForever
+package net.psforever.objects.geometry
+
+import net.psforever.types.Vector3
+
+trait PrimitiveGeometry {
+  def center: Point
+
+  def pointOnOutside(line: Line) : Point = pointOnOutside(line.d)
+
+  def pointOnOutside(v: Vector3) : Point
+}
+
+//trait Geometry2D extends PrimitiveGeometry {
+//  def center: Point2D
+//
+//  def pointOnOutside(v: Vector3): Point2D = center
+//}
+
+trait Geometry3D extends PrimitiveGeometry {
+  def center: Point3D
+
+  def pointOnOutside(v: Vector3): Point3D = center
+}
+
+trait Point {
+  def asVector3: Vector3
+}
+
+trait Slope {
+  def d: Vector3
+
+  def length: Float
+}
+
+trait Line extends Slope {
+  assert({
+    val mag = Vector3.Magnitude(d)
+    mag - 0.05f < 1f && mag + 0.05f > 1f
+  }, "not a unit vector")
+
+  def p: Point
+
+  def length: Float = Float.PositiveInfinity
+}
+
+trait Segment extends Slope {
+  def p1: Point
+
+  def p2: Point
+
+  def length: Float = Vector3.Magnitude(d)
+
+  def asLine: PrimitiveGeometry
+}
+
+final case class Point3D(x: Float, y: Float, z: Float) extends Geometry3D with Point {
+  def center: Point3D = this
+
+  def asVector3: Vector3 = Vector3(x, y, z)
+}
+
+object Point3D {
+  def apply(): Point3D = Point3D(0,0,0)
+
+  def apply(v: Vector3): Point3D = Point3D(v.x, v.y, v.z)
+}
+
+final case class Ray3D(p: Point3D, d: Vector3) extends Geometry3D with Line {
+  def center: Point3D = p
+}
+
+object Ray3D {
+  def apply(x: Float, y: Float, z: Float, d: Vector3): Ray3D = Ray3D(Point3D(x,y,z), d)
+}
+
+final case class Line3D(p: Point3D, d: Vector3) extends Geometry3D with Line {
+  def center: Point3D = p
+}
+
+object Line3D {
+  def apply(x: Float, y: Float, z: Float, d: Vector3): Line3D = {
+    Line3D(Point3D(x,y,z), d)
+  }
+
+  def apply(ax: Float, ay: Float, az: Float, bx: Float, by: Float, bz: Float): Line3D = {
+    Line3D(Point3D(ax, ay, az), Vector3.Unit(Vector3(bx-ax, by-ay, bz-az)))
+  }
+
+  def apply(p1: Point3D, p2: Point3D): Line3D = {
+    Line3D(p1, Vector3.Unit(Vector3(p2.x-p1.x, p2.y-p1.y, p2.z-p1.z)))
+  }
+}
+
+final case class Segment3D(p1: Point3D, p2: Point3D) extends Geometry3D with Segment {
+  def center: Point3D = Point3D(d * 0.5f)
+
+  def d: Vector3 = p2.asVector3 - p1.asVector3
+
+  def asLine: Line3D = Line3D(p1, Vector3.Unit(d))
+}
+
+object Segment3D {
+  def apply(ax: Float, ay: Float, az: Float, bx: Float, by: Float, bz: Float): Segment3D = {
+    Segment3D(Point3D(ax, ay, az), Point3D(bx, by, bz))
+  }
+
+  def apply(x: Float, y: Float, z: Float, d: Vector3): Segment3D = {
+    Segment3D(Point3D(x, y, z), Point3D(x + d.x, y + d.y, z + d.z))
+  }
+}
+
+final case class Sphere(p: Point3D, radius: Float) extends Geometry3D {
+  def center: Point3D = p
+
+  override def pointOnOutside(v: Vector3): Point3D = {
+    val slope = Vector3.Unit(v)
+    val mult = radius / math.sqrt(slope.x * slope.x + slope.y * slope.y + slope.z * slope.z)
+    val pointOnSurface = center.asVector3 + slope * mult.toFloat
+    Point3D(pointOnSurface.x, pointOnSurface.y, pointOnSurface.z)
+  }
+}
+
+object Sphere {
+  def apply(radius: Float): Sphere = Sphere(Point3D(), radius)
+
+  def apply(x: Float, y: Float, z: Float, radius: Float): Sphere = Sphere(Point3D(x,y,z), radius)
+
+  def apply(v: Vector3, radius: Float): Sphere = Sphere(Point3D(v), radius)
+}
+
+final case class Cylinder(position: Vector3, relativeUp: Vector3, radius: Float, height: Float) extends Geometry3D {
+  def center: Point3D = Point3D(position + relativeUp * height * 0.5f)
+
+  override def pointOnOutside(v: Vector3): Point3D = {
+    val centerVector = center.asVector3
+    val slope = Vector3.Unit(v)
+    val acrossTopAndBase = slope - relativeUp
+    val pointOnSide = centerVector + slope * (radius / Vector3.Magnitude(acrossTopAndBase))
+    val pointOnBase = position + acrossTopAndBase * radius
+    val pointOnTop = pointOnBase + relativeUp * height
+    val fromPointOnTopToSide = Vector3.Unit(pointOnTop - pointOnSide)
+    val fromPointOnSideToBase = Vector3.Unit(pointOnSide - pointOnBase)
+    val target = if(fromPointOnTopToSide  == Vector3.Zero ||
+                    fromPointOnSideToBase == Vector3.Zero ||
+                    Geometry.equalVectors(fromPointOnTopToSide, fromPointOnSideToBase)) {
+      //on side, including top rim or base rim
+      pointOnSide
+    } else {
+      //on top or base
+      // the full equation would be 'centerVector + slope * (height * 0.5f / Vector3.Magnitude(relativeUp))'
+      // 'relativeUp` is already a unit vector (magnitude of 1)
+      centerVector + slope * height * 0.5f
+    }
+    Point3D(target)
+  }
+}
+
+object Cylinder {
+  def apply(v: Vector3, radius: Float, height: Float): Cylinder = Cylinder(v, Vector3(0,0,1), radius, height)
+
+  def apply(p: Point3D, radius: Float, height: Float): Cylinder = Cylinder(p.asVector3, Vector3(0,0,1), radius, height)
+
+  def apply(p: Point3D, v: Vector3, radius: Float, height: Float): Cylinder = Cylinder(p.asVector3, v, radius, height)
+}
diff --git a/src/main/scala/net/psforever/objects/zones/Zone.scala b/src/main/scala/net/psforever/objects/zones/Zone.scala
index b61a414f..66d2e1b3 100644
--- a/src/main/scala/net/psforever/objects/zones/Zone.scala
+++ b/src/main/scala/net/psforever/objects/zones/Zone.scala
@@ -1135,7 +1135,7 @@ object Zone {
               .flatMap { _.Amenities }
               .filter { _.Definition.Damageable }
         }
-        //restrict to targets in the damage radius
+        //restrict to targets according to the detection plan
         val allAffectedTargets = (playerTargets ++ vehicleTargets ++ complexDeployableTargets ++ soiTargets)
           .filter { target =>
             (target ne obj) && detectionTest(obj, target, radius)
@@ -1177,11 +1177,11 @@ object Zone {
     * A default function literal mainly used for `causesExplosion`.
     * @see `causeExplosion`
     * @see `ObjectDefinition.Geometry`
-    * @param obj1 a game entity
-    * @param obj2 a game entity
+    * @param obj1 a game entity, should be the source of the explosion
+    * @param obj2 a game entity, should be the target of the explosion
     * @param maxDistance the square of the maximum distance permissible between game entities
     *                    before they are no longer considered "near"
-    * @return `true`, if the target entities are near to each other;
+    * @return `true`, if the target entities are near enough to each other;
     *        `false`, otherwise
     */
   def distanceCheck(obj1: PlanetSideGameObject, obj2: PlanetSideGameObject, maxDistance: Float): Boolean = {
@@ -1193,7 +1193,7 @@ object Zone {
     * @param g2 the geometric representation of a game entity
     * @param maxDistance    the square of the maximum distance permissible between game entities
     *                       before they are no longer considered "near"
-    * @return `true`, if the target entities are near to each other;
+    * @return `true`, if the target entities are near enough to each other;
     *        `false`, otherwise
     */
   def distanceCheck(g1: Geometry3D, g2: Geometry3D, maxDistance: Float): Boolean = {
diff --git a/src/main/scala/net/psforever/types/Vector3.scala b/src/main/scala/net/psforever/types/Vector3.scala
index e008c7a2..76fecca4 100644
--- a/src/main/scala/net/psforever/types/Vector3.scala
+++ b/src/main/scala/net/psforever/types/Vector3.scala
@@ -387,8 +387,8 @@ object Vector3 {
 
   /**
     * Given a `Vector3` element composed of Euler angles
-    * and a `Vector3` element in the direction of "up",
-    * find a standard unit vector that points in the direction of "up" after rotating by the Euler angles.
+    * and a `Vector3` element in the vector direction of "up",
+    * find a standard unit vector that points in the direction of the entity's "up" after rotating by the Euler angles.
     * Compass direction rules apply (North is 0 degrees, East is 90 degrees, etc.).
     * @see `Vector3.Rx(Float)`
     * @see `Vector3.Ry(Float)`
@@ -398,7 +398,12 @@ object Vector3 {
     * @return a mathematical vector representing a relative "up" direction
     */
   def relativeUp(orient: Vector3, up: Vector3): Vector3 = {
-    //TODO is the missing calculation before Rz(Rx(Ry(v, x), y), z) or after Rz(Ry(Rx(v, y), x), z)?
-    Rz(Rx(up, orient.y), (orient.z + 180) % 360f)
+    /*
+    rotate in Ry using the x-component and rotate in Rx using the y-component
+    only Rz is rotated using its corresponding component, and you add 180 clamping to 0-360 degrees
+    I'm sure mathematicians know what's going on here, but I don't
+    the purpose of this comment is to make certain that the future me knows that all this is not a mistake
+     */
+    Rz(Rx(Ry(Unit(up), orient.x), orient.y), (orient.z + 180) % 360f)
   }
 }
diff --git a/src/test/scala/Vector3Test.scala b/src/test/scala/Vector3Test.scala
index ef39a2bb..38cb36f9 100644
--- a/src/test/scala/Vector3Test.scala
+++ b/src/test/scala/Vector3Test.scala
@@ -257,18 +257,62 @@ class Vector3Test extends Specification {
 
     "find a relative up (y-rot)" in {
       Vector3.relativeUp(Vector3(0, 0, 0)) mustEqual Vector3(0,0,1) //up
-      Vector3.relativeUp(Vector3(0, 90, 0)) mustEqual Vector3(0,-1,0) //north
+      Vector3.relativeUp(Vector3(0, 90, 0)) mustEqual Vector3(0,-1,0) //south
       Vector3.relativeUp(Vector3(0, 180, 0)) mustEqual Vector3(0,0,-1) //down
-      Vector3.relativeUp(Vector3(0, 270, 0)) mustEqual Vector3(0,1,0) //south
+      Vector3.relativeUp(Vector3(0, 270, 0)) mustEqual Vector3(0,1,0) //north
       Vector3.relativeUp(Vector3(0, 360, 0)) mustEqual Vector3(0,0,1) //up
     }
 
+    "find a relative up (x-rot)" in {
+      Vector3.relativeUp(Vector3(0, 0, 0)) mustEqual Vector3(0,0,1) //up
+      Vector3.relativeUp(Vector3(90, 0, 0)) mustEqual Vector3(-1,0,0) //west
+      Vector3.relativeUp(Vector3(180, 0, 0)) mustEqual Vector3(0,0,-1) //down
+      Vector3.relativeUp(Vector3(270, 0, 0)) mustEqual Vector3(1,0,0) //east
+      Vector3.relativeUp(Vector3(360, 0, 0)) mustEqual Vector3(0,0,1) //up
+    }
+
     "find a relative up (combined y,z)" in {
       Vector3.relativeUp(Vector3(0, 0, 90)) mustEqual Vector3(0,0,1) //up
       Vector3.relativeUp(Vector3(0, 90, 90)) mustEqual Vector3(-1,0,0) //west
       Vector3.relativeUp(Vector3(0, 180, 90)) mustEqual Vector3(0,0,-1) //down
       Vector3.relativeUp(Vector3(0, 270, 90)) mustEqual Vector3(1,0,0) //east
       Vector3.relativeUp(Vector3(0, 360, 90)) mustEqual Vector3(0,0,1) //up
+
+      Vector3.relativeUp(Vector3(0, 90, 180)) mustEqual Vector3(0,1,0) //north
+      Vector3.relativeUp(Vector3(0, 180, 180)) mustEqual Vector3(0,0,-1) //down
+      Vector3.relativeUp(Vector3(0, 270, 180)) mustEqual Vector3(0,-1,0) //south
+      Vector3.relativeUp(Vector3(0, 360, 180)) mustEqual Vector3(0,0,1) //up
+
+      Vector3.relativeUp(Vector3(0, 90, 270)) mustEqual Vector3(1,0,0) //east
+      Vector3.relativeUp(Vector3(0, 180, 270)) mustEqual Vector3(0,0,-1) //down
+      Vector3.relativeUp(Vector3(0, 270, 270)) mustEqual Vector3(-1,0,0) //west
+      Vector3.relativeUp(Vector3(0, 360, 270)) mustEqual Vector3(0,0,1) //up
+    }
+
+    "find a relative up (combined x,z)" in {
+      Vector3.relativeUp(Vector3(0, 0, 90)) mustEqual Vector3(0,0,1) //up
+      Vector3.relativeUp(Vector3(90, 0, 90)) mustEqual Vector3(0,-1,0) //south
+      Vector3.relativeUp(Vector3(180, 0, 90)) mustEqual Vector3(0,0,-1) //down
+      Vector3.relativeUp(Vector3(270, 0, 90)) mustEqual Vector3(0,1,0) //north
+      Vector3.relativeUp(Vector3(360, 0, 90)) mustEqual Vector3(0,0,1) //up
+
+      Vector3.relativeUp(Vector3(90, 0, 180)) mustEqual Vector3(1,0,0) //east
+      Vector3.relativeUp(Vector3(180, 0, 180)) mustEqual Vector3(0,0,-1) //down
+      Vector3.relativeUp(Vector3(270, 0, 180)) mustEqual Vector3(-1,0,0) //west
+      Vector3.relativeUp(Vector3(360, 0, 180)) mustEqual Vector3(0,0,1) //up
+
+      Vector3.relativeUp(Vector3(90, 0, 270)) mustEqual Vector3(0,1,0) //north
+      Vector3.relativeUp(Vector3(180, 0, 270)) mustEqual Vector3(0,0,-1) //down
+      Vector3.relativeUp(Vector3(270, 0, 270)) mustEqual Vector3(0,-1,0) //south
+      Vector3.relativeUp(Vector3(360, 0, 270)) mustEqual Vector3(0,0,1) //up
+    }
+
+    "find a relative up (combined x,y)" in {
+      val south = Vector3(0,-1,0)
+      Vector3.relativeUp(Vector3(0, 90, 0)) mustEqual Vector3(0,-1,0) //south
+      Vector3.relativeUp(Vector3(90, 90, 0)) mustEqual Vector3(-1,0,0) //west
+      Vector3.relativeUp(Vector3(180, 90, 0)) mustEqual Vector3(0,1,0) //north
+      Vector3.relativeUp(Vector3(270, 90, 0)) mustEqual Vector3(1,0,0) //east
     }
   }
 }
diff --git a/src/test/scala/objects/GeometryTest.scala b/src/test/scala/objects/GeometryTest.scala
deleted file mode 100644
index ea782da9..00000000
--- a/src/test/scala/objects/GeometryTest.scala
+++ /dev/null
@@ -1,533 +0,0 @@
-// Copyright (c) 2020 PSForever
-package objects
-
-import net.psforever.objects.geometry._
-import net.psforever.types.Vector3
-import org.specs2.mutable.Specification
-
-class IntersectionTest extends Specification {
-  "Line2D" should {
-    "detect intersection on target points(s)" in {
-      //these lines intersect at (0, 0)
-      val result = Intersection.Test(
-        Line2D(0,0, 1,0),
-        Line2D(0,0, 0,1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection on a target point" in {
-      //these lines intersect at (0, 0); start of segment 1, middle of segment 2
-      val result = Intersection.Test(
-        Line2D( 0,0, 0,1),
-        Line2D(-1,0, 1,0)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection anywhere else" in {
-      //these lines intersect at (0.5f, 0.5f)
-      val result = Intersection.Test(
-        Line2D(0,0, 1,1),
-        Line2D(1,0, 0,1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection anywhere else (2)" in {
-      //these lines intersect at (0, 0.5)
-      val result = Intersection.Test(
-        Line2D(0,   0, 1,    0),
-        Line2D(0.5f,1, 0.5f,-1)
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection if the lines are parallel" in {
-      val result = Intersection.Test(
-        Line2D(0,0, 1,1),
-        Line2D(1,0, 2,1)
-      )
-      result mustEqual false
-    }
-
-    "detect intersection if the lines overlap" in {
-      //the lines are coincidental
-      val result = Intersection.Test(
-        Line2D(0,0, 1,1),
-        Line2D(1,1, 2,2)
-      )
-      result mustEqual true
-    }
-  }
-
-  "Segment2D" should {
-    "detect intersection on target points(s)" in {
-      //these line segments intersect at (0, 0)
-      val result = Intersection.Test(
-        Segment2D(0,0, 1,0),
-        Segment2D(0,0, 0,1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection on a target point" in {
-      //these line segments intersect at (0, 0); start of segment 1, middle of segment 2
-      val result = Intersection.Test(
-        Segment2D( 0,0, 0,1),
-        Segment2D(-1,0, 1,0)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection anywhere else" in {
-      //these line segments intersect at (0.5f, 0.5f)
-      val result = Intersection.Test(
-        Segment2D(0,0, 1,1),
-        Segment2D(1,0, 0,1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection anywhere else (2)" in {
-      //these line segments intersect at (0, 0.5)
-      val result = Intersection.Test(
-        Segment2D(0,   0, 1,    0),
-        Segment2D(0.5f,1, 0.5f,-1)
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection if the lines are parallel" in {
-      val result = Intersection.Test(
-        Segment2D(0,0, 1,1),
-        Segment2D(1,0, 2,1)
-      )
-      result mustEqual false
-    }
-
-    "detect intersection if the lines overlap" in {
-      //the lines are coincidental
-      val result = Intersection.Test(
-        Line2D(0,0, 1,1),
-        Line2D(1,1, 2,2)
-      )
-      result mustEqual true
-    }
-  }
-
-  "Circle" should {
-    "intersect when overlapping (coincidental)" in {
-      val result = Intersection.Test(
-        Circle(0,0, 1),
-        Circle(0,0, 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when overlapping (engulfed)" in {
-      val result = Intersection.Test(
-        Circle(0,0, 2),
-        Circle(1,0, 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when overlapping (partial 1)" in {
-      val result = Intersection.Test(
-        Circle(0,0, 2),
-        Circle(2,0, 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when overlapping (partial 2)" in {
-      val result = Intersection.Test(
-        Circle(0,   0, 2),
-        Circle(2.5f,0, 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when the circumferences are touching" in {
-      val result = Intersection.Test(
-        Circle(0,0, 2),
-        Circle(3,0, 1)
-      )
-      result mustEqual true
-    }
-
-    "not intersect when not touching" in {
-      val result = Intersection.Test(
-        Circle(0,0, 2),
-        Circle(4,0, 1)
-      )
-      result mustEqual false
-    }
-  }
-
-  "Line3D" should {
-    "detect intersection on target point(s)" in {
-      //these lines intersect at (0, 0, 0)
-      val result = Intersection.Test(
-        Line3D(0,0,0, Vector3(1,0,0)),
-        Line3D(0,0,0, Vector3(0,1,0))
-      )
-      result mustEqual true
-    }
-
-    "detect intersection on a target point" in {
-      //these lines intersect at (0, 0, 0); start of segment 1, middle of segment 2
-      val result = Intersection.Test(
-        Line3D(0,0,0, Vector3(0,1,0)),
-        Line3D(-1,0,0, Vector3(1,0,0))
-      )
-      result mustEqual true
-    }
-
-    "detect intersection anywhere else" in {
-      //these lines intersect at (0.5f, 0.5f, 0)
-      val result = Intersection.Test(
-        Line3D(0,0,0, Vector3.Unit(Vector3(1, 1, 0))),
-        Line3D(1,0,0, Vector3(0,1,0))
-      )
-      result mustEqual true
-    }
-
-    "detect intersection anywhere else (2)" in {
-      //these lines intersect at (0, 0.5, 0)
-      val result = Intersection.Test(
-        Line3D(0,0,0, Vector3(1,0,0)),
-        Line3D(0.5f,1,0, Vector3.Unit(Vector3(0.5f,-1,0)))
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection if the lines are parallel" in {
-      val result = Intersection.Test(
-        Line3D(0,0,0, Vector3.Unit(Vector3(1,1,1))),
-        Line3D(1,1,2, Vector3.Unit(Vector3(1,1,1)))
-      )
-      result mustEqual false
-    }
-
-    "detect intersection if the lines overlap" in {
-      //the sub-segment (1,0,0) to (2,0,0) is an overlap region shared between the two segments
-      val result = Intersection.Test(
-        Line3D(0,0,0, Vector3.Unit(Vector3(2,0,0))),
-        Line3D(1,0,0, Vector3.Unit(Vector3(3,0,0)))
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection (generic skew)" in {
-      //these segments will not intersect
-      val result = Intersection.Test(
-        Segment3D(-3,-8,7, Vector3.Unit(Vector3(-3,-9,8))),
-        Segment3D(6,3,0, Vector3.Unit(Vector3(2,0,0)))
-      )
-      result mustEqual false
-    }
-  }
-
-  "Segment3D" should {
-    "detect intersection of the first point(s)" in {
-      //these segments intersect at (0, 0, 0)
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 1,0,0),
-        Segment3D(0,0,0, 0,1,0)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection of the first point" in {
-      //these segments intersect at (0, 0, 0); start of segment 1, middle of segment 2
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 0,2,0),
-        Segment3D(-1,0,0, 1,0,0)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection on the farther point(s)" in {
-      //these segments intersect at (0, 1, 0)
-      val result = Intersection.Test(
-        Segment3D(0,0,1, 0,1,0),
-        Segment3D(1,0,0, 0,1,0)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection on the farther point" in {
-      //these segments intersect at (1, 1, 0); end of segment 1, middle of segment 2
-      val result = Intersection.Test(
-        Segment3D(1,0,0, 1,1,0),
-        Segment3D(2,0,0, 0,2,0)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection in the middle(s)" in {
-      //these segments intersect at (0.5f, 0.5f, 0)
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 1,1,0),
-        Segment3D(1,0,0, 0,1,0)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection in the middle " in {
-      //these segments intersect at (0, 0.5, 0)
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 1,0,0),
-        Segment3D(0.5f,1,0, 0.5f,-1,0)
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection if the point of intersection would be before the start of the segments" in {
-      //these segments will not intersect as segments; but, as lines, they would intersect at (0, 0, 0)
-      val result = Intersection.Test(
-        Segment3D(1,1,0, 2,2,0),
-        Segment3D(1,0,0, 2,0,0)
-      )
-      result mustEqual false
-    }
-
-    "not detect intersection if the point of intersection would be after the end of the segments" in {
-      //these segments will not intersect as segments; but, as lines, they would intersect at (2, 2, 0)
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 1,1,0),
-        Segment3D(2,0,0, 2,1,0)
-      )
-      result mustEqual false
-    }
-
-    "not detect intersection if the line segments are parallel" in {
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 1,1,1),
-        Segment3D(1,1,2, 2,2,3)
-      )
-      result mustEqual false
-    }
-
-    "detect intersection with overlapping" in {
-      //the sub-segment (1,0,0) to (2,0,0) is an overlap region shared between the two segments
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 2,0,0),
-        Segment3D(1,0,0, 3,0,0)
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection with coincidental, non-overlapping" in {
-      //the sub-segment (1,0,0) to (2,0,0) is an overlap region shared between the two segments
-      val result = Intersection.Test(
-        Segment3D(0,0,0, 1,0,0),
-        Segment3D(2,0,0, 3,0,0)
-      )
-      result mustEqual false
-    }
-
-    "not detect intersection (generic skew)" in {
-      //these segments will not intersect
-      val result = Intersection.Test(
-        Segment3D(-3,-8,7, -3,-9,8),
-        Segment3D(6,3,0, 2,0,0)
-      )
-      result mustEqual false
-    }
-  }
-
-  "Sphere" should {
-    "intersect when overlapping (coincidental)" in {
-      val result = Intersection.Test(
-        Sphere(Vector3.Zero, 1),
-        Sphere(Vector3.Zero, 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when overlapping (engulfed)" in {
-      val result = Intersection.Test(
-        Sphere(Vector3.Zero,   5),
-        Sphere(Vector3(1,0,0), 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when overlapping (partial 1)" in {
-      val result = Intersection.Test(
-        Sphere(Vector3.Zero,   2),
-        Sphere(Vector3(2,0,0), 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when overlapping (partial 2)" in {
-      val result = Intersection.Test(
-        Sphere(Vector3.Zero,      2),
-        Sphere(Vector3(2.5f,0,0), 1)
-      )
-      result mustEqual true
-    }
-
-    "intersect when the circumferences are touching" in {
-      val result = Intersection.Test(
-        Sphere(Vector3.Zero,   2),
-        Sphere(Vector3(3,0,0), 1)
-      )
-      result mustEqual true
-    }
-
-    "not intersect when not touching" in {
-      val result = Intersection.Test(
-        Sphere(Vector3.Zero,   2),
-        Sphere(Vector3(4,0,0), 1)
-      )
-      result mustEqual false
-    }
-  }
-
-  "Cylinder" should {
-    "detect intersection if overlapping" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 2),
-        Cylinder(0, 0, 0, 1, 2)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if sides clip" in {
-      val result = Intersection.Test(
-        Cylinder(0,    0,    0, 1, 2),
-        Cylinder(0.5f, 0.5f, 0, 1, 2)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if touching" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 2),
-        Cylinder(1, 0, 0, 1, 2)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if stacked" in {
-      val result = Intersection.Test(
-        Cylinder(1, 0, 0, 1, 2),
-        Cylinder(1, 0, 2, 1, 2)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if one is sunken into the other" in {
-      val result = Intersection.Test(
-        Cylinder(1, 0, 0, 1, 2),
-        Cylinder(1, 0, 1, 1, 2)
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection if not near each other" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 2),
-        Cylinder(2, 2, 0, 1, 2)
-      )
-      result mustEqual false
-    }
-
-    "not detect intersection if one is too high / low" in {
-      val result = Intersection.Test(
-        Cylinder(1, 0, 0, 1, 2),
-        Cylinder(1, 0, 5, 1, 2)
-      )
-      result mustEqual false
-    }
-  }
-
-  "Cylinder and Sphere" should {
-    "detect intersection if overlapping" in {
-      val result = Intersection.Test(
-        Cylinder(1, 0, 0, 1, 1),
-        Sphere(1, 0, 2, 1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if cylinder top touches sphere base" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(1, 0, 2, 1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if cylinder base touches sphere top" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(-1, 0, -1, 1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if cylinder edge touches sphere edge" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(2, 0, 0.5f, 1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if on cylinder top rim" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(1.75f, 0, 1.25f, 1)
-      )
-      result mustEqual true
-    }
-
-    "detect intersection if on cylinder base rim" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(1.75f, 0, -0.5f, 1)
-      )
-      result mustEqual true
-    }
-
-    "not detect intersection if too far above" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(0, 0, 3, 1)
-      )
-      result mustEqual false
-    }
-
-    "not detect intersection if too far below" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(0, 0, -3, 1)
-      )
-      result mustEqual false
-    }
-
-    "not detect intersection if too far out (sideways)" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(2, 2, 0, 1)
-      )
-      result mustEqual false
-    }
-
-    "not detect intersection if too far out (skew)" in {
-      val result = Intersection.Test(
-        Cylinder(0, 0, 0, 1, 1),
-        Sphere(1.5f, 1.5f, 1.5f, 1)
-      )
-      result mustEqual false
-    }
-  }
-}
-
-object GeometryTest { }