craftingguide/website
1
0
Fork 0
Code Pull Requests Actions Activity

Complete refactoring to move Recipes into Items

Browse Source 
* Changed "version" to "dataVersion" in data format
* Changed the "modName" and "modVersion" fields on the ModVersion
  class to remove the "mod" prefix and changed the data format to
  match
* Change the Stack class to use the itemSlug instead of the item
  itself
* Update the ModVersion and ModPack classes to include methods for
  recording a correspondence between slugs and names. Update code
  which displays items from stacks to use these methods to determine
  display names.
* Add a reference from Recipe back to the item it creates
This commit is contained in:
Andrew Miner
2015-01-03 20:08:11 -08:00
parent 392c410df8
commit 0d25ac723d
24 changed files with 260 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/crafting_plan.test.coffee
+3 -5
View File
@@ -19,9 +19,9 @@ describe 'CraftingPlan', ->
beforeEach ->
modPack = new ModPack
modPack.loadModVersionData {
version: 1
mod_name: 'Minecraft'
mod_version: '1.7.10'
dataVersion: 1
name: 'Minecraft'
version: '1.7.10'
recipes: [
{ input:'Oak Log', output:[[4, 'Oak Plank']] }
{ input:[[2, 'Oak Plank']], output:[[4, 'Stick']] }
@@ -31,8 +31,6 @@ describe 'CraftingPlan', ->
{ input:[[2, 'Iron Ingot'], 'Stick'], tools:'Crafting Table', output:'Iron Sword' }
]
}
logger.debug "modPack: #{modPack}"
logger.debug "modVersion: #{modPack.modVersions[0]}"
plan = new CraftingPlan modPack
test/inventory.test.coffee
+19 -20
View File
@@ -20,30 +20,30 @@ describe 'Inventory', ->
beforeEach ->
inventory = new Inventory
inventory.add new Item(name:'Wool'), 4
inventory.add new Item(name:'String'), 20
inventory.add new Item(name:'Boat')
inventory.add 'wool', 4
inventory.add 'string', 20
inventory.add 'boat'
describe 'add', ->
it 'can add to an empty inventory', ->
inventory.add new Item(name:'Iron Ingot'), 4
inventory.add 'iron_ingot', 4
stack = inventory._stacks['iron_ingot']
stack.constructor.name.should.equal 'Stack'
stack.name.should.equal 'Iron Ingot'
stack.itemSlug.should.equal 'iron_ingot'
stack.quantity.should.equal 4
it 'can augment quantity of existing items', ->
inventory.add new Item(name:'Wool'), 2
inventory.add 'wool', 2
inventory.toList().should.eql ['boat', [20, 'string'], [6, 'wool']]
it 'can add zero quantity', ->
inventory.add new Item(name:'Wool'), 0
inventory.add 'wool', 0
inventory.toList().should.eql ['boat', [20, 'string'], [4, 'wool']]
it 'emits the proper events', ->
events = new EventRecorder inventory
inventory.add new Item(name:'Iron Ingot'), 10
inventory.add 'iron_ingot', 10
events.names.should.eql [Event.add, Event.change]
describe 'addInventory', ->
@@ -55,7 +55,7 @@ describe 'Inventory', ->
it 'can add a mix of new and existing items', ->
newInventory = new Inventory
newInventory.add new Item(name:'String'), 2
newInventory.add 'string', 2
newInventory.addInventory inventory
newInventory.toList().should.eql ['boat', [22, 'string'], [4, 'wool']]
@@ -68,7 +68,6 @@ describe 'Inventory', ->
it 'faithfully copies an existing inventory', ->
copy = inventory.clone()
logger.debug "copy.toList(): #{copy.toList()}"
copy.toList().should.eql ['boat', [20, 'string'], [4, 'wool']]
describe 'each', ->
@@ -81,17 +80,17 @@ describe 'Inventory', ->
it 'works when items have only been added', ->
result = []
inventory.each (stack)-> result.push stack.name
result.should.eql ['Boat', 'String', 'Wool']
inventory.each (stack)-> result.push stack.itemSlug
result.should.eql ['boat', 'string', 'wool']
it 'works when items have been augmented', ->
inventory.add new Item name:'Iron Ingot'
inventory.add new Item name:'Boat'
inventory.add new Item(name:'Wool'), 2
inventory.add 'iron_ingot'
inventory.add 'boat'
inventory.add 'wool', 2
result = []
inventory.each (stack)-> result.push stack.name
result.should.eql ['Boat', 'Iron Ingot', 'String', 'Wool']
inventory.each (stack)-> result.push stack.itemSlug
result.should.eql ['boat', 'iron_ingot', 'string', 'wool']
describe 'hasAtLeast', ->
@@ -101,7 +100,7 @@ describe 'Inventory', ->
it 'always returns true for zero quantity', ->
inventory.hasAtLeast('chicken', 0).should.be.true
inventory.hasAtLeast('Wool', 0).should.be.true
inventory.hasAtLeast('wool', 0).should.be.true
it 'works for a quantity above 1', ->
inventory.hasAtLeast('wool', 3).should.be.true
@@ -117,7 +116,7 @@ describe 'Inventory', ->
it 'completely removes the last item', ->
stack = inventory.pop()
stack.name.should.equal 'Wool'
stack.itemSlug.should.equal 'wool'
stack.quantity.should.equal 4
inventory.toList().should.eql ['boat', [20, 'string']]
@@ -134,7 +133,7 @@ describe 'Inventory', ->
it 'throws when the item has insufficient quantity', ->
expect(-> inventory.remove('wool', 10)).to.throw Error,
'cannot remove 10 wool because there is only 4 in this inventory'
'cannot remove 10: only 4 wool in this inventory'
it 'removes a single item by default', ->
inventory.remove 'wool'
test/inventory_parser.test.coffee
+1 -1
View File
@@ -37,6 +37,6 @@ describe 'InventoryParser', ->
it 're-uses the given inventory object', ->
inventory = new Inventory
inventory.add new Item(name:'String'), 8
inventory.add 'string', 8
result = parser.parse '4 Wool', inventory
result.toList().should.eql [[8, 'string'], [4, 'wool']]
test/mod_pack.test.coffee
+3 -3
View File
@@ -18,15 +18,15 @@ buildcraft = industrialCraft = minecraft = modPack = null
describe 'ModPack', ->
beforeEach ->
minecraft = new ModVersion modName:'Minecraft', modVersion:'1.7.10'
minecraft = new ModVersion name:'Minecraft', version:'1.7.10'
minecraft.addItem new Item name:'Wool'
minecraft.addItem new Item name:'Bed', recipes:['']
buildcraft = new ModVersion modName:'Buildcraft', modVersion:'4.0'
buildcraft = new ModVersion name:'Buildcraft', version:'4.0'
buildcraft.addItem new Item name:'Stone Gear', recipes:['']
buildcraft.addItem new Item name:'Bed', recipes:['']
industrialCraft = new ModVersion modName:'Industrial Craft', modVersion:'2.0'
industrialCraft = new ModVersion name:'Industrial Craft', version:'2.0'
industrialCraft.addItem new Item name:'Resin'
industrialCraft.addItem new Item name:'Rubber', recipes:['']
test/mod_version.test.coffee
+5 -5
View File
@@ -16,15 +16,15 @@ modVersion = null
describe 'ModVersion', ->
beforeEach -> modVersion = new ModVersion modName:'Test', modVersion:'0.0'
beforeEach -> modVersion = new ModVersion name:'Test', version:'0.0'
describe 'constructor', ->
it 'requires a mod name', ->
expect(-> new ModVersion modVersion:'0.0').to.throw Error, 'modName cannot be empty'
expect(-> new ModVersion version:'0.0').to.throw Error, 'name cannot be empty'
it 'requires a mod version', ->
expect(-> new ModVersion modName:'Test').to.throw Error, 'modVersion cannot be empty'
expect(-> new ModVersion name:'Test').to.throw Error, 'version cannot be empty'
it 'supplies default values', ->
modVersion.description.should.equal ''
@@ -44,12 +44,12 @@ describe 'ModVersion', ->
describe 'compareTo', ->
it 'lists required mods first', ->
minecraft = new ModVersion modName:'Minecraft', modVersion:'1.7.10'
minecraft = new ModVersion name:'Minecraft', version:'1.7.10'
modVersion.compareTo(minecraft).should.equal +1
minecraft.compareTo(modVersion).should.equal -1
it 'sorts by name second', ->
buildcraft = new ModVersion modName:'Buildcraft', modVersion:'3.0'
buildcraft = new ModVersion name:'Buildcraft', version:'3.0'
modVersion.compareTo(buildcraft).should.equal +1
buildcraft.compareTo(modVersion).should.equal -1
test/mod_version_parser.test.coffee
+53 -65
View File
@@ -11,7 +11,7 @@ ModVersionParser = require '../src/scripts/models/mod_version_parser'
########################################################################################################################
parser = null
modVersion = parser = null
########################################################################################################################
@@ -19,93 +19,77 @@ describe 'ModVersionParser', ->
describe "V1", ->
before -> parser = new ModVersionParser.V1
describe '_parseItemList', ->
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
it 'can parse an empty list', ->
parser._parseItemList []
_.keys(parser.modVersion.items).should.eql []
it 'can add new items', ->
parser._parseItemList ['Crafting Table', 'Furnace']
_.keys(parser.modVersion.items).should.eql ['crafting_table', 'furnace']
it 'can find existing items', ->
parser.modVersion.addItem new Item name:'Furnace'
parser._parseItemList ['Crafting Table', 'Furnace']
_.keys(parser.modVersion.items).should.eql ['furnace', 'crafting_table']
beforeEach ->
parser = new ModVersionParser.V1
modVersion = parser.modVersion = new ModVersion name:'Test', version:'0.0'
describe '_parseModVersion', ->
it 'requires a mod_name', ->
data = version:1, mod_version:'1.0', items:[]
expect(-> parser._parseModVersion data).to.throw Error, 'mod_name is required'
data = version:'1.0', items:[]
expect(-> parser._parseModVersion data).to.throw Error, 'name is required'
it 'requires a mod_version', ->
data = version:1, mod_name:'Empty', items:[]
expect(-> parser._parseModVersion data).to.throw Error, 'mod_version is required'
data = name:'Empty', items:[]
expect(-> parser._parseModVersion data).to.throw Error, 'version is required'
it 'can parse an empty modVersion', ->
data =
version: 1
mod_name: 'Empty'
mod_version: '1.0'
name: 'Empty'
version: '1.0'
recipes: []
modVersion = parser._parseModVersion data
modVersion.modName.should.equal 'Empty'
modVersion.modVersion.should.equal '1.0'
modVersion.name.should.equal 'Empty'
modVersion.version.should.equal '1.0'
it 'can parse a non-empty mod version', ->
data =
version: 1
mod_name: 'Minecraft'
mod_version: '1.7.10'
name: 'Minecraft'
version: '1.7.10'
recipes: [
{ input:'Sugar Cane', output:'Sugar' }
{ input:[[3, 'Wool'], [3, 'Planks']], tools:'Crafting Table', output:'Bed' }
]
modVersion = parser._parseModVersion data
modVersion.modName.should.equal 'Minecraft'
modVersion.modVersion.should.equal '1.7.10'
modVersion.name.should.equal 'Minecraft'
modVersion.version.should.equal '1.7.10'
slugs = (slug for slug, item of modVersion.items).sort()
slugs.should.eql ['bed', 'crafting_table', 'planks', 'sugar', 'sugar_cane', 'wool']
slugs.should.eql ['bed', 'sugar']
describe '_parseRawMaterials', ->
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
it 'skips the section when missing', ->
parser._parseRawMaterials null
_.keys(parser.modVersion._items).length.should.equal 0
_.keys(modVersion._items).length.should.equal 0
it 'skips the section when empty', ->
parser._parseRawMaterials []
_.keys(parser.modVersion._items).length.should.equal 0
_.keys(modVersion._items).length.should.equal 0
it 'adds items marked as gatherable', ->
parser._parseRawMaterials ['Wool']
parser.modVersion.items['wool'].isGatherable.should.be.true
modVersion.items['wool'].isGatherable.should.be.true
it 'marks an existing item as gatherable', ->
parser.modVersion.addItem new Item name:'Wool'
parser.modVersion.items['wool'].isGatherable.should.be.false
modVersion.addItem new Item name:'Wool'
modVersion.items['wool'].isGatherable.should.be.false
parser._parseRawMaterials ['Wool']
parser.modVersion.items['wool'].isGatherable.should.be.true
modVersion.items['wool'].isGatherable.should.be.true
it 'registers the names of the items', ->
parser._parseRawMaterials ['Wool']
modVersion.names['wool'].should.equal 'Wool'
describe '_parseRecipe', ->
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
it 'requires output to be defined', ->
parser._errorLocation = 'boat'
expect(-> parser._parseRecipe input:'wool').to.throw Error, 'boat is missing output'
test = -> parser._parseRecipe {input:'wool'}
expect(test).to.throw Error, 'boat is missing output'
it 'requires input to be defined', ->
expect(-> parser._parseRecipe output:'wool').to.throw Error, 'recipe for wool is missing input'
test = -> parser._parseRecipe {output:'wool'}
expect(test).to.throw Error, 'recipe for wool is missing input'
it 'can parse a regular recipe', ->
data =
@@ -113,20 +97,26 @@ describe 'ModVersionParser', ->
input: [[3, 'planks'], [3, 'wool']]
tools: 'crafting table'
recipe = parser._parseRecipe data
(stack.name for stack in recipe.output).should.eql ['bed']
(stack.name for stack in recipe.input).sort().should.eql ['planks', 'wool']
(item.name for item in recipe.tools).should.eql ['crafting table']
(stack.itemSlug for stack in recipe.output).should.eql ['bed']
(stack.itemSlug for stack in recipe.input).sort().should.eql ['planks', 'wool']
(stack.itemSlug for stack in recipe.tools).should.eql ['crafting_table']
it 'can parse a recipe without tools', ->
recipe = parser._parseRecipe output:'sugar', input:'sugar cane'
(stack.name for stack in recipe.output).should.eql ['sugar']
(stack.name for stack in recipe.input).sort().should.eql ['sugar cane']
(stack.name for stack in recipe.tools).should.eql []
recipe = parser._parseRecipe {output:'sugar', input:'sugar cane'}
(stack.itemSlug for stack in recipe.output).should.eql ['sugar']
(stack.itemSlug for stack in recipe.input).sort().should.eql ['sugar_cane']
(stack.itemSlug for stack in recipe.tools).should.eql []
it 'registers all names', ->
data =
output: 'Bed'
input: [[3, 'Oak Wood Planks'], [3, 'Wool']]
tools: 'Crafting Table'
parser._parseRecipe data
_.keys(modVersion.names).sort().should.eql ['bed', 'crafting_table', 'oak_wood_planks', 'wool']
describe '_parseStack', ->
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
it 'requires the array to have at least one element', ->
parser._errorLocation = 'boat'
options = index:1, field:'output'
@@ -134,13 +124,13 @@ describe 'ModVersionParser', ->
"output element 1 for boat must have at least one element"
it 'can fill in a missing number', ->
item = parser._parseStack 'boat'
item.name.should.equal 'boat'
item.quantity.should.equal 1
stack = parser._parseStack 'boat'
stack.itemSlug.should.equal 'boat'
stack.quantity.should.equal 1
item2 = parser._parseStack ['boat']
item2.name.should.equal 'boat'
item2.quantity.should.equal 1
stack2 = parser._parseStack ['boat']
stack2.itemSlug.should.equal 'boat'
stack2.quantity.should.equal 1
it 'requires the data to start with a number', ->
parser._errorLocation = 'boat'
@@ -154,11 +144,9 @@ describe 'ModVersionParser', ->
describe '_parseStackList', ->
beforeEach -> parser.modVersion = new ModVersion modName:'Test', modVersion:'0.0'
it 'can promote a single item to a list', ->
list = parser._parseStackList 'boat'
(i.name for i in list).should.eql ['boat']
(stack.itemSlug for stack in list).should.eql ['boat']
it 'can require a list to be non-empty', ->
parser._errorLocation = 'boat'
@@ -171,4 +159,4 @@ describe 'ModVersionParser', ->
it 'can parse a non-empty list', ->
list = parser._parseStackList [[3, 'plank'], [3, 'wool']]
(i.name for i in list).sort().should.eql ['plank', 'wool']
(stack.itemSlug for stack in list).sort().should.eql ['plank', 'wool']