crafting_table 0.3.0

data/features/support/env.rb

@@ -0,0 +1,29 @@
+#coding: utf-8
+
+require_relative '../../lib/crafting_table'
+
+ITEM_FILE = 'data/test/items/vanilla.yml'
+RECIPE_FILE = 'data/test/recipes/vanilla.yml'
+
+def string_to_boolean(string)
+
+  if string.downcase =~ /yes|y/
+    true
+  elsif string.downcase =~ /no|n/
+    false
+  else
+    raise ArgumentError
+  end
+
+end
+
+def string_to_range_or_integer(string)
+  if string =~ /^[0-9]+$/
+    string.to_i
+  elsif string =~ /^[0-9]+\.\.[0-9]+$/
+    Range.new(*string.split('..').map(&:to_i))
+  else
+    fail "Could not convert #{ string.inspect } to range or integer."
+  end
+end
+

data/lib/crafting_table.rb

@@ -0,0 +1,19 @@
+#coding: utf-8
+
+require_relative 'crafting_table/item_manager'
+require_relative 'crafting_table/item'
+
+require_relative 'crafting_table/recipe_manager'
+require_relative 'crafting_table/recipe'
+
+require_relative 'crafting_table/search/search_builder'
+require_relative 'crafting_table/search/name_search'
+require_relative 'crafting_table/search/fuzzy_name_search'
+require_relative 'crafting_table/search/damage_search'
+require_relative 'crafting_table/search/item_id_search'
+require_relative 'crafting_table/search/input_search'
+require_relative 'crafting_table/search/output_search'
+
+module CraftingTable
+
+end

data/lib/crafting_table/item.rb

@@ -0,0 +1,61 @@
+#coding: utf-8
+
+module CraftingTable
+
+  # A class representing a single item.
+  # An item, in this case, can be any block, tool, loot etc.
+  #
+  # @author Michael Senn <morrolan@morrolan.ch>
+  # @since 0.1
+  class Item
+    attr_reader :name, :item_id, :damage_value
+
+    # Create a new Item.
+    #
+    # @example Spruce Wood
+    #   item = Item.new('Spruce Wood', 17, 1)
+    #
+    # @example Glass
+    #   item = Item.new('Glass', 20, :any)
+    #
+    # @param [String] name The item's name.
+    # @param [Integer, Symbol] damage_value The item's damage / meta value.
+    # @param [Integer] item_id The item's ID.
+    def initialize(name, item_id, damage_value = 0)
+      @name, @item_id, @damage_value = name, item_id, damage_value
+    end
+
+    # Compare two items for equality.
+    #
+    # Two items are considered equal, if their name, item ID and damage value are equal.
+    #
+    # @param [Item] other Item which to compare for equality.
+    # @return [Boolean] Whether the two items are equal.
+    def ==(other)
+      name == other.name && item_id == other.item_id && damage_value == other.damage_value
+    end
+
+    alias_method(:eql?, :==)
+
+    # Return reasonable hash value of this item.
+    #
+    # @since 0.2
+    # 
+    # @return [Integer] Hash of item's name, id and damage value.
+    def hash
+      [name, item_id, damage_value].hash
+    end
+
+    # Return a unique identifier of this item.
+    # The identifier is an array, containing its ID and damage value
+    #
+    # @since 0.2
+    #
+    # @return [Array<Integer>] Unique identifier of this item.
+    def identifier
+      [item_id, damage_value]
+    end
+    
+  end
+
+end

data/lib/crafting_table/item_manager.rb

