Show Posts

1

Utilities and 3rd Party Applications / Re: prefchange--now with artifake working in fortress or adventurer mode!

« on: June 01, 2015, 09:39:02 pm »

thanks, it works like a glove!, you rock

as a reward, here is an updated version of make.rb
it makes just about every item type, exept items with subtypes, i don't know how to do that

items that have quality levels are base quality, and imported.

Spoiler (click to show/hide)

Code: [Select]

 # make items under cursor

category = $script_args[0] || 'help'
mat_raw  = $script_args[1] || 'list'
count    = $script_args[2]


category = df.match_rawname(category, ['help', 'bar', 'smallgem', 'wblocks', 'bblocks', 'sblocks', 'gblocks', 'mblocks', 'rough', 'boulder', 'log', 'door', 'floodgate', 'bed', 'chair', 'chain', 'flask', 'goblet', 'window', 'cage', 'barrel', 'bucket', 'animaltrap', 'table', 'coffin', 'statue', 'box', 'bin', 'armorstand', 'weaponrack', 'cabinet', 'figurine', 'amulet', 'scepter', 'crown', 'ring', 'earring', 'bracelet', 'gem', 'anvil', 'meat', 'seeds', 'plant', 'leather', 'fruit', 'leaves', 'pthread', 'yarn', 'webs', 'mthread', 'cloth', 'totem', 'backpack', 'quiver', 'catapultparts', 'ballistaparts', 'ballistaarrowhead', 'trapparts', 'cheese', 'coin', 'pipe-section', 'hatch-cover', 'grate', 'quern', 'millstone', 'splint', 'crutch', 'traction-bench', 'slab', 'book']) || 'help'

if category == 'help'
	puts <<EOS
make items under the cursor.
Usage:
 make [category] [raws token] [number]

Item categories:
 bar, smallgem, wblocks(wood blocks), bblocks(bone blocks), sblocks(stone blocks), gblocks(gem blocks), mblocks(metal blocks), rough(rough gems), boulder, log, door, floodgate, bed, chair, chain, flask, goblet, window, cage, barrel, bucket, animaltrap, table, coffin, statue, box, bin, armorstand, weaponrack, cabinet, figurine, amulet, scepter, crown, ring, earring, bracelet, gem, anvil, meat, seeds, plant, leather, fruit, leaves, pthread(plant thread), yarn, webs, mthread(metal thread), cloth, totem, backpack, quiver, catapultparts, ballistaparts, ballistaarrowhead, trapparts, cheese, coin, pipe-section, hatch-cover, grate, quern, millstone, splint, crutch, traction-bench, slab, book

Raw token:
 Either a full token (PLANT_MAT:ASK:WOOD) or the middle part only
 (the missing part is autocompleted depending on the item category)
 Use 'list' to show all possibilities

*
 type in a complete material token to overide the default materials sugested..
 
Exemples:
 make boulder hematite 10
 make bar CREATURE_MAT:CAT:SOAP
 make plant MUSHROOM_HELMET_PLUMP 5
 make web list

*
 make bed INORGANIC:BRASS

EOS
	throw :script_finished

elsif mat_raw == 'list'
	# allowed with no cursor

elsif df.cursor.x == -30000
	puts "Please place the game cursor somewhere"
	throw :script_finished

elsif !(maptile = df.map_tile_at(df.cursor))
	puts "Error: unallocated map block !"
	throw :script_finished

elsif !maptile.shape_passablehigh
	puts "Error: impassible tile !"
	throw :script_finished
end


def match_list(tok, list)
	if tok != 'list'
		tok = df.match_rawname(tok, list)
		if not tok
			puts "Invalid raws token, use one in:"
			tok = 'list'
		end
	end
	if tok == 'list'
		puts list.map { |w| w =~ /[^\w]/ ? w.inspect : w }.join(' ')
		throw :script_finished
	end
	tok
end


case category

when 'bar'
	cls = DFHack::ItemBarst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.dimension = 150
		item.subtype = -1
	}

