rachinations 0.0.7 → 0.0.8

data/lib/rachinations/helpers/edge_helper.rb

@@ -1,12 +1,15 @@
+require 'fraction'
+
 module Helpers
   module EdgeHelper
+    MathUtils = ::Utils::MathUtils
 
     # Returns true if all edges passed as arguments can execute a push
     #  when called in the same round. The difference between calling this
     #  method and calling Edge#test_ping? on each edge is that this method
     #  knows that each edge removes at least one Resource when it performs
     #  a push.
-    # @param [Array<Edge>] edges the edges
+    # @param [Enumerable<Edge>] edges the edges
     # @param [Boolean] require_all whether to require that the maximum amount
     #  of resources supported by each edge (i.e. its label) be available in
     #  order to succeed.
@@ -17,24 +20,118 @@ module Helpers
           number_of_resources: 0
       }
 
-      raise NotImplementedError, 'only require_all is implemented so far' unless require_all
+      raise ::NotImplementedError, 'only require_all is implemented so far' unless require_all
+
+      final = edges.inject(initial) do |acc, elem|
+
+        edge = elem
 
-      final = edges.inject(initial) do |accumulator, edge|
-        accumulator[:number_of_resources] += edge.label
+        acc[:number_of_resources] += edge.label
 
         resources_available = edge.from.resource_count(expr: edge.push_expression)
 
-        if resources_available >= accumulator[:number_of_resources]
-          accumulator[:partial_success] &&= true
+        if resources_available >= acc[:number_of_resources]
+          acc[:partial_success] &&= true
         else
-          accumulator[:partial_success] &&= false
+          acc[:partial_success] &&= false
         end
-        accumulator
+        acc
       end
 
       final[:partial_success]
 
     end
 
+    # Validates that labels are consistent
+    def self.labels_valid?(edges)
+      all_labels_integer?(edges) || (all_labels_float?(edges) && float_labels_add_up_to_one?(edges))
+    end
+
+    def self.all_labels_of_same_kind?(edges)
+      all_labels_integer?(edges) || all_labels_float?(edges)
+    end
+
+    # maybe returns an edge
+    def self.pick_one(edges:, mode:, index: nil)
+      raise ::RuntimeError.new('Labels must be of the same kind') unless all_labels_of_same_kind?(edges)
+      raise ::RuntimeError.new('Unknown mode') unless [:deterministic, :probabilistic].include?(mode)
+
+      if edges.empty?
+        nil
+      else
+        if mode === :deterministic
+          pick_next(edges, index)
+        elsif mode === :probabilistic
+          pick_any(edges)
+        end
+      end
+    end
+
+    private
+
+    def self.pick_next(edges, index)
+      raise ::ArgumentError.new('Invalid index: '+index) unless index.is_a?(Fixnum)
+
+
+      frequency_hash = edges.reduce(Hash.new) do |acc,elem|
+        acc[elem] = elem.label
+        acc
+      end
+
+      edge_lineup = MathUtils.get_cycle_lineup(frequency_hash)
+      normalized_index = index % edge_lineup.size
+
+      edge_lineup[normalized_index]
+    end
+
+    # pick one edge according to weights, if any
+    def self.pick_any(edges)
+
+      if  all_labels_integer?(edges) && edges.all? { |e| e.label == 1 }
+        #edges is probably an enumerable but only arrays can be sample()'d
+        edges.to_a.sample
+      elsif all_labels_float?(edges)
+        #{edge=>weight} is the shape required by WeightedDistribution
+        weights = edges.reduce(Hash.new) { |acc, el| acc[el] = el.label; acc }
+
+        sum_of_labels = edges.reduce(0) { |acc, el| acc + el.label }
+
+        remaining = 1.0 - sum_of_labels
+
+        # chances that a resource 'vanishes'
+        weights[nil] = remaining
+
+        WeightedDistribution.new(weights).sample
+
+      elsif all_labels_integer?(edges)
+
+        sum_of_labels = edges.reduce(0) { |acc, el| acc + el.label }
+
+        # since labels are integers, we must normalize them to get probablities
+        weights = edges.reduce(Hash.new) { |acc, el| acc[el] = el.label/sum_of_labels; acc }
+
+        WeightedDistribution.new(weights).sample
+
+      else
+        raise RuntimeError.new('Invalid setup')
+      end
+    end
+
+    def self.all_labels_integer?(edges)
+      edges.all? { |e| e.label.is_a?(Fixnum) }
+    end
+
+    def self.all_labels_float?(edges)
+      edges.all? { |e| e.label.is_a?(Float) }
+    end
+
+    def self.float_labels_add_up_to_one?(edges)
+
+      labels_as_fractions = edges.reduce(Array.new){|acc,el| acc.push(el.label.to_fraction(100)); acc }
+
+      MathUtils.add_up_to_one?(labels_as_fractions)
+
+    end
+
   end
 end

