randsum 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b40795441292e1f022b9964709ae9b1a1440b8d2
-  data.tar.gz: e2403d1ed04af388474c6fb24ee69b1065bc2848
+  metadata.gz: c3a741642aa60b86f2c5f085ccce024f09606a29
+  data.tar.gz: dc30d622c0b53c70bae39a1ce4b6f15128b235dc
 SHA512:
-  metadata.gz: 55770ea57631fe9e4d1297b78b824d45067b5b1b52113201491cf72f901e03bb5ce5096be5dd90b5650556fc1fd140a5208bb2e14e65f29d912aa8d75dc4230e
-  data.tar.gz: 6f400f76cb73c5ce4cbc651941646f9cd66dc86c2afeb697e5b95602263c541394d81ce95cc3e6ce1faf4432d49e6c6a264a8e171cbe3dfad7153d198188760a
+  metadata.gz: 80dcc04a112b364b44deea35593bf7eb6df2bd63846c82e93da8f7b32373bf68692a9712591035f1d2cb0ab4ada315922ca48e3a4691714b7a9789971b48f97e
+  data.tar.gz: db464e7cc91dd7a58d1100a8d117adb6440f428b6eb04773d596d8a53bd514436443379d066a4da8ccb9aeb0fc2b462e17b80386d51a83a4075c9f9f8cb19a46

data/README.md

@@ -89,75 +89,166 @@ Snakeyes. Rough.
 `Die#roll` returns a `Roll` object, which can teach you a lot about your rolls (but not, tragically, how to roll better.)
 
 ```
-> report = Randsum::D20.roll 5
+> roll = Randsum::D20.roll 5
 #=> You rolled 5 d20, and got a 61. (Rolls: [20, 16, 9, 14, 1])
 ```
 
 The `#total` method represents the sum total of the dice that were rolled:
 
 ```
-> report.total
+> roll.total
 #=> 61
 ```
 
 The `#rolls` array, which reports the individual results of any dice rolled:
 
 ```
-> report.rolls
+> roll.rolls
 #=> [20, 17, 9, 14,1]
 ```
 
 `#quantity` tells you how many dice were rolled this time:
 
 ```
-> report.quantity
+> roll.quantity
 #=> 5
 ```
 
 `#sides` reports the number of sides on the dice rolled in this result:
 
 ```
-> report.sides
+> roll.sides
 #=> 20
 ```
 
 And if you don't like that roll (hey we get it) you can use `#die` to get another of the same die to roll again!
 
 ```
-> report.die.roll
+> roll.die.roll
 #=> You rolled 1 D20, and got 17. (Rolls: [17])
 ```
 
 #### Manipulating `Roll`s
 
-Roll results can be further manipulated after their original creation. To facilitate popular use-cases for Dice rolling, `Roll`s also include public `#drop_lowest` and `#drop_highest`, and `#drop` methods.
+`Roll`s can be directly created, using the `.roll` class method. Get ready to see the word `Roll` a lot below; its become meaningless to me at this point.
+
+```
+> Randsum::Roll.roll 2 d:20
+#=> You rolled 2 d20, and got 25. (Rolls: [12, 13])
+```
+
+
+##### Dropping Rolls
+`Roll`s also include public `#drop_lowest` and `#drop_highest`, and `#drop` methods.
 
 `#drop_lowest` returns a new `Roll` without the lowest numerical die roll.
 
 ```
-> report = Randsum::D6.roll 4
+> roll = Randsum::D6.roll 4
 #=> You rolled 4 d6, and got 11. (Rolls: [3, 2, 2, 4])
 
-> new_report = report.drop_lowest
-#=>  You rolled 3 d6, and got 9. (Rolls: [4, 3, 2])
+> roll.drop_lowest
+#=> You rolled 3 d6, and got 9. (Rolls: [4, 3, 2])
 ```
 
 Similarly, `#drop_highest` will remove the highest number in the `rolls` array.
 
 ```
-> new_result = report.drop_highest
+> new_roll = roll.drop_highest
 #=> You rolled 3 d6, and got 7. (Rolls: [2, 2, 3])
 ```
 
 Both `#drop_lowest` and `#drop_highest` can also take an optional integer argument.
 
 ```
-> result.drop_highest(2)
+> roll.drop_highest(2)
 #=> You rolled 2 d6, and got 4. (Rolls: [2, 2])
 ```