when 'smallgem'
	cls = DFHack::ItemSmallgemst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_GEM]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'wblocks'
	cls = DFHack::ItemBlocksst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'bblocks'
	cls = DFHack::ItemBlocksst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'BONE' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:BONE"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'sblocks'
	cls = DFHack::ItemBlocksst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'gblocks'
	cls = DFHack::ItemBlocksst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_GEM]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'mblocks'
	cls = DFHack::ItemBlocksst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'rough'
	cls = DFHack::ItemRoughst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_GEM]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'boulder'
	cls = DFHack::ItemBoulderst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'log'
	cls = DFHack::ItemWoodst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'door'
	cls = DFHack::ItemDoorst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'floodgate'
	cls = DFHack::ItemFloodgatest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'bed'
	cls = DFHack::ItemBedst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'chair'
	cls = DFHack::ItemChairst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'chain'
	cls = DFHack::ItemChainst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'flask'
	cls = DFHack::ItemFlaskst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'goblet'
	cls = DFHack::ItemGobletst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'window'
	cls = DFHack::ItemWindowst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_GEM]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'cage'
	cls = DFHack::ItemCagest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'barrel'
	cls = DFHack::ItemBarrelst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'bucket'
	cls = DFHack::ItemBucketst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'animaltrap'
	cls = DFHack::ItemAnimaltrapst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'table'
	cls = DFHack::ItemTablest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'coffin'
	cls = DFHack::ItemCoffinst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'statue'
	cls = DFHack::ItemStatuest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'box'
	cls = DFHack::ItemBoxst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'bin'
	cls = DFHack::ItemBinst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'armorstand'
	cls = DFHack::ItemArmorstandst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'weaponrack'
	cls = DFHack::ItemWeaponrackst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'cabinet'
	cls = DFHack::ItemCabinetst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'figurine'
	cls = DFHack::ItemFigurinest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'amulet'
	cls = DFHack::ItemAmuletst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'scepter'
	cls = DFHack::ItemScepterst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'crown'
	cls = DFHack::ItemCrownst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'ring'
	cls = DFHack::ItemRingst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'earring'
	cls = DFHack::ItemEarringst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'bracelet'
	cls = DFHack::ItemBraceletst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'gem'
	cls = DFHack::ItemGemst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_GEM]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'anvil'
	cls = DFHack::ItemAnvilst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'meat'
	cls = DFHack::ItemMeatst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'MUSCLE' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:MUSCLE"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'seeds'
	cls = DFHack::ItemSeedsst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'SEED' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:SEED"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'plant'
	cls = DFHack::ItemPlantst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'STRUCTURAL' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:STRUCTURAL"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'leather'
	cls = DFHack::ItemSkinTannedst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'LEATHER' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:LEATHER"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'fruit'
	cls = DFHack::ItemPlantGrowthst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'FRUIT' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:FRUIT"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'leaves'
	cls = DFHack::ItemPlantGrowthst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'LEAF' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:LEAF"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'pthread'
	cls = DFHack::ItemThreadst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'THREAD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:THREAD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.dimension = 15000
	}

when 'yarn'
	cls = DFHack::ItemThreadst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'HAIR' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:HAIR"
		puts mat_raw
	end
	customize = lambda { |item|
		item.dimension = 15000
	}

when 'webs'
	cls = DFHack::ItemThreadst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'SILK' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:SILK"
		puts mat_raw
	end
	count ||= 1
	customize = lambda { |item|
		item.flags.spider_web = true
		item.dimension = 15000	# XXX may depend on creature (this is for GCS)
	}

when 'mthread'
	cls = DFHack::ItemThreadst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.dimension = 15000
	}

when 'cloth'
	cls = DFHack::ItemClothst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'THREAD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:THREAD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.dimension = 10000
	}

when 'totem'
	cls = DFHack::ItemTotemst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'BONE' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:BONE"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'backpack'
	cls = DFHack::ItemBackpackst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'LEATHER' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:LEATHER"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'quiver'
	cls = DFHack::ItemQuiverst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'LEATHER' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:LEATHER"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'catapultparts'
	cls = DFHack::ItemCatapultpartsst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'ballistaparts'
	cls = DFHack::ItemBallistapartsst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'ballistaarrowhead'
	cls = DFHack::ItemBallistaarrowheadst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'trapparts'
	cls = DFHack::ItemTrappartsst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'cheese'
	cls = DFHack::ItemCheesest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'CHEESE' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:CHEESE"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'coin'
	cls = DFHack::ItemCoinst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'pipe-section'
	cls = DFHack::ItemPipeSectionst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_METAL]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
	}

