pitchcar 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0b54b3e0e398d6dee15a2c15379efa23ced9a327
+  data.tar.gz: 5b0c6ecfefc77fb815fd33b140a27f906f8922f4
+SHA512:
+  metadata.gz: 45e2206b61b7a56e40784fe507d60a71759393a73a5204e16ed6bf86a2cb2be1241a1bf1cf9e7ff6653090b5aa91da2d18bf784d5b338af3e0703b297e8851e9
+  data.tar.gz: 6de830f9c750dd966cb53dd391747b579a33055e60d4279f6f84e8e69c72dff8d9b45cc720405e2d37211c19be5c11d1b3725744cd753337e1f02f6890e8c835

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2016 Jonah Hirsch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/Readme.md

@@ -0,0 +1,42 @@
+# PitchCar Track Generator
+
+Generates all possible tracks, or a single random valid track, for
+[PitchCar](https://boardgamegeek.com/boardgame/150/pitchcar)
+
+## Rules:
+* Tracks will always begin with a straight piece
+* Tracks must not overlap
+* Tracks must form a complete look
+* Track must not already have been found as a rotation
+
+All possible values for a basic PitchCar set (10 curves, 6 straight pieces)
+are provided in `pitchcar_tracks`
+* `Slw` = Straight piece with left wall
+* `Srw` = Straight piece with right wall
+* `R` = Right Turn
+* `L` = Left Turn
+
+## Usage:
+### Generate all possible tracks
+```ruby
+require_relative 'finder.rb'
+# tracks = Pitchcar::Finder.find_all_tracks(STRAIGHT_PIECES, LEFT_RIGHT_PIECES)
+tracks = Pitchcar::Finder.find_all_tracks(6, 10)
+tracks.first.to_s # => 'Slw Slw Slw Slw L Slw L Slw L R R L L R L L'
+```
+
+### Find a random valid track
+```ruby
+require_relative 'finder.rb'
+# track = Pitchcar::Finder.random_valid_track(STRAIGHT_PIECES, LEFT_RIGHT_PIECES)
+track = Pitchcar::Finder.random_valid_track(6, 10)
+track.to_s # => 'Slw Slw L Slw R R Slw Slw R L R R L Slw R R'
+```
+
+### Find `n` random valid tracks
+```ruby
+require_relative 'finder.rb'
+# tracks = Pitchcar::Finder.random_valid_tracks(STRAIGHT_PIECES, LEFT_RIGHT_PIECES, COUNT)
+track = Pitchcar::Finder.random_valid_tracks(6, 10, 4)
+track.map(&:to_s) # => ["Slw Srw L R Srw L L Srw R L L Slw R Slw L L", "Slw L Slw L Slw R Srw L L R L Srw L R L Slw", "Slw R Slw Slw R Slw Srw L R R Srw R L R L R", "Slw Slw L Srw L R L Srw R L L Srw L R Slw L"]
+```

data/boyermoore.rb

@@ -0,0 +1,117 @@
+# From https://github.com/jashmenn/boyermoore
+
+# Hash impersonator that accepts regular expressions as keys.  But the regular
+# expression lookups are slow, so don't use them (unless you have to).
+class RichHash
+  def initialize
+    @regexps = {}
+    @regular = {}
+  end
+
+  def [](k)
+    regular = @regular[k]
+    return regular if regular
+    if @regexps.size > 0
+      @regexps.each do |regex,v| # linear search is going to be slow
+        return v if regex.match(k)
+      end
+    end
+    nil
+  end
+
+  def []=(k,v)
+    if k.kind_of?(Regexp)
+      @regexps[k] = v
+    else
+      @regular[k] = v
+    end
+  end
+end
+
+# ported directly from this version wikipedia:
+# http://en.wikipedia.org/w/index.php?title=Boyer%E2%80%93Moore_string_search_algorithm&diff=391986850&oldid=391398281
+# it's not very rubyish but it works
+module BoyerMoore
+
+  def self.compute_prefix(str)
+    size = str.length
+    k = 0
+    result = [0]
+    1.upto(size - 1) do |q|
+      while (k > 0) && (str[k] != str[q])
+        k = result[k-1]
+      end
+      k += 1 if(str[k] == str[q])
+      result[q] = k
+    end
+    result
+  end
+
+  def self.prepare_badcharacter_heuristic(str)
+    result = RichHash.new
+    0.upto(str.length - 1) do |i|
+      result[str[i]] = i
+    end
+    result
+  end
+
+  def self.prepare_goodsuffix_heuristic(normal)
+    size = normal.size
+    result = []
+
+    reversed = normal.dup.reverse
+    prefix_normal = compute_prefix(normal)
+    prefix_reversed = compute_prefix(reversed)
+
+    0.upto(size) do |i|
+      result[i] = size - prefix_normal[size-1]
+    end
+
+    0.upto(size-1) do |i|
+      j = size - prefix_reversed[i]
+      k = i - prefix_reversed[i]+1
+      result[j] = k if result[j] > k
+    end
+    result
+  end
+
+  def self.search(haystack, needle)
+    needle_len = needle.size
+    haystack_len = haystack.size
+
+    return nil if haystack_len == 0
+    return haystack if needle_len == 0
+
+    badcharacter = self.prepare_badcharacter_heuristic(needle)
+    goodsuffix   = self.prepare_goodsuffix_heuristic(needle)
+
+    s = 0
+    while s <= haystack_len - needle_len
+      j = needle_len
+      while (j > 0) && self.needle_matches?(needle[j-1], haystack[s+j-1])
+        j -= 1
+      end
+
+      if(j > 0)
+        k = badcharacter[haystack[s+j-1]]
+        k = -1 unless k
+        if (k < j) && (m = j-k-1) > goodsuffix[j]
+          s += m
+        else
+          s += goodsuffix[j]
+        end
+      else
+        return s
+      end
+    end
+    return nil
+  end
+
+  def self.needle_matches?(needle, haystack)
+    if needle.kind_of?(Regexp)
+      needle.match(haystack) ? true : false
+    else
+      needle == haystack
+    end
+  end
+end

data/finder.rb

@@ -0,0 +1,50 @@
+require_relative 'piece'
+require_relative 'track'
+
+module Pitchcar
+  class Finder
+
+    class << self
+      def find_all_tracks(straight, left_right)
+        tracks = find_tracks(straight - 1, left_right, 'S', [])
+        tracks.map(&:with_wall_combinations).flatten
+      end
+
+      def random_valid_track(straight, left_right)
+        track = nil
+        track = random_track(straight, left_right) until !track.nil? && track.valid?
+        track.with_wall_combinations.sample
+      end
+
+      def random_valid_tracks(straight, left_right, count = 2)
+        tracks = []
+        count.times { tracks << random_valid_track(straight, left_right) }
+        tracks
+      end
+
+      private
+
+      def find_tracks(straight, left_right, track_pieces, tracks)
+        print "Found #{tracks.size} tracks\r"
+        track = Track.build_from(track_pieces)
+        return false if track.overlaps?
+
+        return tracks << track if straight == 0 && left_right == 0 && track.valid?(tracks)
+        [track_pieces].product((['S'] * straight + ['L'] * left_right + ['R'] * left_right).uniq).each do |result|
+          if result[1] == 'S'
+            find_tracks(straight - 1, left_right, result.join, tracks)
+          else
+            find_tracks(straight, left_right - 1, result.join, tracks)
+          end
+        end
+        tracks
+      end
+
+      def random_track(straight, left_right)
+        left = Random.rand(1..left_right)
+        right = left_right - left
+        Track.build_from("S#{'S' * (straight - 1)}#{'L' * left}#{'R' * right}".split('').shuffle.join)
+      end
+    end
+  end
+end

data/piece.rb

@@ -0,0 +1,66 @@
+require 'json'
+
+module Pitchcar
+  class Piece
+    TYPES = { STRAIGHT: 0, LEFT: 1, RIGHT: 2, STRAIGHT_LEFT_WALL: 3, STRAIGHT_RIGHT_WALL: 4 }
+    DIRECTIONS = { NORTH: 0, EAST: 1, WEST: 2, SOUTH: 3 }
+    attr_accessor :direction, :x, :y, :type
+
+    def self.starting_piece
+      piece = new
+      piece.x = 0
+      piece.y = 0
+      piece.type = TYPES[:STRAIGHT]
+      piece.direction = DIRECTIONS[:SOUTH]
+      piece
+    end
+
+    def self.type_from_string(string)
+      case string
+      when 'S'
+        TYPES[:STRAIGHT]
+      when 'L'
+        TYPES[:LEFT]
+      when 'R'
+        TYPES[:RIGHT]
+      end
+    end
+
+    def next_direction(from)
+      case type
+        when TYPES[:LEFT]
+        case from
+        when DIRECTIONS[:NORTH]
+          DIRECTIONS[:WEST]
+        when DIRECTIONS[:EAST]
+          DIRECTIONS[:NORTH]
+        when DIRECTIONS[:WEST]
+          DIRECTIONS[:SOUTH]
+        when DIRECTIONS[:SOUTH]
+          DIRECTIONS[:EAST]
+        end
+      when TYPES[:RIGHT]
+        case from
+        when DIRECTIONS[:NORTH]
+          DIRECTIONS[:EAST]
+        when DIRECTIONS[:EAST]
+          DIRECTIONS[:SOUTH]
+        when DIRECTIONS[:WEST]
+          DIRECTIONS[:NORTH]
+        when DIRECTIONS[:SOUTH]
+          DIRECTIONS[:WEST]
+        end
+      else
+        from
+      end
+    end
+
+    def to_s
+      TYPES.key(type).to_s.split('_').map { |word| word[0] }.join.downcase.capitalize
+    end
+
+    def to_h
+      { x: x, y: y, type: TYPES.key(type).downcase, direction: DIRECTIONS.key(direction).downcase }
+    end
+  end
+end