+`#drop` works as a catch-all for these, using keyword arguments:
 
-### WHY IS THIS SO COMPLICATED
+```
+> roll.drop(extremity: :highest, quantity: 2)
+#=> You rolled 2 d6, and got 4. (Rolls: [2, 2])
+```
+
+##### Replacing Values
+`Roll`s have a number of ways to further manipulate the rolls inside.
+
+```
+ > roll = Randsum::D20.roll(3)
+ #=> You rolled 3 d20, and got 35. (Rolls: [14, 12, 9])
+```
+
+You can use the `#reroll` to completely trash the rolls you had and start again.
+```
+ > roll.reroll
+ #=> You rolled 3 d20, and got 44. (Rolls: [19, 11, 14])
+```
+
+`#double_all` takes all instances of a value in the roll and - you guess it - doubles it.
+```
+ > roll.double_all(9)
+ #=> You rolled 3 d20, and got 44. (Rolls: [14, 12, 18])
+```
+
+The catch-all `#replace` method takes a number of arguments that change its behavior:
+  - the `target:` keyword can be:
+
+    - an integer (what you want to replace) or
+      ```
+       > roll.replace(target: 9, with: 20)
+       #=> You rolled 3 d20, and got 46. (Rolls: [14, 12, 20])
+      ```
+    - the symbol `:all` (to replace all of the rolls)
+      ```
+       > roll.replace(target: :all, with: 20)
+       #=> You rolled 3 d20, and got 60. (Rolls: [20, 20, 20])
+      ```
+
+  - the `with:` keyword:
+    - an integer (what you want the target to be replaced by)
+      ```
+       > roll.replace(target: 9, with: 20)
+       #=> You rolled 3 d20, and got 46. (Rolls: [14, 12, 20])
+      ```
+    - the symbol `:reroll` (to replace the targets with a new roll using the same die)
+      ```
+       > roll.replace(target: 9, with: :reroll)
+       #=> You rolled 3 d20, and got 28. (Rolls: [14, 12, 2])
+      ```
+    - the symbol `:double` (to double the value of the targets)
+      ```
+       > roll.replace(target: 9, with: :double)
+       #=> You rolled 3 d20, and got 44. (Rolls: [14, 12, 18])
+      ```
+
+#### Checking!
+Need to see if a value meet or beat another value? Well, beans. We've got that, too.
+
+```
+ > roll = Randsum::D20.roll(3)
+ #=> You rolled 3 d20, and got 22. (Rolls: [20, 1, 1])
+
+ > roll.beats?(20)
+ #=> true
 
+ > roll.beats?(22)
+ #=> false
+
+ > roll.beats?(25)
+ #=> false
+
+ > roll.meets?(20)
+ #=> true
+
+ > roll.meets?(22)
+ #=> true
+
+ > roll.meets?(25)
+ #=> false
+```
+
+### WHY IS THIS SO COMPLICATED
 `Die#simple_roll` will just give you a random number, but where's the fun in that?
 
 ### Why build this?

data/lib/randsum.rb

@@ -1,6 +1,11 @@
 require "randsum/version"
 require "randsum/metadata"
-require "randsum/filters/filter"
+require "randsum/filters/replacers/replacer"
+require "randsum/filters/replacers/replacer_targets/replacer_target"
+require "randsum/filters/replacers/replacer_targets/replacer_target_all"
+require "randsum/filters/replacers/replacer_values/replacer_value"
+require "randsum/filters/replacers/replacer_values/replacer_reroll_value"
+require "randsum/filters/replacers/replacer_values/replacer_double_value"
 require "randsum/filters/droppers/dropper"
 require "randsum/filters/droppers/high_dropper"
 require "randsum/filters/droppers/low_dropper"