@@ -0,0 +1,171 @@
+#coding: utf-8
+
+require 'yaml'
+
+module CraftingTable
+
+  # A class which contains items, and allows to search through them.
+  #
+  # @author Michael Senn <morrolan@morrolan.ch>
+  # @since 0.1
+  class ItemManager
+    attr_reader :items
+
+    # Create a new ItemManager
+    #
+    # @param [Array] items Array of items with which to initialize the item manager.
+    def initialize(items = [])
+      @items = items.to_ary
+    end
+
+    # Add a new item to the internal collection.
+    #
+    # @param [Item] item Item which to add to the collection.
+    # @return [void]
+    def add(item)
+      @items << item
+    end
+
+    # Add new items by reading them from a YAML file.
+    #
+    # @param [String] path The path to the file from which to read items from.
+    # @return [void]
+    def add_from_file(path)
+      YAML.load_file(path).each do |hash|
+        add(Item.new(hash['name'], hash['id'], hash['damage']))
+      end
+    end
+
+    # Clear the internal collection of items.
+    # @return [void]
+    def clear
+      @items.clear
+    end
+
+    # Find items by their name.
+    #
+    # @deprecated Use {#find} instead
+    #
+    # @example Search using default parameters.
+    #   manager.find_by_name('Stone').map(&:name) #=> ['Stone']
+    #
+    # @example Case-insensitive search, non-exact matching.
+    #   manager.find_by_name('stone', exact: false, case_sensitive: false).map(&:name) #=> ['Stone', 'Sandstone', '...']
+    #
+    # @param [String] name The name for which to search.
+    # @param [Hash] options Options which influence the search.
+    # @option options [Boolean] :exact (true) Whether to match names exactly.
+    # @option options [Boolean] :case_sensitive (true) Whether to search case-sensitively.
+    # @return [Array<Item>] Collection of items which matched the search condition.
+    def find_by_name(name, options = {})
+      default_options = { exact: true, case_sensitive: true }
+      default_options.update(options)
+
+      if default_options[:case_sensitive]
+        if default_options[:exact]
+          items.select { |item| item.name == name }
+        else
+          items.select { |item| item.name.include? name }
+        end
+      else
+        if default_options[:exact]
+          items.select { |item| item.name.downcase == name.downcase }
+        else
+          items.select { |item| item.name.downcase.include? name.downcase }
+        end
+      end
+    end
+
+    # Find items by their ID.
+    #
+    # @deprecated Use {#find} instead
+    #
+    # @example Searching for single ID.
+    #   manager.find_by_item_id(17).first.name #=> 'Wood'
+    #
+    # @example Searching for range of IDs.
+    #   manager.find_by_item_id(14..16).map(&:name) #=> ['Gold Ore', 'Iron Ore', 'Coal Ore']
+    #
+    # @example Searching for collection of IDs.
+    #   manager.find_by_item_id([1, 3, 24]).map(&:name) #=> ['Stone', 'Dirt', 'Sandstone']
+    #
+    # @param [#include?, Integer] id A collection of IDs, or a single ID, for which to search.
+    # @return [Array<Item>] Collection of items which matched the search condition.
+    def find_by_item_id(id)
+      if id.respond_to? :include?
+        items.select { |item| id.include? item.item_id }
+      else
+        items.select { |item| item.item_id == id }
+      end
+    end
+
+    # Find items.
+    #
+    # @since 0.3
+    #
+    # @example Searching for name and damage value
+    #   results = manager.find do |search|
+    #     search.name = 'Wood'
+    #     search.exact = false
+    #     search.damage_value = 3
+    #    end
+    #    results.first.name #=> 'Jungle Wood'
+    #
+    # @example Searching for range of item IDs and two specific damage values
+    #   results = manager.find do |search|
+    #     search.item_id = 1..20
+    #     search.damage_value = [1, 3]
+    #   end
+    #   results.map(&:name) #=> ['Spruce Sapling', 'Jungle Sapling', 'Spruce Wood', 'Jungle Wood', 'Spruce Leaves', 'Jungle Leaves']
+    #
+    # @yieldparam builder [SearchBuilder]
+    #   An instance of the SearchBuilder class which allows to easily specify
+    #   multiple search conditions.
+    #
+    # @return [Array<Item>] Items which matched the search conditions.
+    def find(&block)
+      builder = Search::SearchBuilder.new
+      yield builder
+      
+      builder.searches.inject(items) { |items, search| search.apply_to(items) }
+    end
+
+    # Find items by their damage value.
+    #
+    # @deprecated Use {#find} instead
+    #
+    # @example Searching for single damage value.
+    #   manager.find_by_damage_value(2).map(&:name) #=> ['Birch Wood', '...']
+    #
+    # @example Searching for range of damage values.
+    #   manager.find_by_damage_value(1..2).map(&:name) #=> ['Spruce Wood', 'Birch Wood', '...']
+    #
+    # @example Searching for collection of damage values.
+    #   manager.find_by_damage_value([1, 3]).map(&:name) #=> ['Spruce Wood', 'Jungle Wood', '...']
+    #
+    # @param [#include?, Integer] id A collection of damage values, or a single damage value, for which to search.
+    # @return [Array<Item>] Collection of items which matched the search condition.
+    def find_by_damage_value(damage)
+      if damage.is_a?(Symbol) || !damage.respond_to?(:include?)
+        items.select { |item| item.damage_value == damage }
+      else
+        items.select { |item| damage.include? item.damage_value }
+      end
+    end
+
+    # Find items by their identifier.
+    #
+    # @see Item#identifier
+    # @since 0.2
+    #
+    # @param [Array<Integer>] identifier Identifier for which to
+    #search.
+    # @return [Array<Item>] Collection of items which matched
+    #   the search condition.
+    def find_by_identifier(identifier)
+      items.select { |item| item.identifier == identifier }
+    end
+
+  end
+
+end