data/lib/rachinations/utils/math_utils.rb

@@ -0,0 +1,83 @@
+require 'fraction'
+
+module Utils
+  module MathUtils
+
+    # Returns an array containing references to the objects, in the correct
+    #   order, such that it can be used to represent the minimum possible cycle
+    #   that can be implemented using these objects.
+    # 
+    # @example Simple example
+    #   {"foo"=>3,"bar"=>2} yields ["foo","foo","foo","bar","bar"]
+    # @param [Hash<Object,Numeric>] weights A hash where the keys are
+    #   objects and the values their respective weights
+    # @return [Array[Object]] the lineup for the given weight hash
+    def self.get_cycle_lineup(weights)
+      raise ArgumentError.new('Weights should be supplied as a Hash') unless weights.is_a?(Hash)
+      raise ArgumentError.new('Weights should be numbers') unless weights.values.all?{|v| v.is_a?(Fixnum) || v.is_a?(Float) }
+
+      if weights.values.all?{|v| v.is_a?(Fixnum) }
+        get_integer_lineup(weights)
+      elsif weights.values.all?{|v| v.is_a?(Float) }
+        get_float_lineup(weights)
+      end
+
+    end
+
+    # takes an enumerable of fractions
+    def self.add_up_to_one?(fractions)
+
+      numerators = fractions.map{|el| el[0] }
+      denominators = fractions.map{|el| el[1] }
+
+      # lowest_common_multiple
+     # lcm(denominators)
+
+      sum=numerators.map.with_index do |elem,i|
+        multiplier = (lcm(denominators) / denominators[i]).to_i
+        multiplier * elem
+      end.reduce(:+)
+
+      sum == lcm(denominators)
+
+    end
+
+    private
+
+    # used when weights are integers
+    def self.get_integer_lineup(weights)
+      weights.reduce(Array.new) do |acc,(key,val)|
+        val.times{|i| acc.push(key) }
+        acc
+      end
+    end
+
+    # used when weights are floats (will be turned to fractions)
+    def self.get_float_lineup(weights)
+      weights_as_fractions = weights.reduce(Hash.new){|acc,(key,val)| acc[key] = val.to_fraction(100); acc }
+      raise RuntimeError('Fractional weights must add up to one') unless add_up_to_one?(weights_as_fractions.values)
+
+      lcm = lcm(weights_as_fractions.values.map{|el| el[1] } )
+
+      # the higher its weight, the more times the object appears
+      weights_as_fractions.reduce(Array.new) do |acc,(key,val)|
+        numerator = val[0]
+        denominator = val[1]
+        error = val[2] # not used so far
+        appearances = ( (lcm / denominator) * numerator ).to_i
+
+        # one reference for each appearance
+        appearances.times{ acc.push(key) }
+        acc
+      end
+
+    end
+
+    def self.lcm(integers)
+      integers.reduce do |acc,elem|
+        acc.to_i.lcm(elem)
+      end
+    end
+
+  end
+end

data/lib/rachinations/utils/string_utils.rb