data/lib/randsum/filters/droppers/dropper.rb

@@ -1,23 +1,38 @@
 module Randsum
-  class Dropper < Filter
+  class Dropper
+    attr_reader :quantity, :roll
 
-    def self.dropper_for(quantity:,extremity:, rolls:)
+    def self.for(quantity:, extremity:, roll:)
       Object.const_get(
         "Randsum::#{extremity.to_s.gsub("est","").capitalize}Dropper"
-      ).new(quantity: quantity, rolls: rolls)
+      ).new(quantity: quantity, roll: roll)
+    end
+
+    def initialize(quantity:, roll:)
+      @quantity = quantity
+      @roll = roll
     end
 
     def filter
-      ordered.first(remainder)
+      return Randsum::Roll.new(
+        die: roll.die,
+        quantity: roll.quantity,
+        result: result
+      )
     end
 
     def ordered
       raise NotImplementedError
     end
 
-    def remainder
-      rolls.length - quantity
+    private
+
+    def result
+      ordered.first(remainder)
     end
 
+    def remainder
+      roll.length - quantity
+    end
   end
 end

data/lib/randsum/filters/droppers/high_dropper.rb

@@ -1,7 +1,7 @@
 module Randsum
   class HighDropper < Dropper
     def ordered
-      rolls.sort { |a, b| a <=> b }
+      roll.result.sort { |a, b| a <=> b }
     end
   end
 end

data/lib/randsum/filters/droppers/low_dropper.rb

@@ -1,7 +1,7 @@
 module Randsum
   class LowDropper < Dropper
     def ordered
-      rolls.sort { |a, b| b <=> a }
+      roll.result.sort { |a, b| b <=> a }
     end
   end
 end

data/lib/randsum/filters/replacers/replacer.rb

@@ -0,0 +1,35 @@
+module Randsum
+  class Replacer
+    attr_reader :target, :with, :roll
+
+    def self.for(target:, with:, roll:)
+      Randsum::Replacer.new(
+        target: target,
+        with: with,
+        roll: roll,
+      )
+    end
+
+    def initialize(target:, with:, roll:)
+      @target = ReplacerTarget.for(target, roll: roll)
+      @with   = ReplacerValue.for(with, roll: roll)
+      @roll   = roll
+    end
+
+    def filter
+      return Randsum::Roll.new(
+        die: roll.die,
+        quantity: roll.quantity,
+        result: result
+      )
+    end
+
+    def result
+      (roll.result - target.match) + transformed
+    end
+
+    def transformed
+      with.transform(target.match)
+    end
+  end
+end

data/lib/randsum/filters/replacers/replacer_targets/replacer_target.rb

@@ -0,0 +1,28 @@
+module Randsum
+  class ReplacerTarget
+    ALL = :all
+    attr_reader :target, :roll
+
+    def self.for(target, roll:)
+      case target
+      when ALL
+        ReplacerTargetAll
+      when nil
+        ReplacerTargetAll
+      else
+        ReplacerTarget
+      end.new(target, roll: roll)
+    end
+
+    def initialize(target, roll:)
+      @target = target
+      @roll = roll
+    end
+
+    def match
+      roll.result.select do |r|
+        r == target
+      end
+    end
+  end
+end

data/lib/randsum/filters/replacers/replacer_targets/replacer_target_all.rb

@@ -0,0 +1,7 @@
+module Randsum
+  class ReplacerTargetAll < ReplacerTarget
+    def match
+      roll.result
+    end
+  end
+end

data/lib/randsum/filters/replacers/replacer_values/replacer_double_value.rb

@@ -0,0 +1,7 @@
+module Randsum
+  class ReplacerDoubleValue < ReplacerValue
+    def transform(match)
+      match.map { |r| r * 2 }
+    end
+  end
+end

data/lib/randsum/filters/replacers/replacer_values/replacer_reroll_value.rb