data/lib/crafting_table/recipe.rb

@@ -0,0 +1,36 @@
+#coding: utf-8
+
+module CraftingTable
+
+  # A class representing a single recipe.
+  # A recipe has a name, one to n inputs, and one to n outputs.
+  #
+  # @author Michael Senn <morrolan@morrolan.ch>
+  # @since 0.2
+  class Recipe
+    attr_reader :name, :input, :output
+
+    # Create a new recipe.
+    #
+    # @example Torch
+    #   recipe = Recipe.new('Torch',
+    #                       { Item.new('Coal', 263, 0) => 1,
+    #                         Item.new('Stick', 280, 0) => 1 },
+    #                       { Item.new('Torch', 50, 0) => 4 })
+    #
+    # @param [String] name The recipe's name
+    # @param [Hash{Item => Integer}] input
+    #   A hash of items and their amounts which are required to craft
+    #   the recipe.
+    # @param [Hash{Item => Integer}] output
+    #   A hash of items and their amounts which you get when crafting
+    #   the recipe.
+    def initialize(name, input, output)
+      @name, @input, @output = name, input, output
+    end
+
+  end
+
+end
+
+

data/lib/crafting_table/recipe_manager.rb

@@ -0,0 +1,216 @@
+#coding: utf-8
+
+module CraftingTable
+
+  # A class which contains recipes, and allows to search through them.
+  #
+  # @author Michael Senn <morrolan@morrolan.ch>
+  # @since 0.2
+  class RecipeManager
+    attr_reader :recipes
+    attr_reader :item_manager
+
+    # Create a new RecipeManager
+    #
+    # @param [ItemManager] item_manager ItemManager which contains the items
+    #   on which this manager's recipes are based.
+    def initialize(item_manager)
+      @item_manager = item_manager
+      @recipes = []
+    end
+
+    # Add a new recipe to the internal collection.
+    #
+    # @param [Recipe] recipe Recipe which to add to the collection.
+    # @return [void]
+    def add(recipe)
+      @recipes << recipe
+    end
+
+    # Add new recipes by reading them from a YAML file.
+    #
+    # @param [String] path The path to the file from which to read
+    #   recipes from.
+    # @return [void]
+    def add_from_file(path)
+      YAML.load_file(path).each do |recipe_hash|
+        raw_input = recipe_hash.fetch('input', {})
+        raw_output = recipe_hash.fetch('output', {})
+        name = recipe_hash.fetch('name', 'UNKNOWN')
+
+        input = {}
+        output = {}
+        raw_input.each do |identifier_string, amount|
+          identifier = identifier_string.split(':').map(&:to_i)
+          item = item_manager.find_by_identifier(identifier).first
+          input[item] = amount
+        end
+
+        raw_output.each do |identifier_string, amount|
+          identifier = identifier_string.split(':').map(&:to_i)
+          item = item_manager.find_by_identifier(identifier).first
+          output[item] = amount
+        end
+
+        @recipes << Recipe.new(name, input, output)
+      end
+      
+    end
+
+    # Clear the internal collection of recipes.
+    # @return [void]
+    def clear
+      @recipes.clear
+    end
+
+    # Find recipes.
+    #
+    # @since 0.3
+    #
+    # @example Searching for name.
+    #   results = manager.find do |search|
+    #     search.name = 'slab'
+    #     search.exact = false
+    #     search.case_sensitive = false
+    #   end
+    #   results.map(&:name)
+    #   #=> ['Cobblestone slab', 'Wooden slab', 'Stone slab', '...']
+    #
+    # @example Searching for recipes which result in torch(es).
+    #   manager.find do |search|
+    #     manager.output = Item.new('Torch', 50)
+    #   end
+    #
+    # @example Searching for recipes which require oak planks.
+    #   results = manager.find do |search|
+    #     manager.input = Item.new('Oak Wood Planks', 5)
+    #   end
+    #   results.map(&:name)
+    #   #=> ['Sticks', 'Crafting Table', 'Chest', 'Bed', '...']
+    #
+    # @yieldparam builder [SearchBuilder]
+    #   An instance of the SearchBuilder class which allows to easily specify
+    #   multiple search conditions.
+    #
+    # @return [Array<Recipe>] Recipes which matched the search conditions.
+    def find(&block)
+      builder = Search::SearchBuilder.new
+      yield builder
+
+      builder.searches.inject(recipes) { |recipes, search| search.apply_to(recipes) }
+    end
+
+    # Find recipes by their name.
+    #
+    # @deprecated Use {#find} instead.
+    #
+    # @example Search using default parameters.
+    #   manager.find_by_name('Torch').first.input.map(&:name) #=> ['Wooden Planks', 'Coal']
+    #
+    # @example Case-insensitive search, non-exact matching.
+    #   manager.find_by_name('slab').map(&:name) #=> ['Cobblestone Slab', 'Wooden slab', 'Stone slab', '...']
+    #
+    # @param [String] name The name for which to search.
+    # @param [Hash] options Options which influence the search.
+    # @option options [Boolean] :exact (true) Whether to match names exactly.
+    # @option options [Boolean] :case_sensitive (true) Whether to search case-sensitively.
+    # @return [Array<Recipe>] Collection of recipes which matched the search condition.
+    def find_by_name(name, options = {})
+      default_options = { exact: true, case_sensitive: true }
+      default_options.update(options)
+
+      if default_options[:case_sensitive]
+        if default_options[:exact]
+          recipes.select { |recipe| recipe.name == name }
+        else
+          recipes.select { |recipe| recipe.name.include? name }
+        end
+      else
+        if default_options[:exact]
+          recipes.select { |recipe| recipe.name.downcase == name.downcase }
+        else
+          recipes.select { |recipe| recipe.name.downcase.include? name.downcase }
+        end
+      end
+    end
+
+    # Find recipes by their input.
+    #
+    # @deprecated Use {#find} instead.
+    #
+    # @example Searching for recipes which require planks.
+    #   manager.find_by_input(Item.new('Oak Wood Planks', 5, 0)).map(&:name)
+    #   #=> ['Sticks', 'Crafting Table', 'Chest', 'Bed', '...']
+    #
+    # @param [Item] item Item for which to search.
+    # @return [Array<Recipe>] Collection of recipes which matched the search condition.
+    def find_by_input(item)
+      recipes.select { |recipe| recipe.input.key? item }
+    end
+
+    # Find recipes by their output.
+    #
+    # @deprecated Use {#find} instead.
+    #
+    # @example Searching for recipes which result in Coal.
+    #   manager.find_by_output(Item.new('Coal', 263, 0)).map(&:name)
+    #   #=> ['Coal']
+    # @return [Array<Recipe>]
+    #   Collection of recipes which matched the search condition.
+    def find_by_output(item)
+      recipes.select { |recipe| recipe.output.key? item }
+    end
+
+    # Resolve a recipe into its base components.
+    #
+    # @since 0.3
+    # 
+    # @example Components required to craft 50 torches.
+    #   torch = recipe_manager.find_by_name('Torch').first
+    #   components = recipe_manager.resolve_recipe(recipe_torch, 50)
+    #   components.map { |item, amount| item.name => amount }
+    #   #=> { "Wood" => 2, "Coal" => 13 }
+    #
+    # @param [Recipe] recipe
+    #   The recipe which to resolve to its components.
+    # @param [Integer] amount Desired amount of the recipe.
+    # @return [Hash{Item => Integer}]
+    #   A hash mapping the base components
+    #   to the required amount of each.
+    def resolve_recipe(recipe, amount)
+      # Todo: Allow to specify arbitrary outputs.
+      # Todo: Fail if the specified output is not part of the recipe.
+      desired_output = recipe.output.keys.first
+      amount_per_iteration = recipe.output[desired_output]
+      # If we get four items per iteration, and want 21 items in
+      # total, we'll need 6 iterations.
+      iterations = (amount.to_f / amount_per_iteration).ceil
+
+      requirements = Hash.new(0)
+      
+      recipe.input.each do |input, amount|
+        # Finding potential recipes for the input.
+        recipes_for_input = find_by_output(input)
+
+        # Todo: Allow for other criteria where the recipe should be ignored.
+        if recipes_for_input.empty?
+          requirements[input] += amount * iterations
+        else
+          recipe_for_input = recipes_for_input.first
+          requirements_for_input = resolve_recipe(recipe_for_input,
+                                                  amount * iterations)
+
+          requirements.merge!(requirements_for_input) do |key, old_amount, new_amount|
+            old_amount + new_amount
+          end
+
+        end
+      end
+
+      requirements
+      
+    end
+        
+  end
+
+end