Bowling game Kata in Scala - pattern match
Some tips:

When pattern matching and inspecting multiple values of a sequence type (Seq, List, Array, etc) you can reduce the length of your expression by using sequence patterns instead of explicitly breaking the sequence up with the :: operator. So instead of a :: b :: c :: d :: Nil you can more concisely use Seq(a, b, c, d).

When you want to check for explicit values while pattern matching on an object you can use those values instead of replacing them with variables that are then checked with an if statement. For example case Seq(a, b, c) if a == 10 =&gt; ...  can be more concisely expressed as case Seq(10, b, c) =&gt; ...

When using pattern matching on sequences (especially when the case expression goes beyond the standard head :: tail) it can enhance legibility to use single letter variable names and comments instead of long variable names. I think that we would both agree that good code should describe itself through both value and function names. However, in this case there is no way of adding intuition with function names and so all of the description ended up in your value names.
Like I said before, do what works for you. If legibility was our only metric then maybe pattern matching isn't the ideal way to implement your function. It could still be recursive, but instead of cases you could use functions. Do whatever suits you the best but when possible I would recommend short variable names accompanied by comments over long variable names.


Some code:
object BowlingGame {
  def count(points: Seq[Int]): Int = {
    def helper(ps: Seq[Int], acc: Int): Int = ps match {
      case Nil =&gt; 
        acc

      case Seq(a) =&gt;      
        acc + a

      // strike or spare in last round
      case xs @ Seq(a, b, c) =&gt;                
        acc + xs.sum

      // strike
      case Seq(10, a, b, _*) =&gt;
        helper(ps.tail, acc + 10 + a + b)

      // spare
      case Seq(a, b, c, _*) if a + b == 10 =&gt;
        helper(ps.drop(2), acc + a + b + c)

      // neither a spare or a strike
      case Seq(a, b, _*) =&gt;
        helper(ps.drop(2), acc + a + b)
    }
    helper(points, 0)
  }
}