@@ -0,0 +1,7 @@
+module Randsum
+  class ReplacerRerollValue < ReplacerValue
+    def transform(match)
+      match.map { roll.die.simple_roll }
+    end
+  end
+end

data/lib/randsum/filters/replacers/replacer_values/replacer_value.rb

@@ -0,0 +1,28 @@
+module Randsum
+  class ReplacerValue
+    REROLL = :reroll
+    DOUBLE = :double
+
+    attr_reader :roll, :value
+
+    def self.for(value, roll:)
+      case value
+      when REROLL
+        ReplacerRerollValue
+      when DOUBLE
+        ReplacerDoubleValue
+      else
+        ReplacerValue
+      end.new(value, roll: roll)
+    end
+
+    def initialize(value, roll:)
+      @value = value
+      @roll  = roll
+    end
+
+    def transform(match)
+      match.map { value }
+    end
+  end
+end

data/lib/randsum/roll.rb

@@ -7,6 +7,10 @@ module Randsum
     alias_method :count, :quantity
     alias_method :rolls, :result
 
+    def self.roll(num, d:)
+      new(die: Die.new(d), quantity: num)
+    end
+
     def initialize(die:, quantity:, result: nil)
       @die = die
       @quantity = quantity
@@ -24,14 +28,44 @@ module Randsum
     end
     alias_method :to_i, :total
 
+    def beats?(check_value)
+      total > check_value
+    end
+
+    def meets?(meet_value)
+      total >= meet_value
+    end
+
+    def replace(target, with:)
+      Replacer.for(
+        target: target,
+        with: with,
+        roll: self
+      ).filter
+    end
+
+    def double_all(target)
+      Replacer.for(
+        target: target,
+        with: ReplacerValue::DOUBLE,
+        roll: self
+      ).filter
+    end
+
+    def reroll
+      Replacer.for(
+        target: ReplacerTarget::ALL,
+        with: ReplacerValue::REROLL,
+        roll: self
+      ).filter
+    end
+
     def drop(quantity:,extremity:)
-      return new_roll_with(
-      result: Dropper.dropper_for(
-          quantity: quantity,
-          extremity: extremity,
-          rolls: result
-        ).filter
-      )
+      Dropper.for(
+        quantity: quantity,
+        extremity: extremity,
+        roll: self
+      ).filter
     end
 
     def drop_lowest(quantity = 1)
@@ -44,14 +78,6 @@ module Randsum
 
     private
 
-    def new_roll_with(result: nil)
-      return Roll.new(
-        die: die,
-        quantity: quantity,
-        result: result
-      )
-    end
-
     def roll!
       (1..quantity).map { die.simple_roll }
     end

data/lib/randsum/version.rb

@@ -1,3 +1,3 @@
 module Randsum
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: randsum
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Alex Jarvis
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-05 00:00:00.000000000 Z
+date: 2016-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,7 +94,12 @@ files:
 - lib/randsum/filters/droppers/dropper.rb
 - lib/randsum/filters/droppers/high_dropper.rb
 - lib/randsum/filters/droppers/low_dropper.rb
-- lib/randsum/filters/filter.rb
+- lib/randsum/filters/replacers/replacer.rb
+- lib/randsum/filters/replacers/replacer_targets/replacer_target.rb
+- lib/randsum/filters/replacers/replacer_targets/replacer_target_all.rb
+- lib/randsum/filters/replacers/replacer_values/replacer_double_value.rb
+- lib/randsum/filters/replacers/replacer_values/replacer_reroll_value.rb
+- lib/randsum/filters/replacers/replacer_values/replacer_value.rb
 - lib/randsum/metadata.rb
 - lib/randsum/roll.rb
 - lib/randsum/version.rb

data/lib/randsum/filters/filter.rb

@@ -1,14 +0,0 @@
-module Randsum
-  class Filter
-    attr_reader :quantity, :rolls
-
-    def initialize(quantity:, rolls:)
-      @quantity = quantity
-      @rolls = rolls
-    end
-
-    def filter
-      raise NotImplementedError
-    end
-  end
-end