From 94bbae437d98c103d1dae09be9949bcf26e8bcf9 Mon Sep 17 00:00:00 2001
From: Marcin Chrzanowski <marcin.j.chrzanowski@gmail.com>
Date: Wed, 30 Aug 2017 17:13:47 -0400
Subject: Refactor similar die functions

---
 src/dice.js | 121 ++++++++++++++++++------------------------------------------
 1 file changed, 36 insertions(+), 85 deletions(-)

(limited to 'src')

diff --git a/src/dice.js b/src/dice.js
index 53d337d..828a772 100644
--- a/src/dice.js
+++ b/src/dice.js
@@ -1,3 +1,6 @@
+const greaterThanOrEqual = (a, b) => a >= b
+const lessThanOrEqual = (a, b) => a <= b
+
 const constant = n => () => [() => n]
 
 const pool = (die) => {
@@ -58,13 +61,13 @@ const bonusSubtract = (die1, die2) => {
   }
 }
 
-const explode = (die1, die2) => {
+const explode = (comparison, die1, die2) => {
   return () => {
     const explodeOn = roll(die1)
     return die2().map(die => () => {
       let lastRoll = die()
       let total = lastRoll
-      while (lastRoll >= explodeOn) {
+      while (comparison(lastRoll, explodeOn)) {
         lastRoll = die()
         total += lastRoll
       }
@@ -73,26 +76,21 @@ const explode = (die1, die2) => {
   }
 }
 
+const explodeAbove = (die1, die2) => {
+  return explode(greaterThanOrEqual, die1, die2)
+}
+
 const explodeUnder = (die1, die2) => {
-  return () => {
-    const explodeOn = roll(die1)
-    return die2().map(die => () => {
-      let lastRoll = die()
-      let total = lastRoll
-      while (lastRoll <= explodeOn) {
-        lastRoll = die()
-        total += lastRoll
-      }
-      return total
-    })
-  }
+  return explode(lessThanOrEqual, die1, die2)
 }
 
-const keepHigh = (die1, die2) => {
+
+
+const keep = (order, die1, die2) => {
   return () => {
     const numberToKeep = roll(die1)
     let rolls = die2().map(die => [die, die()])
-    rolls.sort((a, b) => (a[1] - b[1])).reverse()
+    rolls.sort(order)
     return rolls.slice(0, numberToKeep).map(pair => {
       let returnedOriginal = false
       return () => {
@@ -107,26 +105,15 @@ const keepHigh = (die1, die2) => {
   }
 }
 
+const keepHigh = (die1, die2) => {
+  return keep((a, b) => (b[1] - a[1]), die1, die2)
+}
+
 const keepLow = (die1, die2) => {
-  return () => {
-    const numberToKeep = roll(die1)
-    let rolls = die2().map(die => [die, die()])
-    rolls.sort((a, b) => (a[1] - b[1]))
-    return rolls.slice(0, numberToKeep).map(pair => {
-      let returnedOriginal = false
-      return () => {
-        if (!returnedOriginal) {
-          returnedOriginal = true
-          return pair[1]
-        } else {
-          return pair[0]()
-        }
-      }
-    })
-  }
+  return keep((a, b) => (a[1] - b[1]), die1, die2)
 }
 
-const again = (die1, die2) => {
+const again = (comparison, die1, die2) => {
   return () => {
     const againOn = roll(die1)
     let rolls = []
@@ -135,7 +122,7 @@ const again = (die1, die2) => {
     const rollDie = (die) => {
       const roll = die()
 
-      if (roll >= againOn) {
+      if (comparison(roll, againOn)) {
         rollAgain.push(die)
       }
 
@@ -162,49 +149,21 @@ const again = (die1, die2) => {
   }
 }
 
-const againUnder = (die1, die2) => {
-  return () => {
-    const againOn = roll(die1)
-    let rolls = []
-    let rollAgain = []
-
-    const rollDie = (die) => {
-      const roll = die()
-
-      if (roll <= againOn) {
-        rollAgain.push(die)
-      }
-
-      let returnedOriginal = false
-      rolls.push(() => {
-        if (!returnedOriginal) {
-          returnedOriginal = true
-          return roll
-        } else {
-          return die()
-        }
-      })
-    }
-
-    die2().forEach(rollDie)
-
-    while (rollAgain.length > 0) {
-      const oldRollAgain = rollAgain
-      rollAgain = []
-      oldRollAgain.forEach(rollDie)
-    }
+const againAbove = (die1, die2) => {
+  return again(greaterThanOrEqual, die1, die2)
+}
 
-    return rolls
-  }
+const againUnder = (die1, die2) => {
+  return again(lessThanOrEqual, die1, die2)
 }
 
-const threshold = (die1, die2) => {
+const threshold = (comparison, die1, die2) => {
   return () => {
     const cutoff = roll(die1)
 
     return die2().map(die => {
       return () => {
-        if (die() >= cutoff) {
+        if (comparison(die(), cutoff)) {
           return 1
         } else {
           return 0
@@ -214,20 +173,12 @@ const threshold = (die1, die2) => {
   }
 }
 
-const thresholdLow = (die1, die2) => {
-  return () => {
-    const cutoff = roll(die1)
+const thresholdHigh = (die1, die2) => {
+  return threshold(greaterThanOrEqual, die1, die2)
+}
 
-    return die2().map(die => {
-      return () => {
-        if (die() <= cutoff) {
-          return 1
-        } else {
-          return 0
-        }
-      }
-    })
-  }
+const thresholdLow = (die1, die2) => {
+  return threshold(lessThanOrEqual, die1, die2)
 }
 
 exports.pool = pool
@@ -239,11 +190,11 @@ exports.subtract = subtract
 exports.bonusAdd = bonusAdd
 exports.bonusSubtract = bonusSubtract
 exports.negative = negative
-exports.explode = explode
+exports.explodeAbove = explodeAbove
 exports.explodeUnder = explodeUnder
 exports.keepHigh = keepHigh
 exports.keepLow = keepLow
-exports.again = again
+exports.againAbove = againAbove
 exports.againUnder = againUnder
-exports.threshold = threshold
+exports.thresholdHigh = thresholdHigh
 exports.thresholdLow = thresholdLow
-- 
cgit v1.2.3