@@ -0,0 +1,8 @@
+module Utils
+  module StringUtils
+
+    def self.valid_ruby_variable_name?(str)
+      (/^[a-z_][a-zA-Z_0-9]*$/ =~ str) == 0
+    end
+  end
+end

data/lib/rachinations/version.rb

@@ -1,3 +1,3 @@
 module Rachinations
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/rachinations.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Felipe Almeida"]
   spec.email         = ["falmeida1988@gmail.com"]
   spec.summary       = %q{Ruby port for Dr. J. Dormans' Machinations Game Mechanics Diagrams.}
-  spec.description   = %q{This project provides a Ruby-based DiagramShorthandMethods to enable game designers to
+  spec.description   = %q{This project provides a Ruby-based Diagram to enable game designers to
 design and also test tentative game designs and/or prototypes}
   spec.homepage      = "https://github.com/queirozfcom/rachinations"
   spec.license       = "MIT"
@@ -31,5 +31,6 @@ design and also test tentative game designs and/or prototypes}
   spec.add_dependency "activesupport","3.0.0"
   spec.add_dependency "i18n","0.6.11"
   spec.add_dependency "weighted_distribution", "1.0.0"
+  spec.add_dependency 'fraction','0.3.2'
 
 end

data/testing/spec/diagram_spec.rb

@@ -14,27 +14,27 @@ describe Diagram do
 
     it 'should be created with a source and a pool and run n times with no errors' do
 
-      d=Diagram.new 'simple'
+      d=Diagram.new 'simples'
 
       d.add_node! Source, {
-          :name => 'source'
+          :name => 'fonte'
       }
 
       d.add_node! Pool, {
-          :name => 'deposit',
+          :name => 'depósito',
           :initial_value => 0
       }
 
       d.add_edge! Edge, {
-          :name => 'connector',
-          :from => 'source',
-          :to => 'deposit'
+          :name => 'conector',
+          :from => 'fonte',
+          :to => 'depósito'
       }
 
       d.run!(10)
 
       expect(d.resource_count).to eq 10
-      expect(d.get_node('deposit').resource_count).to eq 10
+      expect(d.get_node('depósito').resource_count).to eq 10
 
     end
 
@@ -459,11 +459,13 @@ describe Diagram do
 
         d = Diagram.new
 
+        d.add_node! Sink, name: 'sink'
         d.add_node! Source, name: 's'
         d.add_node! Gate, name: 'g'
         d.add_node! Pool, name: 'p'
         d.add_edge! Edge, from: 's', to: 'g'
         d.add_edge! Edge, from: 'g', to: 'p', label: 50.percent
+        d.add_edge! Edge, from: 'g', to: 'sink', label: 50.percent
 
         d.run!(20)
 
@@ -472,8 +474,70 @@ describe Diagram do
       end
     end
 
+    describe 'stop conditions' do
+
+      it 'should stop when a stop condition is met before all turns run' do
 
-    describe 'Comprehensive examples'do
+        d = Diagram.new
+
+        d.add_node! Source, name: 's'
+        d.add_node! Gate, name: 'g'
+        d.add_node! Pool, name: 'po'
+        d.add_edge! Edge, from: 's', to: 'g'
+        d.add_edge! Edge, from: 'g', to: 'po'
+
+        d.add_stop_condition! message: 'first', condition: expr { d.po.resource_count >= 5 }
+
+        # useless but still
+        d.add_stop_condition! message: 'second', condition: expr { d.po.resource_count >= 10 }
+
+        d.run!(20)
+
+        expect(d.po.resource_count).to eq 5
+      end
+
+      it 'should continue until the last round if no stop conditions are met' do
+        d = Diagram.new
+
+        d.add_node! Source, name: 's'
+        d.add_node! Gate, name: 'g'
+        d.add_node! Pool, name: 'po'
+        d.add_edge! Edge, from: 's', to: 'g'
+        d.add_edge! Edge, from: 'g', to: 'po'
+
+        d.add_stop_condition! message: 'first', condition: expr { d.po.resource_count > 99 }
+
+        # also useless but still
+        d.add_stop_condition! message: 'second', condition: expr { d.po.resource_count < -1 }
+
+        d.run!(20)
+
+        expect(d.po.resource_count).to eq 20
+
+      end
+
+      it 'complains' do
+        # when users try to add two stop conditions but give them no names
+
+        expect {
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'po'
+          d.add_edge! Edge, from: 's', to: 'g'
+          d.add_edge! Edge, from: 'g', to: 'po'
+
+          d.add_stop_condition! condition: expr { d.po.resource_count > 99 }
+          d.add_stop_condition! condition: expr { d.po.resource_count < -1 }
+
+        }.to raise_error
+
+      end
+
+    end
+
+    describe 'Comprehensive examples' do
 
       it 'example using pull_all and activators' do
 
@@ -485,14 +549,14 @@ describe Diagram do
         d.add_node! Pool, name: 'p4', initial_value: 2
         d.add_node! Pool, name: 'p5', activation: :automatic, initial_value: 6, mode: :push_any
 
-        d.add_edge! Edge, from: 'p2',to:'p1'
-        d.add_edge! Edge, from: 'p3',to:'p1'
-        d.add_edge! Edge, from: 'p4',to:'p1'
+        d.add_edge! Edge, from: 'p2', to: 'p1'
+        d.add_edge! Edge, from: 'p3', to: 'p1'
+        d.add_edge! Edge, from: 'p4', to: 'p1'
 
-        d.add_edge! Edge, from: 'p5',to:'p3'
-        d.add_edge! Edge, from: 'p5',to:'p4'
+        d.add_edge! Edge, from: 'p5', to: 'p3'
+        d.add_edge! Edge, from: 'p5', to: 'p4'
 
-        d.p5.attach_condition{ d.p3.resource_count < 1 && d.p4.resource_count < 1 }
+        d.p5.attach_condition { d.p3.resource_count < 1 && d.p4.resource_count < 1 }
 
         d.run! 8
 
@@ -505,9 +569,6 @@ describe Diagram do
       end
 
 
-
-
-
     end
 
   end

data/testing/spec/gate_spec.rb

@@ -2,6 +2,7 @@ require_relative 'spec_helper'
 
 describe 'Diagrams with gates' do
 
+
   context 'general tests' do
 
     it 'works' do
@@ -20,12 +21,232 @@ describe 'Diagrams with gates' do
 
     end
 
+    it 'has default settings' do
+
+
+      g = Gate.new name: 'g'
+
+      expect(g.mode).to eq(:deterministic)
+      expect(g.name).to eq('g')
+      expect(g.activation).to eq(:passive)
+    end
+
   end
 
   context 'specific features' do
 
-    it 'does not keep resources over turns' do
-      skip
+    # in other words,
+    #   either all floats adding up to 1 (which will be interpreted as probabilities that one will be chosen)
+    #   or all integers (which will be interpreted )
+    context 'outgoing edges' do
+
+      it 'errors when one is fraction and another integer' do
+
+        expect {
+
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'p1'
+          d.add_node! Pool, name: 'p2'
+
+
+          d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+          d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 1/2
+          d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 4
+
+          d.run! 10
+
+        }.to raise_error(BadConfig)
+      end
+
+      it 'compiles when both are integer' do
+
+        expect {
+
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'p1'
+          d.add_node! Pool, name: 'p2'
+
+
+          d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+          d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 5
+          d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 4
+
+          d.run! 10
+
+        }.not_to raise_error
+
+      end
+
+      it 'compiles when both are fractions and add up to 1' do
+
+        # well-behaved labels
+        expect {
+
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'p1'
+          d.add_node! Pool, name: 'p2'
+
+
+          d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+          d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 1/2
+          d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 1/2
+
+          d.run! 10
+
+        }.not_to raise_error
+
+        # badly behaved labels
+        expect {
+
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'p1'
+          d.add_node! Pool, name: 'p2'
+
+
+          d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+          d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 3/21
+          d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 18/21
+
+          d.run! 10
+
+        }.not_to raise_error
+
+      end
+
+      it "errors when fraction labels don't add up to one" do
+        # less than 1
+        expect{
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'p1'
+          d.add_node! Pool, name: 'p2'
+          d.add_node! Pool, name: 'p3'
+
+
+          d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+          d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 1/9
+          d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 8/77
+          d.add_edge! Edge, name: 'e4', from: 'g', to: 'p3', label: 2/17
+
+          d.run! 10
+        }.to raise_error(BadConfig)
+
+        # greater than 1 but each one not greater than 1
+        expect{
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'p1'
+          d.add_node! Pool, name: 'p2'
+
+
+          d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+          d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 4/9
+          d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 11/12
+
+          d.run! 10
+        }.to raise_error(BadConfig)
+
+        # greater than 1 but a single label is greater than 1
+        expect{
+          d = Diagram.new
+
+          d.add_node! Source, name: 's'
+          d.add_node! Gate, name: 'g'
+          d.add_node! Pool, name: 'p1'
+          d.add_node! Pool, name: 'p2'
+
+
+          d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+          d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 22/9
+          d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 1/12
+
+          d.run! 10
+        }.to raise_error(BadConfig)
+      end
+
+    end
+
+    it 'probabilistic gates send resources in a non-deterministic way' do
+
+      no_of_turns = 100
+
+      d = Diagram.new
+
+      d.add_node! Source, name: 's'
+      d.add_node! Gate, name: 'g', mode: :probabilistic
+
+      d.add_node! Pool, name: 'p1'
+      d.add_node! Pool, name: 'p2'
+      d.add_node! Pool, name: 'p3'
+
+      d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+
+      d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 1/2
+      d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 1/4
+      d.add_edge! Edge, name: 'e4', from: 'g', to: 'p3', label: 1/4
+
+      d.run! no_of_turns
+
+      # have to deal with probabilities here
+      expect(d.get_node('p1').resource_count).to be_within(10).of(50)
+      expect(d.get_node('p2').resource_count).to be_within(10).of(25)
+      expect(d.get_node('p3').resource_count).to be_within(10).of(25)
+
+      # this should work in  most cases
+      expect(d.get_node('p2').resource_count).not_to eq(d.get_node('p3').resource_count)
+
+      # the sum must remain constant
+      p1_res = d.get_node('p1').resource_count
+      p2_res = d.get_node('p2').resource_count
+      p3_res = d.get_node('p3').resource_count
+
+      sum_res = p1_res + p2_res + p3_res
+      expect(sum_res).to eq no_of_turns
+
+    end
+
+    it 'deterministic gates always distribute resources in the same order (integer labels)' do
+
+      d = Diagram.new
+
+      d.add_node! Source, name: 's'
+      d.add_node! Gate, name: 'g', mode: :deterministic
+
+      d.add_node! Pool, name: 'p1'
+      d.add_node! Pool, name: 'p2'
+      d.add_node! Pool, name: 'p3'
+
+      d.add_edge! Edge, name: 'e1', from: 's', to: 'g'
+
+      d.add_edge! Edge, name: 'e2', from: 'g', to: 'p1', label: 2
+      d.add_edge! Edge, name: 'e3', from: 'g', to: 'p2', label: 1
+      d.add_edge! Edge, name: 'e4', from: 'g', to: 'p3', label: 1
+
+      # if resources are shared deterministically and the number of turns
+      # is a multiple of the number of outgoing edges then there should be
+      # a predictably defined number of resources in each pool
+      d.run! 12
+
+      expect(d.get_node('p1').resource_count).to eq(6)
+      expect(d.get_node('p2').resource_count).to eq(3)
+      expect(d.get_node('p3').resource_count).to eq(3)
+
     end
 
   end