RayTracer - The Scala way

case class Ray(start: Vector3, end: Vector3) {
  def traceSide(cuboid: AxisAlignedCuboid, side: EnumFacing): Option[Hit] = {
    val (plane, coord) = side match {
      case DOWN => (VPlane.XZ, cuboid.min.y)
      case UP => (VPlane.XZ, cuboid.max.y)
      case NORTH => (VPlane.XY, cuboid.min.z)
      case SOUTH => (VPlane.XY, cuboid.max.z)
      case WEST => (VPlane.YZ, cuboid.min.x)
      case EAST => (VPlane.YZ, cuboid.max.x)
    }
    start.intercept(plane)(end, coord) match {
      case Some(hit) =>
        val (hitA, hitB) = plane.extractDefining(hit)
        val (minA, minB) = plane.extractDefining(cuboid.min)
        val (maxA, maxB) = plane.extractDefining(cuboid.max)
        if (!MathUtils.between(minA, hitA, maxA) || !MathUtils.between(minB, hitB, maxB))
          None
        else
          Some(Hit(hit, hit.distanceSq(start), Some(cuboid), side))
      case _ => None
    }
  }

  def traceCuboid(cuboid: AxisAlignedCuboid): Option[Hit] = values map (traceSide(cuboid, _)) minBy {
    case Some(hit) => hit.distanceSq
    case _ => Double.MaxValue
  }

  def traceCuboids(cuboids: Seq[AxisAlignedCuboid]): Option[Hit] = cuboids map traceCuboid minBy {
    case Some(hit) => hit.distanceSq
    case _ => Double.MaxValue
  }

  def traceCuboids(pos: BlockPos, cuboids: Seq[AxisAlignedCuboid]): Option[BlockHit] = traceCuboids(cuboids) map {
    _.blockHit(pos)
  }

  def trace(world: World): Option[Hit] =
    world.rayTraceBlocks(start, end, true, false, true) match {
      case null => None
      case mop if mop.typeOfHit == MovingObjectType.MISS => None
      case mop =>
        val hit: Vector3 = mop.hitVec
        Some(Hit(hit, hit.distanceSq(start), None, mop.sideHit))
    }
}