when 'hatch-cover'
	cls = DFHack::ItemHatchCoverst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'grate'
	cls = DFHack::ItemGratest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'quern'
	cls = DFHack::ItemQuernst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'millstone'
	cls = DFHack::ItemMillstonest
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'splint'
	cls = DFHack::ItemSplintst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'crutch'
	cls = DFHack::ItemCrutchst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.plants.all.find_all { |plt|
			plt.material.find { |mat| mat.id == 'WOOD' }
		}.map { |plt| plt.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "PLANT_MAT:#{mat_raw}:WOOD"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'traction-bench'
	cls = DFHack::ItemTractionBenchst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'slab'
	cls = DFHack::ItemSlabst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.inorganics.find_all { |ino|
			ino.material.flags[:IS_STONE]
		}.map { |ino| ino.id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "INORGANIC:#{mat_raw}"
		puts mat_raw
	end
	customize = lambda { |item|
		item.flags.foreign = true
	}

when 'book'
	cls = DFHack::ItemBookst
	if mat_raw !~ /:/ and !(df.decode_mat(mat_raw) rescue nil)
		list = df.world.raws.creatures.all.find_all { |cre|
			cre.material.find { |mat| mat.id == 'LEATHER' }
		}.map { |cre| cre.creature_id }
		mat_raw = match_list(mat_raw, list)
		mat_raw = "CREATURE_MAT:#{mat_raw}:LEATHER"
		puts mat_raw
	end
	customize = lambda { |item|
	}

	count ||= 1

end


mat = df.decode_mat mat_raw

count ||= 1
count.to_i.times {
	item = cls.cpp_new
	item.id = df.item_next_id
	item.stack_size = 1
	item.mat_type = mat.mat_type
	item.mat_index = mat.mat_index

	customize[item] if customize

	df.item_next_id += 1
	item.categorize(true)
	df.world.items.all << item

	item.pos = df.cursor
	item.flags.on_ground = true
	df.map_tile_at.mapblock.items << item.id
	df.map_tile_at.occupancy.item = true
}


# move game view, so that the ui menu updates
if df.cursor.z > 5
	df.curview.feed_keys(:CURSOR_DOWN_Z)
	df.curview.feed_keys(:CURSOR_UP_Z)
else
	df.curview.feed_keys(:CURSOR_UP_Z)
	df.curview.feed_keys(:CURSOR_DOWN_Z)
end

great for quick fortress mode "testing"

2

Utilities and 3rd Party Applications / Re: prefchange--now with artifact faking advfort candy!

« on: June 01, 2015, 09:01:46 pm »

nice work! I am having a hiccup though, creatorship is edit:~~always assigned to the first dwarf in the unit list~~ random AFIAK, even when I use "v" or "k" to view a specific unit. is there a unit or target argument? or is it supposed to work with a unit selected?
i'm talking about artifake.lua

3

Utilities and 3rd Party Applications / Re: DFHack 0.40.24-r3

« on: May 10, 2015, 03:02:48 pm »

i managed to build the item as part of the wagon with the script, then used gm-editor to change the in_building flag to false.
the item remains in the wagon but is no longer "built" into it, so success!
but i have a ways to go before doing it with a script, thanks for pointing me in the right direction

4

Utilities and 3rd Party Applications / Re: DFHack 0.40.24-r3

« on: May 09, 2015, 10:24:57 pm »

hi, i made a simple edit to the putontable script that "builds" items into your wagon, but what i would really like is to be able to put items "inside" buildings and containers. is it possible with this same style lua script?
or perhaps using gmeditor?

5

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

« on: May 09, 2015, 03:42:07 pm »

oh, thanks, maybe i'll make them bones into an intermediary object, like a bar or block, then require those as reagents for the reactions producing the items i want

6

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

« on: May 09, 2015, 02:49:49 pm »

so i made some reactions that use bones as reagents, but every job i que creates multiple products, until it uses up the whole stack. is there a way to stop that, and make them use just the number of bones called for in reaction, and leave the rest of the stack alone?

7

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

« on: May 07, 2015, 02:59:09 pm »

thank you guys

8

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

« on: May 07, 2015, 02:48:03 pm »

Quote from: scamtank on May 07, 2015, 02:07:45 pm

It's included in the package.

thanks, but i'm not seeing it anywhere in DFHack 0.40.24-r3 for OSX

9

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

« on: May 07, 2015, 02:03:37 pm »

Quote from: Klisz on May 07, 2015, 01:36:24 pm

There's a DFHack script - fix-handedness.rb, I believe it's called - but no way without DFHack.

Thanks, is there a link or location to get fix-handedness.rb ?

10

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

« on: May 07, 2015, 01:21:00 pm »

does anybody know of a in reaction method(if not a dfhack script maybe) to fix glove_items made by custom reactions, so that they have a left and right "handedness" ? (not sure if thats a word, but you kow what i mean right...)

11

DF General Discussion / Re: Preferred monsters

« on: May 06, 2015, 09:51:19 pm »

A Kraken as an aquatic megabeast would be cool, if they could attack coastal civs
also maybe Matt Damon, and Ben Aflek. I'm think'n Matt as a Mega, and Ben as a SemiMega.

12

DF Modding / Re: [MODDING] 0.40.x QUESTIONS THREAD

« on: May 02, 2015, 03:42:22 pm »

Quote from: Snergler on May 01, 2015, 08:15:25 pm

I created a plant growth using the BUD template, then gave the bud the plant thread template, I then created a custom reaction at the farmers workshop to process the growth to thread, but the loom does not recognize the thread as usable plant thread. My question is, do plant thread have to come from a "structural" part of the plant in order to be woven to cloth?

AFAIK it is not possible to weave plant thread derived from growth items, DFWiki seems to confirm this also.
Though it may be possible to use these thread items in suturing, like thread spun from creature hair, I have not tested it.

13

DF Modding / Re: [MODDING] 0.40.x QUESTIONS THREAD

« on: May 01, 2015, 08:15:25 pm »

I created a plant growth using the BUD template, then gave the bud the plant thread template, I then created a custom reaction at the farmers workshop to process the growth to thread, but the loom does not recognize the thread as usable plant thread. My question is, do plant thread have to come from a "structural" part of the plant in order to be woven to cloth?

14

Utilities and 3rd Party Applications / Re: DFHack 0.40.24-r3

« on: April 10, 2015, 11:44:19 am »

I think that tiletypes can be used to enable magma workshops, by painting an tile with the MAGMA material. you can use the FLOOR shape(you might have to make the tile visible with HIDDEN 0) then use gui/liquids to fill the hole with lava.

15

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

« on: March 19, 2015, 04:06:30 pm »

Quote from: Dirst on March 19, 2015, 01:38:07 pm

Quote from: Snergler on March 18, 2015, 08:42:03 pm
so to answer my original question, i guess it is possible.... but at what price
And I thought implementing the raws-only method of spawning a creature was convoluted. I salute your persistence and ‼SCIENCE‼ skills.

yea, i used to think cheese bins were weird, but know i know that is just the tip of the weirdberg

thanks to you and blackflame and urist and Zarathustra30 for the collaboration, it was a learning experience.
now it got me all interested in playing with temperature, heatdam point, and spec heat values.
i've learned that by using [SPEC_HEAT:1] and [MAT_FIXED_TEMP:10015](normal underground temp) then lowering the [HEATDAM_POINT] below [MAT_FIXED_TEMP] in increments, the material wears out faster the larger the difference between the two. for every 10 degrees lower, the material wears out about 5 seconds faster, but only within a certain range.
once you hit larger differences, say 100 degrees the effect is accelerated, and about 1000 degrees, materials disintegrate instantly. so the closer to your [MAT_FIXED_TEMP] the more accurate you can be, i assume that [COLDDAM_POINT] would behave the same, but you just raise the value above the [MAT_FIXED_TEMP] AFAIK

Bay 12 Games Forum

News:

Profile Info

Messages - Snergler

Utilities and 3rd Party Applications / Re: prefchange--now with artifake working in fortress or adventurer mode!

Utilities and 3rd Party Applications / Re: prefchange--now with artifact faking advfort candy!

Utilities and 3rd Party Applications / Re: DFHack 0.40.24-r3

Utilities and 3rd Party Applications / Re: DFHack 0.40.24-r3

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD

DF General Discussion / Re: Preferred monsters

DF Modding / Re: [MODDING] 0.40.x QUESTIONS THREAD

DF Modding / Re: [MODDING] 0.40.x QUESTIONS THREAD

Utilities and 3rd Party Applications / Re: DFHack 0.40.24-r3

DF Modding / Re: [MODDING] REACTIONS QUESTIONS THREAD