Bonus/malus for pool matchmaking based on sit counter

modules/lobby/src/main/Hook.scala

@@ -92,7 +92,8 @@ case class Hook(
       ratingRange = realRatingRange,
       lame = user.??(_.lame),
       blocking = lila.pool.PoolMember.BlockedUsers(user.??(_.blocking)),
-      since = createdAt
+      since = createdAt,
+      ragesitCounter = 0
     )
   )
 

modules/pool/src/main/MatchMaking.scala

@@ -1,5 +1,7 @@
 package lila.pool
 
+import scala.math.abs
+
 import lila.common.WMMatching
 
 object MatchMaking {
@@ -38,6 +40,8 @@ object MatchMaking {
         rangeMalus(a, b) + rangeMalus(b, a)
       } + {
         blockMalus(a, b) + blockMalus(b, a)
+      } - {
+        ragesitBonus(a, b)
       }
       val maxScore = ratingToMaxScore(a.rating atLeast b.rating)
       if (score <= maxScore) Some(score) else None
@@ -54,6 +58,15 @@ object MatchMaking {
     private def blockMalus(a: PoolMember, b: PoolMember) =
       if (a.blocking.ids contains b.userId) 9000 else 0
 
+    // bonus if the two players both have a good sit counter
+    // bonus if the two players both have a bad sit counter
+    // malus (so negative number as bonus) if neither of those are true, meaning that their sit counters are far away (e.g. 0 and -5)
+    private def ragesitBonus(a: PoolMember, b: PoolMember) =
+      if (a.ragesitCounter >= -2 && b.ragesitCounter >= -2) 50 // good players
+      else if (a.ragesitCounter <= -10 && b.ragesitCounter <= -10) 100 // very bad players
+      else if (a.ragesitCounter <= -5 && b.ragesitCounter <= -5) 50 // bad players
+      else (abs(a.ragesitCounter - b.ragesitCounter) atMost 10) * -10 // match of good and bad player
+
     def apply(members: Vector[PoolMember]): Option[Vector[Couple]] = {
       WMMatching(members.toArray, pairScore).fold(
         err => {

modules/pool/src/main/PoolActor.scala

@@ -31,10 +31,10 @@ private final class PoolActor(
 
   def receive = {
 
-    case Join(joiner) =>
+    case Join(joiner, ragesitCounter) =>
       members.find(joiner.is) match {
         case None =>
-          members = members :+ PoolMember(joiner, config)
+          members = members :+ PoolMember(joiner, config, ragesitCounter)
           if (members.size >= config.wave.players.value) self ! FullWave
           monitor.join.count(monId)()
         case Some(member) if member.ratingRange != joiner.ratingRange =>
@@ -109,7 +109,7 @@ private final class PoolActor(
 
 private object PoolActor {
 
-  case class Join(joiner: PoolApi.Joiner) extends AnyVal
+  case class Join(joiner: PoolApi.Joiner, ragesitCounter: Int)
   case class Leave(userId: User.ID) extends AnyVal
 
   case object ScheduledWave

modules/pool/src/main/PoolApi.scala

@@ -28,7 +28,7 @@ final class PoolApi(
   def join(poolId: PoolConfig.Id, joiner: Joiner) =
     playbanApi.hasCurrentBan(joiner.userId) foreach {
       case false => actors foreach {
-        case (id, actor) if id == poolId => actor ! Join(joiner)
+        case (id, actor) if id == poolId => playbanApi.sitAndDcCounter(joiner.userId).map(actor ! Join(joiner, _))
         case (_, actor) => actor ! Leave(joiner.userId)
       }
       case _ =>

modules/pool/src/main/PoolMember.scala

@@ -13,6 +13,7 @@ case class PoolMember(
     lame: Boolean,
     blocking: PoolMember.BlockedUsers,
     since: DateTime,
+    ragesitCounter: Int,
     misses: Int = 0 // how many waves they missed
 ) {
 
@@ -33,7 +34,7 @@ object PoolMember {
 
   case class BlockedUsers(ids: Set[User.ID]) extends AnyVal
 
-  def apply(joiner: PoolApi.Joiner, config: PoolConfig): PoolMember =
+  def apply(joiner: PoolApi.Joiner, config: PoolConfig, ragesitCounter: Int): PoolMember =
     PoolMember(
       userId = joiner.userId,
       sri = joiner.sri,
@@ -41,6 +42,7 @@ object PoolMember {
       rating = joiner.ratingMap.getOrElse(config.perfType.key, 1500),
       ratingRange = joiner.ratingRange,
       blocking = BlockedUsers(joiner.blocking),
-      since = DateTime.now
+      since = DateTime.now,
+      ragesitCounter = ragesitCounter
     )
 }