Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Calculates the probabilities of victory using unusual combinations of non-transitive dice. Does not make any optimisations (e.g. ruling out always-lose/always-win combinations on a DiceSet) at all, so it quickly slows down if, for example, two players each throw six dice.
#!/usr/bin/env ruby
# Grimesweeper
# Calculates the victory chances if different combinations of Grime Dice (non-transitive dice) against one another
# Inspired by https://protonsforbreakfast.wordpress.com/2013/01/08/amazing-dice-rediscovering-surprise/
# Discussed on http://www.reddit.com/r/tabletopgamedesign/comments/1aibz9/grime_dice_might_make_a_good_basis_for/
# More info: http://grime.s3-website-eu-west-1.amazonaws.com/
class DiceSet < Array
# Returns an array of all of the possible outcome totals of throwing this DiceSet
def outcomes
# Calculate recursively by getting the outcomes for all dice except the first, in combination
# with all of the possible states of the first.
return self[0] if self.length == 1 # if only one die, outcomes are its face values (exit condition)
DiceSet::new(self[1..-1]).outcomes.collect{|o| self[0].collect{|i| i + o }}.flatten
end
end
class Die < Array
end
DICE = {
# A normal 6-sided die
:normal => Die::new([ 1, 2, 3, 4, 5, 6]),
# Three common non-transitive dice: red beats green beats blue beats red; the cycle is reversed if they're doubled up
:red => Die::new([ 3, 3, 3, 3, 3, 6]),
:green => Die::new([ 2, 2, 2, 5, 5, 5]),
:blue => Die::new([ 1, 4, 4, 4, 4, 4]),
# Four dice, in the 'Efron' model: blue beats magenta beats olive beats red beats blue; also magenta beats red (across the circle)
:efron_blue => Die::new([ 3, 3, 3, 3, 3, 3]),
:efron_magenta => Die::new([ 2, 2, 2, 2, 6, 6]),
:efron_olive => Die::new([ 1, 1, 1, 5, 5, 5]),
:efron_red => Die::new([ 0, 0, 4, 4, 4, 4]),
# Seven dice, numbered up to 21, in the 'Deventer' model: each beats three others, so that you can try to beat two opponents simultaneously.
# Deventer dice have six sides, but they're in pairs so we can simplify to "three sides" in this model:
:deventer_red => Die::new([ 7, 10, 16]), # beats orange, yellow, blue
:deventer_orange => Die::new([ 5, 13, 15]), # beats yellow, green, indigo
:deventer_yellow => Die::new([ 3, 9, 21]), # beats green, blue, violet
:deventer_green => Die::new([ 1, 12, 20]), # beats blue, indigo, red
:deventer_blue => Die::new([ 6, 8, 19]), # beats indigo, violet, orange
:deventer_indigo => Die::new([ 4, 11, 18]), # beats violet, red, yellow
:deventer_violet => Die::new([ 2, 14, 17]), # beats red, orange, green
# Grime fives
:five_blue => Die::new([ 2, 2, 2, 7, 7, 7]), # beats olive and magenta
:five_olive => Die::new([ 0, 5, 5, 5, 5, 5]), # beats yellow and red
:five_yellow => Die::new([ 3, 3, 3, 3, 8, 8]), # beats magenta and blue
:five_magenta => Die::new([ 1, 1, 6, 6, 6, 6]), # beats red and olive
:five_red => Die::new([ 4, 4, 4, 4, 4, 9]), # beats blue and yellow
}
# Given two dice, or two sets of dice, returns the chance that the former beating the latter
# Return value is in the form of a { :wins => ..., :loses => ..., :draws => ...} hash
def compete(alpha, beta)
# Convert inputs to a standard format, whether gives arrays, symbols, dice or sets
alpha = [alpha] if alpha.is_a?(Die) || !alpha.is_a?(Array)
beta = [beta] if beta.is_a?(Die) || !beta.is_a?(Array)
alpha = DiceSet::new(alpha.collect{|a| Die::new(a)})
beta = DiceSet::new(beta.collect{|b| Die::new(b)})
# Set up storage for wins, loses, draws
result = {:wins => 0, :loses => 0, :draws => 0, :trials => 0}
# compare each result to each other result
alpha.outcomes.sort.each do |a|
beta.outcomes.sort.each do |b|
result[:trials] += 1
#printf "%3i. %2i %2i", result[:trials], a, b
result[:wins] += 1 if a > b
#printf ' %2i', result[:wins] if a > b
result[:loses] += 1 if a < b
#printf ' %2i', result[:loses] if a < b
result[:draws] += 1 if a == b
#print "\n"
end
end
result
end
# Returns human-readable results of a comparison
def compare(alpha_desc, alpha, beta_desc, beta)
result = compete(alpha, beta)
if result[:wins] == result[:loses]
puts "#{alpha_desc} ties with #{beta_desc} (#{result[:draws]} draws, #{result[:wins] + result[:loses]} wins/loses)"
elsif result[:wins] > result[:loses]
victory_percentage = ((result[:wins].to_f / result[:trials]) * 100).round(2)
draw_percentage = ((result[:draws].to_f / result[:trials]) * 100).round(2)
puts "#{alpha_desc} beats #{beta_desc} #{victory_percentage}% of the time (draws #{draw_percentage}%)"
else
victory_percentage = ((result[:loses].to_f / result[:trials]) * 100).round(2)
draw_percentage = ((result[:draws].to_f / result[:trials]) * 100).round(2)
puts "#{beta_desc} beats #{alpha_desc} #{victory_percentage}% of the time (draws #{draw_percentage}%)"
end
end
# Classic comparisons
compare 'Red', DICE[:red], 'Green', DICE[:green]
compare 'Green', DICE[:green], 'Blue', DICE[:blue]
compare 'Blue', DICE[:blue], 'Red', DICE[:red]
# Colours versus normal
#puts '-'*78
#compare 'Red', DICE[:red], 'Normal', DICE[:normal]
#compare 'Green', DICE[:green], 'Normal', DICE[:normal]
#compare 'Blue', DICE[:blue], 'Normal', DICE[:normal]
# Pairs versus
puts '-'*78
redset, greenset, blueset = [DICE[:red], DICE[:red]], [DICE[:green], DICE[:green]], [DICE[:blue], DICE[:blue]]
compare '2Red', redset, '2Green', greenset
compare '2Green', greenset, '2Blue', blueset
compare '2Blue', blueset, '2Red', redset
# Trios versus
puts '-'*78
redset << DICE[:red]
greenset << DICE[:green]
blueset << DICE[:blue]
compare '3Red', redset, '3Green', greenset
compare '3Green', greenset, '3Blue', blueset
compare '3Blue', blueset, '3Red', redset
# Quads versus
puts '-'*78
redset << DICE[:red]
greenset << DICE[:green]
blueset << DICE[:blue]
compare '4Red', redset, '4Green', greenset
compare '4Green', greenset, '4Blue', blueset
compare '4Blue', blueset, '4Red', redset
# Quints versus - warning: takes a long time
#puts '-'*78
#redset << DICE[:red]
#greenset << DICE[:green]
#blueset << DICE[:blue]
#compare '5Red', redset, '5Green', greenset
#compare '5Green', greenset, '5Blue', blueset
#compare '5Blue', blueset, '5Red', redset
# Sexts versus - warning: takes a LUDICROUSLY long time
#puts '-'*78
#redset << DICE[:red]
#greenset << DICE[:green]
#blueset << DICE[:blue]
#compare '6Red', redset, '6Green', greenset
#compare '6Green', greenset, '6Blue', blueset
#compare '6Blue', blueset, '6Red', redset
# Septs versus - warning: eats processors for breakfast
#puts '-'*78
#redset << DICE[:red]
#greenset << DICE[:green]
#blueset << DICE[:blue]
#compare '6Red', redset, '6Green', greenset
#compare '6Green', greenset, '6Blue', blueset
#compare '6Blue', blueset, '6Red', redset
# A comparison of unusual pairings
#compare 'Red+Green', [DICE[:red], DICE[:green]], '2Green', [DICE[:green], DICE[:green]]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment