Topic: What is a "decent meal"? (Read 17135 times)

PatrikLundell · « **Reply #45 on:** November 14, 2018, 02:14:31 pm »

Thanks for that thread reference, therahedwig, it looks like it contains exactly what I was looking for (and in more detail than I realized I needed)!

I suspect Sun Berries/Sliver barb may be available in trade if conditions are exactly right. If I understand it correctly, the resources available to a civ depends on what's available to the starting site of the civ, and I think those resources are drawn from a rectangle around the site, rather than from a single world tile (and sites tend to be larger than a single world tile and/or straddle world tiles anyway).
When it comes to the revamped system, I'd expect similar effects to the current ones to appear, with some spheres (and their corresponding resources) being too hostile to some or all species you trade with. As your own species can be more or less random (as can the others), what you can have access to in a specific world may probably vary considerably from what's available in another even within the same weirdness/magic level, with mundane worlds being rather mundane and samey in comparison.

Edit: Updated "food_needs" to flag preferences for unobtainable butcher products based on Urist Da Vinci's research:

Spoiler (click to show/hide)

Code: [Select]

--  Bumblebee honey is impossible to obtain in vanilla, and thus does bumblebee mead remain
--  out of reach. Feather trees are bugged so you can't get any eggs, and thus not get at
--  the egg white or yolk (despite the trade depot being contaminated by feather tree egg
--  yolk after the elves have visited).
--
local bumblebee = -1
local feather_tree = -1

for i, creature in ipairs (df.global.world.raws.creatures.all) do
  if creature.creature_id == "BUMBLEBEE" then
    bumblebee = i
    break
  end
end

for i, plant in ipairs (df.global.world.raws.plants.all) do
  if plant.id == "FEATHER" then
    feather_tree = i
    break
  end
end

local min_butcher_size = --  Data taken from http://www.bay12forums.com/smf/index.php?topic=78108.0
  {["MUSCLE"] =          1900,  --  Meat in the reference
   ["FAT"] =             1900,  --  Haven't seen any preferences for it
   ["TALLOW"] =          1900,  --  i.e. rendered fat. Haven't seen any preferences for it, though
   ["SKIN"] =            1900,  --  Inedible, but here for completeness
   ["BONE"] =            2000,  --  Inedible
   ["INTESTINES"] =      5000,
   ["BRAIN"] =          10000,
   ["LUNG"] =           10000,
   ["LIVER"] =          10000,
   ["STOMACH"] =        10000,  --  Called tripe as food
   ["GUT"] =            10000,  --  ###Not in reference. Guessing it's the same most others.
   ["GIZZARD"] =        10000,  --  Not in reference. Wiki claims size similar to brain and liver. Wiki DF2014:Prepared_organs does not list Gut or Gizzard.
   ["NERVE"] =          15000,  --  ###Name not checked. Inedible anyway
   ["HOOF"] =           15000,  --  Inedible
   ["HEART"] =          20000,
   ["PANCREAS"] =       20000,  --  Called sweetbread as food
   ["SPLEEN"] =         20000,
   ["KIDNEY"] =         20000,
   ["HORN"] =           20000,  --  Inedible
   ["CARTILAGE"] =     200000,  --  Inedible
   ["HAIR"] =          200000,  --  Inedible
   ["EYE"] =           500000,
   ["TOOTH"] =       25000000,  --  Inedible
   ["CHEESE"] =             0}  --  Not a butcher product, and thus no size relation, but exists as food preferences, so here for reference.

local available_plant = {}
local available_creature = {}

-----------------------------

function add (list, item)
  for i, element in ipairs (list) do
    if element [1] == item then
      list [i] [2] = list [i] [2] + 1
      return
    end
  end
  
  table.insert (list, {item, 1})
end

-----------------------------

function sort (list)
  local temp
  
  for i = 1, #list - 1 do
    for k = i + 1, #list do
      if list [k] [1] < list [i] [1] then
        temp = list [i]
        list [i] = list [k]
        list [k] = temp
      end
    end
  end
end

-----------------------------

function preference_string (preference)
  local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
            
  if preference.matindex ~= -1 and 
     (material.mode == "plant" or
      material.mode == "creature") then
    if preference.item_type == df.item_type.DRINK or 
       preference.item_type == df.item_type.LIQUID_MISC then  --  The state in the preferences seems locked to Solid
      local unavailable = ""
      
      if material.mode == "plant"  then
        
        if not available_plant [material.plant.index] then
          unavailable = "UNAVAILABLE "
        end
        
        return unavailable .. material.material.state_name.Liquid .. " [" .. material.plant.name .. "]"
          
      else
        local impossible = ""
        
        if preference.matindex == bumblebee then
          impossible = "IMPOSSIBLE "
        end
        
        if not available_creature [material.index] then
          unavailable = "UNAVAILABLE "
        end
        
        return unavailable .. impossible .. material.material.state_name.Liquid .. " [" .. material.creature.name [0] .. "]"
      end
        
    else
      local butcherable = ""
      local impossible = ""
      local too_small = ""
      local unavailable = ""
      
      if material.mode == "creature" then
        for i, str in ipairs (material.creature.raws) do
          if str [0] == "[NOT_BUTCHERABLE]" then
            butcherable = "NOT BUTCHERABLE "
            break
          end
        end
        
        if not available_creature [material.index] then
          unavailable = "UNAVAILABLE "
        end
        
        if min_butcher_size [material.material.id] then
          if min_butcher_size [material.material.id] > material.creature.adultsize then
            too_small = "TOO SMALL "
          end
          
        else
          dfhack.printerr ("preference_string found unexpected animal food preference (continuing): " .. material.material.id)
        end
        
      else
        if not available_plant [material.plant.index] then
          unavailable = "UNAVAILABLE "
        end
        
        if material.matindex == feather_tree then
          impossible = "IMPOSSIBLE "
        end          
      end
      
      if material.material.prefix == "" then
        if material.mode == "plant" then
          return unavailable .. impossible .. material.material.state_name.Solid .. " [" .. material.plant.name .. "]"
            
        else
          return unavailable .. butcherable .. too_small .. material.material.state_name.Solid .. " [" .. material.creature.name [0] .. "]"
        end
                
      else
        if material.mode == "plant" then
          return unavailable .. impossible .. material.material.prefix .. " " .. material.material.state_name.Solid .. " [" .. material.plant.name .. "]"
          
        else
          return unavailable .. butcherable .. too_small .. material.material.prefix .. " " .. material.material.state_name.Solid .. " [" .. material.creature.name [0] .. "]"
        end
      end
    end            
            
  else
    local unavailable = ""
    
    if not available_creature [preference.mattype] then
      unavailable = "UNAVAILABLE "
    end
        
    return unavailable .. df.global.world.raws.creatures.all [preference.mattype].name [0]
  end
end

-----------------------------

function food_needs ()
  local preferences = {}
  local unit_preferences = {}
  local drink_demands = {}
  local food_demands = {}
  local unsatisfied_residents = 0
  local food_unsatisified_residents = 0
  
  for i, plant in ipairs (df.global.world.raws.plants.all) do
    available_plant [i] = false
  end
  
  for i, creature in ipairs (df.global.world.raws.creatures.all) do
    available_creature [i] = creature.flags.CASTE_COMMON_DOMESTIC  or               --  Some of them don't exist in the wild
                             creature.flags.BIOME_RIVER_TEMPERATE_FRESHWATER or     --  Don't know how to check availability
                             creature.flags.BIOME_RIVER_TEMPERATE_BRACKISHWATER or  --
                             creature.flags.BIOME_RIVER_TEMPERATE_SALTWATER or      --
                             creature.flags.BIOME_RIVER_TROPICAL_FRESHWATER or      --
                             creature.flags.BIOME_RIVER_TROPICAL_BRACKISHWATER or   --
                             creature.flags.BIOME_RIVER_TROPICAL_SALTWATER          --
  end
  
  for i, region in ipairs (df.global.world.world_data.regions) do
    for k, pop in ipairs (region.population) do
      if pop.type == df.world_population_type.Animal or
         pop.type == df.world_population_type.Vermin or
         pop.type == df.world_population_type.VerminInnumerable or
         pop.type == df.world_population_type.ColonyInsect then
        available_creature [pop.race] = true
        
      elseif pop.type == df.world_population_type.Tree or
             pop.type == df.world_population_type.Grass or
             pop.type == df.world_population_type.Bush then
        available_plant [pop.plant] = true
      end
    end
  end
  
  for i, region in ipairs (df.global.world.world_data.underground_regions) do
    for k, pop in ipairs (region.feature_init.feature.population) do
      if pop.type == df.world_population_type.Animal or
         pop.type == df.world_population_type.Vermin or
         pop.type == df.world_population_type.VerminInnumerable or
         pop.type == df.world_population_type.ColonyInsect then
        available_creature [pop.race] = true
        
      elseif pop.type == df.world_population_type.Tree or
             pop.type == df.world_population_type.Grass or
             pop.type == df.world_population_type.Bush then
        available_plant [pop.plant] = true
      end
    end
  end
  
  for i, unit in ipairs (df.global.world.units.all) do
    if (dfhack.units.isCitizen (unit) or
        unit.flags2.resident) and
       dfhack.units.isAlive (unit) and
       unit.status.current_soul then
      for k, preference in ipairs (unit.status.current_soul.preferences) do
        if preference.active then
          if preference.type == df.unit_preference.T_type.LikeFood then
            table.insert (preferences, preference)
            
            if not unit_preferences [unit.id] then
              unit_preferences [unit.id] = {}
            end
            
            table.insert (unit_preferences [unit.id], preference)
          end
        end
      end
    end
  end

  for i, unit_preference in pairs (unit_preferences) do
    local drink_satisfied = false
    local food_satisfied
    
    for k, preference in ipairs (unit_preference) do
      local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
      
      --  See if there's a plant "booze" being produced that satisfies this unit's needs
      --  through booze cooking.
      --
      if preference.matindex ~= -1 and
         material.mode == "plant" and
         (preference.item_type == df.item_type.DRINK  or 
          preference.item_type == df.item_type.LIQUID_MISC) then
        if material.plant.flags.TREE then
          for l, zone in ipairs (df.global.world.buildings.other.ACTIVITY_ZONE) do
            if zone.name:len() >= material.plant.id:len() and
               string.sub (zone.name:upper (), 1, material.plant.id:len()) == material.plant.id then
              if drink_demands [material.plant.index] then
                drink_demands [material.plant.index] = drink_demands [material.plant.index] + 1
                  
              else
                drink_demands [material.plant.index] = 1
              end
                
              drink_satisfied = true
              break              
            end
          end
          
        else
          for l, plot in ipairs (df.global.world.buildings.other.FARM_PLOT) do
            if plot.name == material.plant.id then  --  Farm plot set up
              for m, seed in ipairs (df.global.world.items.other.SEEDS) do
                if seed.mat_index == material.plant.index then
                  if drink_demands [material.plant.index] then
                    drink_demands [material.plant.index] = drink_demands [material.plant.index] + 1
                  
                  else
                    drink_demands [material.plant.index] = 1
                  end
                
                  drink_satisfied = true
                  break
                end
              end
            
              if drink_satisfied then
                break
              end
            end
          end
        end
      end
      
      if drink_satisfied then
        break
      end
    end
    
    food_satisfied = drink_satisfied  --  Through booze cooking
    
    if not food_satisfied then
      --  Look for farm plots that produce edible stuff, at least
      --
      for k, preference in ipairs (unit_preference) do
        local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
      
        if preference.matindex ~= -1 and
           material.mode == "plant" and
           preference.item_type ~= df.item_type.DRINK  and        --  Don't really need this check, as it will fail on
           preference.item_type ~= df.item_type.LIQUID_MISC then  --  these cases anyway.
          if material.plant.flags.TREE then
            for l, zone in ipairs (df.global.world.buildings.other.ACTIVITY_ZONE) do
              if zone.name:len() >= material.plant.id:len() and
                 string.sub (zone.name:upper (), 1, material.plant.id:len()) == material.plant.id then
                if food_demands [material.plant.index] then
                  food_demands [material.plant.index] = food_demands [material.plant.index] + 1
                  
                else
                  food_demands [material.plant.index] = 1
                end
                
                food_satisfied = true
                break              
              end
            end
          
          else
            for l, plot in ipairs (df.global.world.buildings.other.FARM_PLOT) do
              if plot.name == material.plant.id then  --  Farm plot set up
                for m, seed in ipairs (df.global.world.items.other.SEEDS) do
                  if seed.mat_index == material.plant.index then
                    if food_demands [material.plant.index] then
                      food_demands [material.plant.index] = food_demands [material.plant.index] + 1
                  
                    else
                      food_demands [material.plant.index] = 1
                    end
                
                    food_satisfied = true
                    break
                  end
                end
            
                if food_satisfied then
                  break
                end
              end
            end
          end
        end
      
        if food_satisfied then
          break
        end
      end
      
    end
    
    if not drink_satisfied then
      unsatisfied_residents = unsatisfied_residents + 1
    end
    
    if not food_satisfied then
      food_unsatisified_residents = food_unsatisified_residents + 1
    end
    
    if not food_satisfied then
      dfhack.println ("Failed to find satisfying 'farmed' food or drink for " .. dfhack.TranslateName (df.unit.find (i).name, true))
      
      for k, preference in ipairs (unit_preference) do
        dfhack.println ("  " .. preference_string (preference))
      end
      
    elseif not drink_satisfied then
      dfhack.println ("Failed to find satisfying 'farmed' drink for " .. dfhack.TranslateName (df.unit.find (i).name, true))
      
      for k, preference in ipairs (unit_preference) do
        local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
      
        if preference.matindex ~= -1 and
           material.mode == "plant" and
           (preference.item_type == df.item_type.DRINK  or 
            preference.item_type == df.item_type.LIQUID_MISC) then
          dfhack.println ("  " .. preference_string (preference))
        end
      end
    end
  end
  
  dfhack.println ("Number of drink unsatisfied residents: " .. tostring (unsatisfied_residents), " food unsatisfied residents: " .. tostring (food_unsatisified_residents))
  
  local count = 0
  dfhack.println ("Drink demand satisfying crops:")
  for i, drink in pairs (drink_demands) do
    count = count + 1
    dfhack.println (df.global.world.raws.plants.all [i].name, drink)
  end
  dfhack.println (count)
  count = 0
  dfhack.println ("Food demand satisfying crops:")
  for i, food in pairs (food_demands) do
    count = count + 1
    dfhack.println (df.global.world.raws.plants.all [i].name, food)
  end
  dfhack.println (count)
  
  
  local drink_list = {}
  local food_list = {}
  
  for i, preference in ipairs (preferences) do
    local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
            
    if preference.matindex ~= -1 and 
       (material.mode == "plant" or
        material.mode == "creature") then
      if preference.item_type == df.item_type.DRINK or 
         preference.item_type == df.item_type.LIQUID_MISC then  --  The state in the preferences seems locked to Solid
        add (drink_list, preference_string (preference))
        
      else                
        add (food_list, preference_string (preference))
      end            
            
    else
      add (food_list, preference_string (preference))
    end
  end
  
  sort (drink_list)
  sort (food_list)
  
  dfhack.color (COLOR_YELLOW)
  dfhack.println ("Drink preferences found:")
  dfhack.color (COLOR_RESET)
  
  for i, drink in ipairs (drink_list) do
    dfhack.println (drink [1], drink [2])
  end
  
  dfhack.println ()
  dfhack.color (COLOR_YELLOW)
  dfhack.println ("Food preferences found:")
  dfhack.color (COLOR_RESET)
  
  for i, food in ipairs (food_list) do
    dfhack.println (food [1], food [2])
  end
end

food_needs ()

Edit 2: Updated the script above again to flag unavailable items, i.e. items based on plants and creatures that do not exist in the world because they haven't been selected by DF to appear in any region (and aren't common domestic, as some of those don't exist in the wild), possibly because no region has a suitable biome.

Saiko Kila · « **Reply #46 on:** November 16, 2018, 08:36:17 am »

Quote from: PatrikLundell on November 14, 2018, 04:23:45 am

Eggs, fish, and raw fish all lack the kind of internal structure (other) animals and plant have, so they can only be preferred as the whole items. Eggs are particular in that the actually have a different internal structure in the form of shell, white, and yolk.
It can also be noted that Feather Tree Eggs are bugged and cannot be acquired, but eleven caravans litter the trade depot with Feather Tree Egg Yolk (which cannot be picked up and used).

After last post some lover of aquatic vermin body parts have appeared in my fortress. Here's excerpt from your (older) script's output:

Code: [Select]

hagfish gut     1
hake    5
hake liver tissue       1

Both hagfish and hake are water vermin, apparently sometimes dwarves are inquisitive enough to find what hides inside these vermin...
The guys who love hake have this preference:
item_type: 48 (i.e. FISH)
item_subtype: -1
mattype: 550 (this one is race ID of the creature, hake in default RAWs)
matindex: -1

The guy who loves hake's liver has this preference (he also likes a whole vermin fish of another species, he's a fish guy):
item_type: 47 (i.e. MEAT)
item_subtype: -1
mattype: 29 (this means liver)
matindex: 550 (and here the ID)

So clearly sometimes, when choosing meat, the vermin are considered by game. I don't know why so rarely, but still in my game it's more often than pigs, llamas, cows, horses or other domestic animals, which have zero lovers. Except cheese and milk, yeah, these are preferred by some gourmands.

Quote

My biome hacking includes trees, yes. For some reason it tends to take a few years for saplings of most temperate fruit trees to appear, but since they only take 3 years to mature, it's not a big deal.

Ideally, migrant (and petitioner) preferences ought to be based on their background, which means it ought to be based on what was available in the places they've lived (which ought to include what's available via trade). I agree preferences ought to develop over time, with newborn being blank slates, but if so, the process ought to be capable of blocking stuff exposed to (i.e. I've only ever eaten Plump Helmet, and I don't like it and will never do so. Please let me try other things! Hm, Cave Wheat. Novel, but no, I won't grow attached to that either). However, currently newborn are fully formed with preferences, views, personality traits, etc.

Yep, their initial state should be blank, though they should have some preference chances. But even if it remained like it is, it should be more rational when choosing. You can't like something no one ever seen

Quote

Edit: Looking more into preferences, I see no whole creature preferences in my fortress, except for vermin (moghopper) and vermin fish, while there is a preference for Pike Kidney Tissue (and looking at the raws for Pike shows it's a creature, not vermin).
I've also found that mead isn't actually booze cookable.

Ah, so they won't make mead roasts. But it's a kind of moot point, you see, because of peculiar behaviour of eaters and drinkers who do not have their preferred food: they choose whatever was produced or brewed recently. In case of food it's often horse tripe or pig intestine (i.e. not a big deal usually), but in case of alcohol it can be mead - which is rarely made. I have over 20 hives, and when mead is made, even if it's more than one unit, it's all gone before sunset, because of this behaviour. So I wouldn't be able to make a mead roast anyway.

In case of meat I sometimes butcher the extra rare creature surrounded by common creatures - for example a beak dog, an eagle (rare), a llama and another llama. This usually "saturates" the market so the rare eagle parts won't be instantly eaten by some boor who can't appreciate them. But this can tedious, and I can do it only for the most valued dwarves anyway.

As for aquatic vermin parts - as seen in my example above, they can happen. But they are quite rare for some reason.

Quote

Edit 2: Is it known what the size limits for butchering and slaughtering are, and if there's more than just bones that won't appear if the creature is too small to yield anything but skull and meat? I'm fairly sure a Magpie is too small to be butchered (to satisfy a need for Magpie Gut), but would a Buzzard (which appears to be a borderline species that sometimes yields just a skull and meat, and sometimes a more complete result) produce a Gut part in either or both cases?

Edit 3: I've found that the "[NOT_BUTCHERABLE]" token from the raws can be accessed from the creature raw to determine if a creature is labelled as butcherable (which showed that the Magpie in Edit 2 is marked as [NON_BUTCHERABLE]).

A marginally updated food_needs script that flags the impossible items I know of as impossible (butcher products from creatures that can't be butchered, bumblebee honey/mead, feather tree egg parts).

I've run the new script (after modifying to count my long-term residents) and here's the part about vermin:

Spoiler (click to show/hide)

These are some queer preferences, I'd say.

Now, about the script: it proved most useful, but I had to make some modifications, and there's a part which apparently works differently for you. The modifications I made are logging (because output is too big for my console's buffer), and determination of long-term residents (because otherwise only full citizens are counted, and my fortress has more long-terms than citizens). As a side note, the flag "resident" means that the critter is a and underground cave dweller (I don't know why it's named resident, "underground" or "caverns" would be better), just like "underworld" means that it is a hell dweller.

The part I do not understand is the one which checks the plots (and zones), specifically compares their name to the material id. In my game this field contains the nickname of the field the player can give, so the result of comparison is always false, i.e. #drink_demands and #food_demands will be always zero. Do you use a script which populates these names with IDs maybe?

PatrikLundell · « **Reply #47 on:** November 16, 2018, 09:09:15 am »

Given that "normal" vermin body parts can appear, it might not be too surprising aquatic can appear as well. The output pasted also show Dwarven Cheese flagged incorrectly, as it's supposed to be possible to milk purring maggots.

If the "resident" flag means "cavern denizen", how do you determine if a non citizen is a resident (and not e.g. a visitor from your own civ)?

The plot and zone name matching are indeed based on other scripts I use, and shouldn't be used in scripts shared with others (unless the others are as well, as part of a package). I use one script for logging to spare useful trees and, in its latest version, set up gathering zones around them (I did that manually previously), and another one yearly to enable/disable farm plots and zones to attempt to keep a desired booze supply. The script names plots after what's planted on them by the player and uses the name to find fallow plots allocated to a given crop when it's time to plant again. However, it's tailored to my play style of trying to grew crops in spring (those that can't be planted in spring are allocated to the earliest possible season), harvest fruit in summer, catch up on all the hauling that's built up over the first half of the year, and R&R (and militia training) during winter.

Starver · « **Reply #48 on:** November 16, 2018, 10:32:23 am »

Again, perhaps a reason to (internally) sandbox the possibility of an animal-type and only proceed to choose its component parts if it's sandbox-butcherable thing (if, as it might well be, DF is just making the assumption that they exist for everything it picks). You'd expect it to at least directly reference the raws (to make it sensitive to modding) to look for possible subtrees, but with my "pick something rare (yet possible)" scheme it does the spadework for the other circumstantials involved.

But, really, I was wanting to post about the image Dwarf with "LOVE" and "HAKE" tattooed on their knuckles.

Saiko Kila · « **Reply #49 on:** November 16, 2018, 02:39:56 pm »

Quote from: PatrikLundell on November 16, 2018, 09:09:15 am

Given that "normal" vermin body parts can appear, it might not be too surprising aquatic can appear as well. The output pasted also show Dwarven Cheese flagged incorrectly, as it's supposed to be possible to milk purring maggots.

It's not surprising that it appears, what I find surprising is that it seems to be much rarer than the proper (whole) vermin, which supposedly is an artefact of the algorithm which determines the whole preference. I think it may run and choose whether a dwarf wants a vermin or a meat (or whatever), and if it wants meat, is just runs through all, including vermin. And maybe aquatic vermin are counted separately.

Ad for purring maggot, yes, that's how it shows. But I would love to see actual purring maggot and processing of it - maybe it is bugged in game, and the script shows truth?

Quote

If the "resident" flag means "cavern denizen", how do you determine if a non citizen is a resident (and not e.g. a visitor from your own civ)?

I just include your script with modifications I made (i.e. one with logging and with counting citizens and long-term residents). I use a function I made for other script. Similarly to isCitizen() function, it checks flags and conditions - it calls isCitizen() in the beginning, and only performs checks if false is returned. I assume that it is faster than rewriting the isCitizen() in Lua to account for the long-term residents, also it's easier to customize (for example it returns 3 for visitors and diplomats, but not merchants, since merchants don't use my taverns while diplomats do).

At the end the total sum of citizens and LTRs is shown, and it should be the same as number of people in the Citizen tab in "u"-screen. If it is different, then there's something wrong. I had to make this function for my scripts, because sometimes there are goblins or necromancers with visitor flags, and other irregularities. But the most important is determination of all guys in the Citizen tabs, since they do most stuff, like eating, drinking, clothes wearing etc.

Spoiler (click to show/hide)

Quote

The plot and zone name matching are indeed based on other scripts I use, and shouldn't be used in scripts shared with others (unless the others are as well, as part of a package). I use one script for logging to spare useful trees and, in its latest version, set up gathering zones around them (I did that manually previously), and another one yearly to enable/disable farm plots and zones to attempt to keep a desired booze supply. The script names plots after what's planted on them by the player and uses the name to find fallow plots allocated to a given crop when it's time to plant again. However, it's tailored to my play style of trying to grew crops in spring (those that can't be planted in spring are allocated to the earliest possible season), harvest fruit in summer, catch up on all the hauling that's built up over the first half of the year, and R&R (and militia training) during winter.

OK, clear then. I think I can modify it to look for plants in the structure of fields, at least. Anything, this part of the script is useful anyway, because it shows all these poor critters and their preferences as it is. And now I can log it, to maybe make some statistics if I do it for more forts, to satisfy my curiosity.

One thing about the too small items - this is probably more a warning that exact declaration, because bigger specimens could potentially bring these items (like dog's spleen or coyote's heart), right? My non available items now look like this. Very singular tastes, these dwarves have

Spoiler (click to show/hide)

PatrikLundell · « **Reply #50 on:** November 17, 2018, 12:20:55 pm »

Purring maggots have the Underground Chasm biome, a.k.a. muddy cavern, so it might not be too surprising they're not found more frequently (I've never seen one as far as I know, but I don't look too carefully after vermin). If I read the raws correctly mog juice isn't alcoholic and is edible only if cooked, and I haven't found any other LIQUID MISC preferences that cannot be "eaten" (i.e. drunk) raw. Apart from vermin butchering, I don't think there's any relation between butcherability and creature extraction (such as mog juice and dwarven milk), and I don't think there should be any.

Creepy crawlers do not, in fact have the NOT_BUTCHERABLE tag, while all (?) other vermin do, so it ought to be legal for creepy crawler meat to be a preference as they're large enough to provide it.

I don't think DF should generate a preference for a body part that can only be obtained through butchering of the very largest specimens of a species (with necro bacon processing being the extreme of that), while I consider it reasonable to allow preferences for items that may be missing on smaller than standard members.

df.global.ui contains a number of useful fields, by the way (I don't know how far back those fields existed):
- civ_id = you civ entity id
- site_id = fortress site id
- group_id = fortress entity id
- race_id = civ race

Edit: An attempt to make a script that fixes food need bugs (but does NOT do anything to address "unreasonable", but technically possible, preferences). Note that it's been tested very little, and as it changes preferences, I'd try it on a freshly loaded save that can be discarded.

Spoiler (click to show/hide)

Quote

-- Bumblebee honey is impossible to obtain in vanilla, and thus does bumblebee mead remain
-- out of reach. Feather trees are bugged so you can't get any eggs, and thus not get at
-- the egg white or yolk (despite the trade depot being contaminated by feather tree egg
-- yolk after the elves have visited).
--
local bumblebee = -1
local feather_tree = -1

for i, creature in ipairs (df.global.world.raws.creatures.all) do
if creature.creature_id == "BUMBLEBEE" then
bumblebee = i
break
end
end

for i, plant in ipairs (df.global.world.raws.plants.all) do
if plant.id == "FEATHER" then
feather_tree = i
break
end
end

local min_butcher_size = -- Data taken from http://www.bay12forums.com/smf/index.php?topic=78108.0
{["MUSCLE"] = 1900, -- Meat in the reference
["FAT"] = 1900, -- Haven't seen any preferences for it
["TALLOW"] = 1900, -- i.e. rendered fat. Haven't seen any preferences for it, though
["SKIN"] = 1900, -- Inedible, but here for completeness
["BONE"] = 2000, -- Inedible
["INTESTINES"] = 5000,
["BRAIN"] = 10000,
["LUNG"] = 10000,
["LIVER"] = 10000,
["STOMACH"] = 10000, -- Called tripe as food
["GUT"] = 10000, -- ###Not in reference. Guessing it's the same most others.
["GIZZARD"] = 10000, -- Not in reference. Wiki claims size similar to brain and liver. Wiki DF2014:Prepared_organs does not list Gut or Gizzard.
["NERVE"] = 15000, -- Inedible
["HOOF"] = 15000, -- Inedible
["HEART"] = 20000,
["PANCREAS"] = 20000, -- Called sweetbread as food
["SPLEEN"] = 20000,
["KIDNEY"] = 20000,
["HORN"] = 20000, -- Inedible
["CARTILAGE"] = 200000, -- Inedible
["HAIR"] = 200000, -- Inedible
["EYE"] = 500000,
["TOOTH"] = 25000000, -- Inedible
["CHEESE"] = 0} -- Not a butcher product, and thus no size relation, but exists as food preferences, so here for reference.

local butcher_edible =
{["MUSCLE"] = true, -- Meat in the reference
["FAT"] = false, -- Haven't seen any preferences for it
["TALLOW"] = false, -- i.e. rendered fat. Haven't seen any preferences for it, though
["SKIN"] = false, -- Inedible, but here for completeness
["BONE"] = false, -- Inedible
["INTESTINES"] = true,
["BRAIN"] = true,
["LUNG"] = true,
["LIVER"] = true,
["STOMACH"] = true, -- Called tripe as food
["GUT"] = true, -- ###Not in reference. Guessing it's the same most others.
["GIZZARD"] = true, -- Not in reference. Wiki claims size similar to brain and liver. Wiki DF2014:Prepared_organs does not list Gut or Gizzard.
["NERVE"] = false, -- Inedible
["HOOF"] = false, -- Inedible
["HEART"] = true,
["PANCREAS"] = true, -- Called sweetbread as food
["SPLEEN"] = true,
["KIDNEY"] = true,
["HORN"] = false, -- Inedible
["CARTILAGE"] = false, -- Inedible
["HAIR"] = false, -- Inedible
["EYE"] = true,
["TOOTH"] = false, -- Inedible
["CHEESE"] = false} -- Handled separately, like milk

local available_plant = {}
local available_creature = {}

-----------------------------

function is_resident (unit)
return not dfhack.units.isCitizen (unit) and
unit.civ_id == df.global.ui.civ_id and
not unit.flags1.marauder and
not unit.flags1.tame and
not unit.flags2.visitor and
not unit.flags1.merchant and
not unit.flags1.forest and
not unit.flags1.diplomat
end

-----------------------------

function replacement_string (preference, replacement, unit)
local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)

if preference.item_type == df.item_type.DRINK or
preference.item_type == df.item_type.LIQUID_MISC then -- The state in the preferences seems locked to Solid
local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)

return material.material.state_name.Liquid .. " with " .. replacement.material.state_name.Liquid .. " on " .. dfhack.TranslateName (unit.name, true)

else
if old_mat.mode == "creature" then
local old_str = ""
local new_str = ""

if not old_mat then
old_str = df.global.world.raws.creatures.all [preference.mattype].name

elseif old_mat.material.prefix == "" then
old_str = old_mat.material.state_name.Solid

else
old_str = old_mat.material.prefix .. " " .. old_mat.material.state_name.Solid
end

if type (replacement) == "number" then
new_str = df.global.world.raws.creatures.all [replacement].name

else
if replacement.material.prefix == "" then
new_str = replacement.material.state_name.Solid

else
new_str = replacement.material.prefix .. " " .. replacement.material.state_name.Solid
end
end

return old_str .. " with " .. new_str .. " on " .. dfhack.TranslateName (unit.name, true)

else
local old_str = ""
local new_str = ""

if not old_mat then
old_str = df.global.world.raws.plants.all [preference.mattype].name

elseif old_mat.material.prefix == "" then
old_str = mat.material.state_name.Solid

else
old_str = mat.material.prefix .. " " .. mat.material.state_name.Solid
end

if type (replacement) == "number" then
new_str = df.global.world.raws.plants.all [replacement].name

else
if replacement.material.prefix == "" then
new_str = replacement.material.state_name.Solid

else
new_str = replacement.material.prefix .. " " .. replacement.material.state_name.Solid
end
end

return old_str .. " with " .. new_str .. " on " .. dfhack.TranslateName (unit.name, true)
end
end
end

-----------------------------

function fix_food_needs ()
-- printall (dfhack.matinfo.find ("PLANT:POD_SWEET:EXTRACT"))
local drinkable = {} -- Entries will be matinfo structures
local edible = {} -- Entries will either be an integer creature index for a whole vermin creature, or a matinfo structure
local rng = dfhack.random.new ()

for i, plant in ipairs (df.global.world.raws.plants.all) do
available_plant = false
end

for i, creature in ipairs (df.global.world.raws.creatures.all) do
available_creature = creature.flags.CASTE_COMMON_DOMESTIC or -- Some of them don't exist in the wild
creature.flags.BIOME_RIVER_TEMPERATE_FRESHWATER or -- Don't know how to check availability
creature.flags.BIOME_RIVER_TEMPERATE_BRACKISHWATER or -- -"-
creature.flags.BIOME_RIVER_TEMPERATE_SALTWATER or -- -"-
creature.flags.BIOME_RIVER_TROPICAL_FRESHWATER or -- -"-
creature.flags.BIOME_RIVER_TROPICAL_BRACKISHWATER or -- -"-
creature.flags.BIOME_RIVER_TROPICAL_SALTWATER -- -"-
end

for i, region in ipairs (df.global.world.world_data.regions) do
for k, pop in ipairs (region.population) do
if pop.type == df.world_population_type.Animal or
pop.type == df.world_population_type.Vermin or
pop.type == df.world_population_type.VerminInnumerable or
pop.type == df.world_population_type.ColonyInsect then
available_creature [pop.race] = true

elseif pop.type == df.world_population_type.Tree or
pop.type == df.world_population_type.Grass or
pop.type == df.world_population_type.Bush then
available_plant [pop.plant] = true
end
end
end

for i, region in ipairs (df.global.world.world_data.underground_regions) do
for k, pop in ipairs (region.feature_init.feature.population) do
if pop.type == df.world_population_type.Animal or
pop.type == df.world_population_type.Vermin or
pop.type == df.world_population_type.VerminInnumerable or
pop.type == df.world_population_type.ColonyInsect then
available_creature [pop.race] = true

elseif pop.type == df.world_population_type.Tree or
pop.type == df.world_population_type.Grass or
pop.type == df.world_population_type.Bush then
available_plant [pop.plant] = true
end
end
end

for i, plant in ipairs (df.global.world.raws.plants.all) do
if available_plant and
not plant.flags.GRASS then -- Grasses can't be harvested in any way, but evil ones are made of meat...
for k, material in ipairs (plant.material) do
if (material.flags.ALCOHOL_PLANT or
material.flags.LIQUID_MISC_PLANT) and
material.flags.EDIBLE_RAW then
table.insert (drinkable, dfhack.matinfo.find ("PLANT:" .. plant.id .. ":" .. material.id))
-- dfhack.println (drinkable [#drinkable].material.state_name.Liquid .. " [" .. drinkable [#drinkable].plant.name .. "]")

elseif not material.flags.LIQUID_MISC_PLANT and -- Oils that can't be drunk raw don't seem to be selected for cooking by DF.
(material.flags.EDIBLE_RAW or
material.flags.EDIBLE_COOKED) and
plant.index ~= feather_tree then -- Feather tree eggs are bugged...
table.insert (edible, dfhack.matinfo.find ("PLANT:" .. plant.id .. ":" .. material.id))
-- if edible [#edible].material.prefix == "" then
-- dfhack.println (edible [#edible].material.state_name.Solid .. " [" .. edible [#edible].plant.name .. "]")
--
-- else
-- dfhack.println (edible [#edible].material.prefix .. " " .. edible [#edible].material.state_name.Solid .. " [" .. edible [#edible].plant.name .. "]")
-- end
end
end
end
end

for i, creature in ipairs (df.global.world.raws.creatures.all) do
if not creature.flags.GENERATED and -- Exclude FBs, demons, etc.
available_creature then
if creature.flags.any_vermin then
local can_be_eaten = false

for k, material in ipairs (creature.material) do
if material.id == "MUSCLE" then
can_be_eaten = true

elseif material.id == "MILK" then
table.insert (drinkable, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
-- dfhack.println (drinkable [#drinkable].material.state_name.Liquid .. " [" .. drinkable [#drinkable].creature.name
.. "]")

elseif material.id == "CHEESE" then
table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
-- dfhack.println (edible [#edible].material.state_name.Solid .. " [" .. edible [#edible].creature.name
.. "]")

end
end

if can_be_eaten then -- Weed out stuff like e.g. fire snakes
table.insert (edible, i)
-- dfhack.println (creature.creature_id)
end

else
local butcherable = true

for k, str in ipairs (creature.raws) do
if str
== "[NOT_BUTCHERABLE]" then

butcherable = false
break
end
end

if min_butcher_size ["MUSCLE"] > creature.adultsize then
butcherable = false -- Technically possibly, but nothing edible resulting
end

for k, material in ipairs (creature.material) do
if material.id == "MILK" then
table.insert (drinkable, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
-- dfhack.println (drinkable [#drinkable].material.state_name.Liquid .. " [" .. drinkable [#drinkable].creature.name
.. "]")

elseif material.id == "CHEESE" then
table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
-- dfhack.println (edible [#edible].material.state_name.Solid .. " [" .. edible [#edible].creature.name
.. "]")

elseif butcherable and
not creature.flags.CASTE_CAN_LEARN and --### Is this the correct criterion?
min_butcher_size [material.id] and
min_butcher_size [material.id] <= creature.adultsize and
butcher_edible [material.id] then
table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
-- dfhack.println (edible [#edible].material.state_name.Solid .. " [" .. edible [#edible].creature.name
.. "]")

end
end
end
end
end

-- dfhack.println (#drinkable, #edible)

for i, unit in ipairs (df.global.world.units.all) do
if (dfhack.units.isCitizen (unit) or
is_resident (unit)) and
dfhack.units.isAlive (unit) and
unit.status.current_soul then
for k, preference in ipairs (unit.status.current_soul.preferences) do
if preference.active then
if preference.type == df.unit_preference.T_type.LikeFood then
local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)

if preference.matindex ~= -1 and
(material.mode == "plant" or
material.mode == "creature") then
if preference.item_type == df.item_type.DRINK or
preference.item_type == df.item_type.LIQUID_MISC then -- The state in the preferences seems locked to Solid
if material.mode == "creature" then
if not available_creature [preference.matindex] or
preference.matindex == bumblebee then
local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
local rng_number = rng:random (#drinkable - 1) + 1 -- To get it into the Lua vector range

dfhack.println ("Replacing unavailable " .. replacement_string (preference, drinkable [rng_number], unit))

preference.mattype = drinkable [rng_number].type
preference.matindex = drinkable [rng_number].index

if drinkable [rng_number].material.flags.ALCOHOL then
preference.item_type = df.item_type.DRINK

else
preference.item_type = df.item_type.LIQUID_MISC
end
end

else
if not available_plant [preference.matindex] then
local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
local rng_number = rng:random (#drinkable - 1) + 1 -- To get it into the Lua vector range

dfhack.println ("Replacing unavailable " .. replacement_string (preference, drinkable [rng_number], unit))
preference.mattype = drinkable [rng_number].type
preference.matindex = drinkable [rng_number].index

if drinkable [rng_number].material.flags.ALCOHOL then
preference.item_type = df.item_type.DRINK

else
preference.item_type = df.item_type.LIQUID_MISC
end
end
end

else
if material.mode == "creature" then
local butcherable = true
local too_small = false

for i, str in ipairs (material.creature.raws) do
if str
== "[NOT_BUTCHERABLE]" then

butcherable = false
break
end
end

if min_butcher_size [material.material.id] then
if min_butcher_size [material.material.id] > material.creature.adultsize then
too_small = true

if min_butcher_size ["MUSCLE"] > material.creature.adultsize then
butcherable = false -- Technically possibly, but nothing edible resulting
end
end

else
dfhack.printerr ("fix_food_needs found unexpected animal food preference (continuing): " .. material.material.id)
end

if not available_creature [preference.matindex] then
local rng_number = rng:random (#edible - 1) + 1 -- To get it into the Lua vector range

dfhack.println ("Replacing non existent " .. replacement_string (preference, edible [rng_number], unit))

if type (edible [rng_number]) == "number" then
preference.mattype = edible [rng_number]
preference.matindex = -1

else
preference.mattype = edible [rng_number].type
preference.matindex = edible [rng_number].index
end

elseif not butcherable then
if material.creature.flags.any_vermin then
dfhack.println ("Replacing vermin part " .. replacement_string (preference, preference.matindex, unit))
preference.mattype = preference.matindex
preference.matindex = -1

else
local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
local rng_number = rng:random (#edible - 1) + 1 -- To get it into the Lua vector range

dfhack.println ("Replacing unbutcherable " .. replacement_string (preference, edible [rng_number], unit))

if type (edible [rng_number]) == "number" then
preference.mattype = edible [rng_number]
preference.matindex = -1

else
preference.mattype = edible [rng_number].type
preference.matindex = edible [rng_number].index
end
end

elseif too_small then
for l, mat in ipairs (material.creature.material) do
if mat.id == "MUSCLE" then
local material = dfhack.matinfo.find ("CREATURE:" .. material.creature.creature_id .. ":MUSCLE")

dfhack.println ("Replacing unobtainable " .. replacement_string (preference, material, unit))

if not material then
dfhack.printerr ("Replacement failed", preference.mattype, preference.matindex)

else
preference.mattype = material.type
preference.matindex = material.index
end

break
end
end
end

else
if not available_plant [preference.matindex] then
local rng_number = rng:random (#edible - 1) + 1 -- To get it into the Lua vector range

dfhack.println ("Replacing unavailable " .. replacement_string (preference, edible [rng_number], unit))

if type (edible [rng_number]) == "number" then
preference.mattype = edible [rng_number]
preference.matindex = -1

else
preference.mattype = edible [rng_number].type
preference.matindex = edible [rng_number].index
end

elseif material.matindex == feather_tree then
local rng_number = rng:random (#edible - 1) + 1 -- To get it into the Lua vector range

dfhack.println ("Replacing unobtainable " .. replacement_string (preference, edible [rng_number], unit))

if type (edible [rng_number]) == "number" then
preference.mattype = edible [rng_number]
preference.matindex = -1

else
preference.mattype = edible [rng_number].type
preference.matindex = edible [rng_number].index
end
end
end
end

elseif not available_creature [preference.mattype] then
local rng_number = rng:random (#edible - 1) + 1 -- To get it into the Lua vector range

dfhack.println ("Replacing unavailable " .. replacement_string (preference, edible [rng_number], unit))

if type (edible [rng_number]) == "number" then
preference.mattype = edible [rng_number]
preference.matindex = -1

else
preference.mattype = edible [rng_number].type
preference.matindex = edible [rng_number].index
end
end
end
end
end
end
end
end

fix_food_needs ()

The script replaces vermin parts with the whole vermin, unobtainable butchery products with muscle (which is checked that it should be possible to obtain), and otherwise replaces unavailable drinks with a random possible one, and unavailable food with a random possible one.

Saiko Kila · « **Reply #51 on:** November 17, 2018, 05:36:39 pm »

I'd look at it when I have time tomorrow (since it would be 7th version I'd need to to modify for my fortress

) but there's one bug I noticed earlier: the thresholds for animal size are one order of magnitude too high. This is reason why things like wolf's spleen is tagged as "too small". The thresholds are apparently in grams (the same as in real RAWs, for example 40000 for wolf's adult size), while the raw structure in dfhack uses decagrams (the same as in-game displayed size for traps, or body size in unit structures, for example 4000 for wolf). So line

Code: [Select]

if min_butcher_size [material.material.id] > material.creature.adultsize thenshould be

Code: [Select]

if min_butcher_size [material.material.id] > material.creature.adultsize*10 thento account for that.

PatrikLundell · « **Reply #52 on:** November 18, 2018, 03:33:43 am »

Thanks. I'll adjust the size structure rather than try to hunt down the usages, though.

I've updated the booze_cooker script:
- It now covers residents as well as citizens
- All food item slots are populated, not just the last ("booze") one. The logic tries to select cookable items that exist in the fortress, excluding STRUCTURAL plants unless they yield fruit (because the structure is what produces seeds and everything else). Seeds are permitted to be cooked only if there are at least 50 of them or they're from trees.
- An attempt at a "just in time" cooking order is used, so the script adds up to 3 cooking jobs (it seems you can't actually do more than at most 2 in a week).
- Very limited testing. It's likely some things don't work as intended. I offer only the money (0) back, but don't accept damages!

Spoiler (click to show/hide)

Code: [Select]

local target_meal_count = 16  --  The number of meals to keep in stock per dorf.
                              --  16 should be 1 year's worth (1 meal every 3 weeks, according to wiki)
local verbose = true          --  Prints every meal added. You probably want to set it to false when/if
                              --  you believe it works correctly.

local seed_cooking_limit = 50 --  Number of seeds required before we can start to cook them.
                              --  Does not apply to trees, as those seeds can't be planted.
                           
--  Structure for storing stocks. The layout is:
--  [category] [mat_index] [mat_type] containing
--    {#items, Cookable, #preferences, is_base for it} as [1], [2], [3], and [4]. Mat_type is -1 for eggs,
--    fish, and raw fish. "is_base" is set to true for the plant part that forms the base for production
--    of other products, which is either "STRUCTURAL" or "FRUIT".
--  The function "take_stock" populates the structure, apart from #preferences, which is
--  initiated to 0 (and currently isn't used at all).
--
local stock = {["booze"] = {},  --  any_drink. How does it differ from drink? Mead included in both?
               ["liquid_misc"] = {},
               ["powder_misc"] = {},
               ["glob"] = {},
               ["meat"] = {},
               ["fish"] = {},
               ["fish_raw"] = {},
               ["egg"] = {},
               ["seeds"] = {},
               ["plant"] = {},
               ["fruit"] = {},  --  plant_growth
               ["cheese"] = {}}
                 
local vector = {["booze"] = "ANY_DRINK",
                ["liquid_misc"] = "LIQUID_MISC",
                ["powder_misc"] = "POWDER_MISC",
                ["glob"] = "GLOB",
                ["meat"] = "MEAT",
                ["fish"] = "FISH",
                ["fish_raw"] = "FISH_RAW",
                ["egg"] = "EGG",
                ["seeds"] = "SEEDS",
                ["plant"] = "PLANT",
                ["fruit"] = "PLANT_GROWTH",
                ["cheese"] = "CHEESE"}                 
                          
--  Variables used to iterate over stock, even when
--  the stock contents varies.
--
local category_iterator
local mat_index_iterator = 0
local mat_type_iterator = -2  --  We do use -1, so -2 is used as "null"

local category_start
local category_end
local max_mat_type = 0
local max_mat_index = 0

--  Find out the order in which "next" iterates over categories to find the first and
--  last ones
--    
for i, value in pairs (vector) do
  if i ~= "booze" and
     i ~= "liquid_misc" then
    if not category_start then
      category_start = i
    end
    
    category_end = i
  end
end

category_iterator = category_start

--  Try to determine the largest mat_type and mat_index values possible
--
for i, category in pairs (df.global.world.raws.mat_table.organic_types) do
  for k, value in ipairs (category) do
    if value > max_mat_type then
      max_mat_type = value
    end
    
    if df.global.world.raws.mat_table.organic_indexes [i] [k] > max_mat_index then
      max_mat_index = df.global.world.raws.mat_table.organic_indexes [i] [k]
    end
  end
end

-----------------------------

function add (list, item, preference)
  for i, element in ipairs (list) do
    if element [1] == item then
      list [i] [2] = list [i] [2] + 1
      return
    end
  end
  
  table.insert (list, {item, 1, preference})
end

-----------------------------

function sort (list)
  local temp
  
  for i = 1, #list - 1 do
    for k = i + 1, #list do
      if list [k] [1] < list [i] [1] then
        temp = list [i]
        list [i] = list [k]
        list [k] = temp
      end
    end
  end
end

-----------------------------

function is_resident (unit)
  return not dfhack.units.isCitizen (unit) and
         unit.civ_id == df.global.ui.civ_id and
         not unit.flags1.marauder and
         not unit.flags1.tame and
         not unit.flags2.visitor and
         not unit.flags1.merchant and
         not unit.flags1.forest and
         not unit.flags1.diplomat
end

-----------------------------

function get_next_stock_item ()
  local i = category_iterator
  local mat_index_iter = mat_index_iterator
  local mat_type_iter = mat_type_iterator
  local last_attempt = false
  
  while true do
    if stock [i] then
      for k = mat_index_iter, max_mat_index do
        if last_attempt and
           k > mat_index_iterator then
          mat_type_iterator = -2  --  Failure to find anything
          return
        end   
        
        if stock [i] [k] then    
          for l = mat_type_iter + 1, max_mat_type do
            if last_attempt and
               k == mat_index_iterator and
               l > mat_type_iterator then
              mat_type_iterator = -2  --  Failure to find anything
              return
            end
            
            if stock [i] [k] [l] then
              if stock [i] [k] [l] [2] then    --  Cookable
                local use_it = true
              
                if stock [i] [k] [l] [4] then
                  use_it = false  --###  Need to change this to cook "junk" plants if
                                  --###  sufficient seeds are available.
                
                elseif i == "seeds" then
                  local material = dfhack.matinfo.decode (l, k)

                  use_it = material.plant.flags.TREE or
                           stock [i] [k] [l] [1] >= seed_cooking_limit
                end
              
                if use_it then
                  categor_iterator = i
                  mat_index_iterator = k
                  mat_type_iterator = l
                
                  return  --  The actual results is found in the set of iterators
                end
              end
            end
          end
        
          mat_type_iter = -2
        end
      end
    end
    
    mat_index_iter = 0
    
    if i == category_end then
      i = category_start
      
    else
      i, v = next (vector, i)
    end
    
    if i == category_iterator then
      last_attempt = true
    end
  end
end

-----------------------------

function take_stock ()
  for i, dummy in pairs (stock) do
    for k, item in ipairs (df.global.world.items.other [vector [i]]) do
      if item.flags.trader or
         item.flags.forbid then
        --  null. Skip stuff that's not actually available
        
      elseif (i == "liquid_misc" or         --  Skip liquids not in containers (such as FB secretions)
              i == "booze") and             --  as well as the stupid feather tree egg yolk contaminating
             (#item.general_refs == 0 or    --  the trade depot. Spilled booze is probably a contaminant
              (#item.general_refs == 1 and  --  but doesn't hurt to exclude it here as well.
               item.general_refs [0]._type == df.general_ref_building_holderst)) then
        --  null
        
      elseif i == "egg" or          --  Eggs don't have mat_index/mat_type, as they're composite items
             i == "fish" or         --  and I think fish works the same.
             i == "fish_raw" then
        if not stock [i] [item.race] then
          stock [i] [item.race] = {}
        end
        
        if not stock [i] [item.race] [-1] then
            stock [i] [item.race] [-1] = {0, true, 0, false}  --  Assume all eggs and all fish can be cooked.
        end
        
        stock [i] [item.race] [-1] [1] = stock [i] [item.race] [-1] [1] + item.stack_size
        
      else
        local material = dfhack.matinfo.decode (item.mat_type, item.mat_index)
    
        if material.mode == "plant" or
           material.mode == "creature" then
       
          if not stock [i] [item.mat_index] then
            stock [i] [item.mat_index] = {}
          end
      
          if not stock [i] [item.mat_index] [item.mat_type] then
            stock [i] [item.mat_index] [item.mat_type] = {0, material.material.flags.EDIBLE_COOKED, 0, i == "fruit"}
            
            if i == "plant" and
               material.material.id == "STRUCTURAL" then
              local has_fruit = false
            
              for k, growth in ipairs (material.plant.growths) do
                if growth.id == "FRUIT" then
                  has_fruit = true
                  break
                end
              end
            
              stock [i] [item.mat_index] [item.mat_type] [4] = not has_fruit
            end             
          end
      
          stock [i] [item.mat_index] [item.mat_type] [1] = stock [i] [item.mat_index] [item.mat_type] [1] + item.stack_size
          
        elseif i == "liquid_misc" and
               material.mode == "builtin" then
          --  null. Water and possibly magma
            
        elseif i == "powder_misc" and
               material.mode == "inorganic" then
          --  null. At least sand falls into this category
          
        else
          dfhack.printerr ("take_stock encountered unexpected " ..vector [i] .." material mode: " .. material.mode, material.material.id, item.mat_type, item.mat_index)
        end
      end
    end
  end
end

-----------------------------

function get_food_needs ()
  local preferences = {}
  
  for i, unit in ipairs (df.global.world.units.all) do
    if (dfhack.units.isCitizen (unit) or
        is_resident (unit)) and
       dfhack.units.isAlive (unit) and
       unit.status.current_soul then
      for k, preference in ipairs (unit.status.current_soul.preferences) do
        if preference.active then
          if  preference.type == df.unit_preference.T_type.LikeFood then
            local found = false
            
            for l, pref in ipairs (preferences) do
              if pref.mattype == preference.mattype and
                 pref.matindex == preference.matindex and
                 pref.item_type == preference_item_type then
                found = true
                break
              end
            end
            
            if not found then
              table.insert (preferences, preference)
            end
          end
        end
      end
    end
  end

  local drink_list = {}
  local food_list = {}
  
  for i, preference in ipairs (preferences) do
    local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
            
    if preference.matindex ~= -1 and 
       (material.mode == "plant" or
        material.mode == "creature") then
      if preference.item_type == df.item_type.DRINK or 
         preference.item_type == df.item_type.LIQUID_MISC then  --  The state in the preferences seems locked to Solid
         add (drink_list, material.material.state_name.Liquid, preference)
              
      else                
        if material.material.prefix == "" then
          add (food_list, material.material.state_name.Solid, preference)
                
        else
          add (food_list, material.material.prefix .. " " .. material.material.state_name.Solid, preference)
        end
      end            
            
    else
      add (food_list, df.global.world.raws.creatures.all [preference.mattype].name [0], preference)
    end
  end
  
  sort (drink_list)
  sort (food_list)
  
--  dfhack.color (COLOR_YELLOW)
--  dfhack.println ("Drink preferences found:")
--  dfhack.color (COLOR_RESET)
  
--  for i, drink in ipairs (drink_list) do
--    dfhack.println (drink [1], drink [2], drink [3].mattype, drink [3].matindex)
--  end
  
--  dfhack.println ()
--  dfhack.color (COLOR_YELLOW)
--  dfhack.println ("Food preferences found:")
--  dfhack.color (COLOR_RESET)
  
--  for i, food in ipairs (food_list) do
--    dfhack.println (food [1], food [2])
--  end
  
  return drink_list, food_list
end

-----------------------------

function matching_meals (preference)
  local count = 0
  
  for i, food in ipairs (df.global.world.items.other.FOOD) do
    for k, ingredient in ipairs (food.ingredients) do
      if ingredient.mat_type == preference.mattype and
         ingredient.mat_index == preference.matindex then
        count = count + food.stack_size
        break
      end
    end
  end
  
  return count
end

-----------------------------

local drink_list = {}
local food_list = {}
local current_drink = 1
local job_list_size = 10
local max_jobs = 3
  
-----------------------------

function drink_available (preference)
  if preference.item_type == df.item_type.DRINK then
    return stock ["booze"] and
           stock ["booze"] [preference.matindex] and
           stock ["booze"] [preference.matindex] [preference.mattype] and
           stock ["booze"] [preference.matindex] [preference.mattype] [1] > 0
  
  elseif preference.item_type == df.item_type.LIQUID_MISC then
    return stock ["liquid_misc"] and
           stock ["liquid_misc"] [preference.matindex] and
           stock ["liquid_misc"] [preference.matindex] [preference.mattype] and
           stock ["liquid_misc"] [preference.matindex] [preference.mattype] [1] > 0
  
  else
    local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
    
    dfhack.printerr ("Unaccounted for 'drinks' df.item_type of " .. df.item_type [preference.item_type] .. " for " .. material.material.state_name.Liquid)
    return false
  end
end

-----------------------------

function callback ()
--  dfhack.println ("callback invoked")
  local current_kitchen = 0
  local failure_to_get_stock = false
  
  take_stock ()
  
  if #drink_list == 0 then
      drink_list, food_list = get_food_needs ()
  end
  
  for i = current_drink, #drink_list do
    if current_drink < #drink_list then
      current_drink = current_drink + 1
    
    else
      drink_list, food_list = get_food_needs ()
      current_drink = 1
    end

    if drink_available (drink_list [current_drink] [3]) and
       matching_meals (drink_list [current_drink] [3]) < target_meal_count * drink_list [current_drink] [2] then
      local current_jobs = 0
      
      for k, job in ipairs (df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].jobs) do
        if job.job_type == df.job_type.PrepareMeal then
          current_jobs = current_jobs + 1
        end
      end
      
      while #df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].jobs >= job_list_size or
            current_jobs >= max_jobs do
        current_kitchen = current_kitchen + 1
        
        if #df.global.world.buildings.other.WORKSHOP_KITCHEN <= current_kitchen then
          current_kitchen = 0
          dfhack.timeout (7, 'days', callback)  
          return
        end
        
        current_jobs = 0
        
        for k, job in ipairs (df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].jobs) do
          if job.job_type == df.job_type.PrepareMeal then
            current_jobs = current_jobs + 1
          end
        end
      end
      
      local job = df.job:new ()

      job.job_type = df.job_type.PrepareMeal
      job.pos.x = df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].centerx
      job.pos.y = df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].centery
      job.pos.z = df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].z
      job.mat_type = 4
      job.wait_timer = 0
      job.general_refs:insert ("#", df.general_ref_building_holderst:new ())
      job.general_refs [0].building_id = df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].id
      job.job_items:insert ("#", df.job_item:new ())
      job.job_items:insert ("#", df.job_item:new ())
      job.job_items:insert ("#", df.job_item:new ())
      job.job_items:insert ("#", df.job_item:new ())
      
      job.job_items [0].flags1.solid = true
      
      for l, job_item in ipairs (job.job_items) do
        job.job_items [l].flags1.unrotten = true
        job.job_items [l].flags1.cookable = true
        job.job_items [l].quantity = 1
        job.job_items [l].vector_id = df.job_item_vector_id.ANY_COOKABLE
        
        if l ~= 3 then
          get_next_stock_item ()
          
          if mat_type_iterator == -2 then
            failure_to_get_stock = true
            break
          end
          
          job.job_items [l].item_type = df.item_type [vector [categor_iterator]]
          job.job_items [l].mat_type = mat_type_iterator
          job.job_items [l].mat_index = mat_index_iterator
        end
      end
      
      if failure_to_get_stock then
        for l, job in ipairs (job.job_items) do
          df.job_item:delete (job.job_items [l])
        end
        
        job:delete ()
        dfhack.printerr ("Failure to find enough stock to create booze cooking job. Skipping this iteration.")
        break
      end
      
      job.job_items [3].item_type = drink_list [current_drink] [3].item_type
      job.job_items [3].mat_type = drink_list [current_drink] [3].mattype
      job.job_items [3].mat_index = drink_list [current_drink] [3].matindex
      
      df.global.world.buildings.other.WORKSHOP_KITCHEN [current_kitchen].jobs:insert ("#", job)
      dfhack.job.linkIntoWorld (job, true)
      
      if verbose then
        dfhack.println ("Adding job to prepare " .. drink_list [current_drink] [1] .. " roasts.")
      end
    end
  end
  
  dfhack.timeout (7, 'days', callback)  
end

-----------------------------

function booze_cooker ()  
  if #df.global.world.buildings.other.WORKSHOP_KITCHEN == 0 then
    dfhack.color (COLOR_LIGHTRED)
    dfhack.println ("No kitchen found!")
    dfhack.color (COLOR_RESET)
    return
  end
  
  callback ()
end

booze_cooker ()

Saiko Kila · « **Reply #53 on:** November 20, 2018, 06:25:42 pm »

Regarding the first script, the one http://www.bay12forums.com/smf/index.php?topic=172335.msg7888383#msg7888383
I've spent more time with testing it. First technical, the script is a quote not a "code", needs to be copied, and since some lines are too long for my web browserI had to edit it to prevent related errors. Not a big deal if someone knows Lua commenting style, but there it is. Second technical was I had to change

Spoiler (click to show/hide)

Code: [Select]

return old_str .. " with " .. new_str .. " on " .. dfhack.TranslateName (unit.name, true)to

Code: [Select]

return old_str .. " with " .. tostring(new_str) .. " on " .. dfhack.TranslateName (unit.name, true)

because new_str is treated as userdata data type, not as a string and it throws an error.
Third technical was I had to change lines

Spoiler (click to show/hide)

Code: [Select]

  for i, plant in ipairs (df.global.world.raws.plants.all) do
    available_plant = false
  end
 
  for i, creature in ipairs (df.global.world.raws.creatures.all) do
    available_creature = creature.flags.CASTE_COMMON_DOMESTIC  or

to

Code: [Select]

for i, plant in ipairs (df.global.world.raws.plants.all) do
    available_plant[plant] = false
  end
 
  for i, creature in ipairs (df.global.world.raws.creatures.all) do
    available_creature[creature] = creature.flags.CASTE_COMMON_DOMESTIC  or

I suppose this is how it was intended, but I note it in case it causes some funny things.

Now about the workings, the actual working and changes to dwarves. During first pass it caused some changes, for instance
IMPOSSIBLE bumblebee mead [bumblebee]
to
dwarven milk [purring maggot]
You may say that it's changing something impossible to something theoretically possible, so it's theoretically fine, but it also does change alcohol into non-alcohol. Now I don't know if it at all matters to the dwarf to have one alcohol, but sans the one hillock generated imigrant (which was created by the game de novo, like seven initital dwarves) all people do have one alcohol preference, and sometimes (often, I would say) it's the only food preference they have. So I think it would be good after change to still have one alcohol (or two).

Another change was
TOO SMALL desert tortoise gizzard tissue [desert tortoise]
to
donkey stomach tissue [donkey]
which was OK, but after I ran the script second time (because there were still two impossible foods) this happened
donkey stomach tissue [donkey]
to
giant slug liver tissue
Hm. Only reason I can think of is some residual cache of Lua, a problem which I also run into sometimes with my scripts, when they can reuse a variable between different runs (instead of having it reinitialised/cleared). So in this cases the variable needs to be cleared explicitly or something. Not that big deal overall, but something which can surprise an user.

However, third weird change I noticed was harder to explain:
cow cheese [cow]
to
UNAVAILABLE roc muscle [roc]
It was on the first run. This was changed again in the second run:
UNAVAILABLE roc muscle [roc]
to
hippo heart tissue
Which is OK. But why change the perfectly fine cheese to roc meat in the first place?

There was similar issue with other dwarf:
penguin muscle [penguin]
to
UNAVAILABLE giant damselfly stomach tissue [giant damselfly]
which in second run was repaired with this change:
UNAVAILABLE giant damselfly stomach tissue [giant damselfly]
to
giant hedgehog pancreatic tissue
There were of course many other changes (I ran it on fortress of 160 people), but these struck me as somewhat strange. You may keep an eye on cases like this.

----------

Regarding the second script, the booze cooker, this is first time I ran it, so I didn't fully know what to expect. First a technical: it throws an error (or rather warning) of "take_stock encountered unexpected LIQUID_MISC material mode: inorganic 0 33", which is caused by milk of lime. I added lines

Code: [Select]

elseif i == "liquid_misc" and
               material.mode == "inorganic" then

in appropriate place, and the error disappeared.

As for the working, it seems it is working. I'm not quite accustomed to reading scripts of other people, this is the third dfhack script I read (other than mine own), so I don't fully understand what it is doing yet, but apart from one error once (it was expecting integer in line "job.job_items [l].item_type = df.item_type [vector [categor_iterator]]", I don't know why it wasn't getting an integer), it creates up to three jobs per kitchen, with seemingly preference for powder (flour) in the first three, but maybe it's because they are the freshest thing.

PatrikLundell · « **Reply #54 on:** November 21, 2018, 03:55:22 am »

Thanks for the testing. I'll try to understand what's happening and fix the problems.

The booze cooker script is set up to generate a callback every 7 days, at which time it tries to fill each kitchen queue up to 3 lavish meal orders. The reason you get flour in the first 3 spots is because of how the script tries to allocate resources. The take_stock function collects what's available at every callback, while an iterator group of 3 variables iterates over all items deemed suitable for filling out meals. This iteration starts with the first category you have in your fortress, which seems to be powder_misc, and allocates one item to each of the first 3 slots (they should all be different flours). When all powder_misc entries have been sampled, it moves over to the next category to take one of each of those. Note that the iteration is a rather convoluted construction because it's intended to iterate over the whole stock over several iterations, taking into account that the stock will change between the callbacks. This means that the next week you may get more flour containing roasts, while the week after you'll get one with the last kinds of flour, and the rest taken from the next category (whichever that is). If it works as intended, it should eventually return back to powders again when all items have been sampled.

Edit: I've updated the fix_food_needs script:

Spoiler (click to show/hide)

Code: [Select]

--  Bumblebee honey is impossible to obtain in vanilla, and thus does bumblebee mead remain
--  out of reach. Feather trees are bugged so you can't get any eggs, and thus not get at
--  the egg white or yolk (despite the trade depot being contaminated by feather tree egg
--  yolk after the elves have visited).
--
local bumblebee = -1
local feather_tree = -1

for i, creature in ipairs (df.global.world.raws.creatures.all) do
  if creature.creature_id == "BUMBLEBEE" then
    bumblebee = i
    break
  end
end

for i, plant in ipairs (df.global.world.raws.plants.all) do
  if plant.id == "FEATHER" then
    feather_tree = i
    break
  end
end

local min_butcher_size = --  Data taken from http://www.bay12forums.com/smf/index.php?topic=78108.0
                         --  The values are shifted down one order of magnitude to match the ingame (rather than the raw) unit.
  {["MUSCLE"] =          190,  --  Meat in the reference
   ["FAT"] =             190,  --  Haven't seen any preferences for it
   ["TALLOW"] =          190,  --  i.e. rendered fat. Haven't seen any preferences for it, though
   ["SKIN"] =            190,  --  Inedible, but here for completeness
   ["BONE"] =            200,  --  Inedible
   ["INTESTINES"] =      500,
   ["BRAIN"] =          1000,
   ["LUNG"] =           1000,
   ["LIVER"] =          1000,
   ["STOMACH"] =        1000,  --  Called tripe as food
   ["GUT"] =            1000,  --  ###Not in reference. Guessing it's the same most others.
   ["GIZZARD"] =        1000,  --  Not in reference. Wiki claims size similar to brain and liver.
                               --    Wiki DF2014:Prepared_organs does not list Gut or Gizzard.
   ["NERVE"] =          1500,  --  ###Name not checked. Inedible anyway
   ["HOOF"] =           1500,  --  Inedible
   ["HEART"] =          2000,
   ["PANCREAS"] =       2000,  --  Called sweetbread as food
   ["SPLEEN"] =         2000,
   ["KIDNEY"] =         2000,
   ["HORN"] =           2000,  --  Inedible
   ["CARTILAGE"] =     20000,  --  Inedible
   ["HAIR"] =          20000,  --  Inedible
   ["EYE"] =           50000,
   ["TOOTH"] =       2500000,  --  Inedible
   ["CHEESE"] =            0}  --  Not a butcher product, and thus no size relation, but exists as food preferences.

local butcher_edible =
  {["MUSCLE"] =         true,  --  Meat in the reference
   ["FAT"] =           false,  --  Haven't seen any preferences for it
   ["TALLOW"] =        false,  --  i.e. rendered fat. Haven't seen any preferences for it, though
   ["SKIN"] =          false,  --  Inedible, but here for completeness
   ["BONE"] =          false,  --  Inedible
   ["INTESTINES"] =     true,
   ["BRAIN"] =          true,
   ["LUNG"] =           true,
   ["LIVER"] =          true,
   ["STOMACH"] =        true,  --  Called tripe as food
   ["GUT"] =            true,  --  ###Not in reference. Guessing it's the same most others.
   ["GIZZARD"] =        true,  --  Not in reference. Wiki claims size similar to brain and liver.
                               --    Wiki DF2014:Prepared_organs does not list Gut or Gizzard.
   ["NERVE"] =         false,  --  Inedible
   ["HOOF"] =          false,  --  Inedible
   ["HEART"] =          true,
   ["PANCREAS"] =       true,  --  Called sweetbread as food
   ["SPLEEN"] =         true,
   ["KIDNEY"] =         true,
   ["HORN"] =          false,  --  Inedible
   ["CARTILAGE"] =     false,  --  Inedible
   ["HAIR"] =          false,  --  Inedible
   ["EYE"] =            true,
   ["TOOTH"] =         false,  --  Inedible
   ["CHEESE"] =        false}  --  Handled separately, like milk
   

local available_plant = {}
local available_creature = {}

-----------------------------

function item_type_of (matinfo)
  if type (matinfo) == "number" then
    if df.global.world.raws.creatures.all [matinfo].flags.VERMIN_FISH then
      return df.item_type.FISH
      
    else
      return df.item_type.MEAT
    end
    
  else
    if matinfo.material.flags.MEAT then
      return df.item_type.MEAT
      
    elseif matinfo.material.flags.ALCOHOL then
      return df.item_type.DRINK
      
    elseif matinfo.material.flags.POWDER_MISC then
      return df.item_type.POWDER_MISC
      
    elseif matinfo.material.flags.LIQUID_MISC then
      return df.item_type.LIQUID_MISC

    elseif matinfo.material.flags.STRUCTURAL_PLANT_MAT then
      return df.item_type.PLANT
      
    elseif matinfo.material.flags.SEED_MAT then
      return df.item_type.SEEDS
      
    elseif matinfo.material.flags.LEAF_MAT then
      return df.item_type.PLANT_GROWTH

    elseif matinfo.material.flags.CHEESE then
      return df.item_type.CHEESE
    
    else
      dfhack.printerr ("item_type_of encountered item it couldn't classify: " .. matinfo.material.id)
    end
  end
end

-----------------------------

function is_resident (unit)
  return not dfhack.units.isCitizen (unit) and
         unit.civ_id == df.global.ui.civ_id and
         not unit.flags1.marauder and
         not unit.flags1.tame and
         not unit.flags2.visitor and
         not unit.flags1.merchant and
         not unit.flags1.forest and
         not unit.flags1.diplomat
end

-----------------------------

function replacement_string (preference, replacement, unit)
  local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
  
  if preference.item_type == df.item_type.DRINK or 
     preference.item_type == df.item_type.LIQUID_MISC then  --  The state in the preferences seems locked to Solid
    local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
    
    return material.material.state_name.Liquid .. 
           " with " .. replacement.material.state_name.Liquid ..
           " on " .. dfhack.TranslateName (unit.name, true)
   
  else
    if old_mat.mode == "creature"  then
      local old_str = ""
      local new_str = ""
      
      if not old_mat then
        old_str = df.global.world.raws.creatures.all [preference.mattype].name [0]
        
      elseif old_mat.material.prefix == "" then
        old_str = old_mat.material.state_name.Solid
        
      else
        old_str =  old_mat.material.prefix .. " " .. old_mat.material.state_name.Solid
      end
      
      if type (replacement) == "number" then
        new_str = df.global.world.raws.creatures.all [replacement].name [0]
          
      else        
        if replacement.material.prefix == "" then
          new_str = replacement.material.state_name.Solid
          
        else
          new_str = replacement.material.prefix .. " " .. replacement.material.state_name.Solid
        end
      end
      
      return old_str .. " with " .. tostring (new_str) .. " on " .. dfhack.TranslateName (unit.name, true)
      
    else
      local old_str = ""
      local new_str = ""
      
      if not old_mat then
        old_str = df.global.world.raws.plants.all [preference.mattype].name
        
      elseif  old_mat.material.prefix == "" then
        old_str =  mat.material.state_name.Solid
        
      else
        old_str =  mat.material.prefix .. " " .. mat.material.state_name.Solid
      end
      
      if type (replacement) == "number" then
        new_str = df.global.world.raws.plants.all [replacement].name
          
      else        
        if replacement.material.prefix == "" then
          new_str = replacement.material.state_name.Solid
          
        else
          new_str = replacement.material.prefix .. " " .. replacement.material.state_name.Solid
        end
      end
      
      return old_str .. " with " .. tostring (new_str) .. " on " .. dfhack.TranslateName (unit.name, true)
    end
  end
end

-----------------------------

function fix_food_needs ()
--  printall (dfhack.matinfo.find ("PLANT:POD_SWEET:EXTRACT"))
--  printall (dfhack.matinfo.find ("CREATURE:COW:CHEESE"))
  local drinkable = {}  --  Entries will be matinfo structures
  local edible = {}     --  Entries will either be an integer creature index for a whole vermin creature,
                        --  or a matinfo structure
  local rng = dfhack.random.new ()
  
  for i, plant in ipairs (df.global.world.raws.plants.all) do
    available_plant [i] = false
  end
  
  for i, creature in ipairs (df.global.world.raws.creatures.all) do
    available_creature [i] = creature.flags.CASTE_COMMON_DOMESTIC  or               --  Some of them don't exist in the wild
                             creature.flags.BIOME_RIVER_TEMPERATE_FRESHWATER or     --  Don't know how to check availability
                             creature.flags.BIOME_RIVER_TEMPERATE_BRACKISHWATER or  --  -"-
                             creature.flags.BIOME_RIVER_TEMPERATE_SALTWATER or      --  -"-
                             creature.flags.BIOME_RIVER_TROPICAL_FRESHWATER or      --  -"-
                             creature.flags.BIOME_RIVER_TROPICAL_BRACKISHWATER or   --  -"-
                             creature.flags.BIOME_RIVER_TROPICAL_SALTWATER          --  -"-
  end
  
  for i, region in ipairs (df.global.world.world_data.regions) do
    for k, pop in ipairs (region.population) do
      if pop.type == df.world_population_type.Animal or
         pop.type == df.world_population_type.Vermin or
         pop.type == df.world_population_type.VerminInnumerable or
         pop.type == df.world_population_type.ColonyInsect then
        available_creature [pop.race] = true
        
      elseif pop.type == df.world_population_type.Tree or
             pop.type == df.world_population_type.Grass or
             pop.type == df.world_population_type.Bush then
        available_plant [pop.plant] = true
      end
    end
  end
  
  for i, region in ipairs (df.global.world.world_data.underground_regions) do
    for k, pop in ipairs (region.feature_init.feature.population) do
      if pop.type == df.world_population_type.Animal or
         pop.type == df.world_population_type.Vermin or
         pop.type == df.world_population_type.VerminInnumerable or
         pop.type == df.world_population_type.ColonyInsect then
        available_creature [pop.race] = true
        
      elseif pop.type == df.world_population_type.Tree or
             pop.type == df.world_population_type.Grass or
             pop.type == df.world_population_type.Bush then
        available_plant [pop.plant] = true
      end
    end
  end
  
  for i, plant in ipairs (df.global.world.raws.plants.all) do
    if available_plant [i] and
       not plant.flags.GRASS then  -- Grasses can't be harvested in any way, but evil ones are made of meat...
      for k, material in ipairs (plant.material) do
        if (material.flags.ALCOHOL_PLANT or
            material.flags.LIQUID_MISC_PLANT) and
           material.flags.EDIBLE_RAW then
          table.insert (drinkable, dfhack.matinfo.find ("PLANT:" .. plant.id .. ":" .. material.id))
          
        elseif not material.flags.LIQUID_MISC_PLANT and  --  Oils that can't be drunk raw don't seem to be cooked by DF.
               (material.flags.EDIBLE_RAW or
                material.flags.EDIBLE_COOKED) and
               plant.index ~= feather_tree then  --  Feather tree eggs are bugged...
          table.insert (edible, dfhack.matinfo.find ("PLANT:" .. plant.id .. ":" .. material.id))
        end
      end
    end
  end
  
  for i, creature in ipairs (df.global.world.raws.creatures.all) do
    if not creature.flags.GENERATED and  --  Exclude FBs, demons, etc.
       available_creature [i] then
      if creature.flags.any_vermin then
        local can_be_eaten = false

        for k, material in ipairs (creature.material) do
          if material.id == "MUSCLE" then
            can_be_eaten = true
            
          elseif material.id == "MILK" then
            table.insert (drinkable, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
            
          elseif material.id == "CHEESE" then
            table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
          end
        end
        
        if can_be_eaten then  --  Weed out stuff like e.g. fire snakes
          table.insert (edible, i)
        end
        
      else
        local butcherable = true
                  
        for k, str in ipairs (creature.raws) do
          if str [0] == "[NOT_BUTCHERABLE]" then
            butcherable = false
            break
          end
        end
        
        if min_butcher_size ["MUSCLE"] > creature.adultsize then
          butcherable = false  --  Technically possibly, but nothing edible resulting
        end
                
        for k, material in ipairs (creature.material) do
          if material.id == "MILK" then
              table.insert (drinkable, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
            
          elseif material.id == "CHEESE" then
              table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
            
          elseif butcherable and
                 not creature.flags.CASTE_CAN_LEARN and  --### Is this the correct criterion?
                 min_butcher_size [material.id] and
                 min_butcher_size [material.id] <= creature.adultsize and
                 butcher_edible [material.id] then
            table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))            
          end    
        end
      end
    end
  end
  
--  dfhack.println (#drinkable, #edible)
  
  for i, unit in ipairs (df.global.world.units.all) do
    if (dfhack.units.isCitizen (unit) or
        is_resident (unit)) and
       dfhack.units.isAlive (unit) and
       unit.status.current_soul then
      for k, preference in ipairs (unit.status.current_soul.preferences) do
        if preference.active then
          if preference.type == df.unit_preference.T_type.LikeFood then          
            local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
            
            if preference.matindex ~= -1 and 
               (material.mode == "plant" or
                material.mode == "creature") then
              if preference.item_type == df.item_type.DRINK or 
                 preference.item_type == df.item_type.LIQUID_MISC then  --  The state in the preferences seems locked to Solid
                if material.mode == "creature"  then
                  if not available_creature [preference.matindex] or
                     preference.matindex == bumblebee then
                    local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
                    local rng_number = rng:random (#drinkable - 1) + 1  --  To get it into the Lua vector range
                    
                    while preference.item_type == df.item_type.DRINK and
                          not drinkable [rng_number].material.flags.ALCOHOL do
                      rng_number = rng:random (#drinkable - 1) + 1
                    end
                    
                    dfhack.println ("Replacing unavailable " .. replacement_string (preference, drinkable [rng_number], unit))
                    
                    preference.mattype = drinkable [rng_number].type
                    preference.matindex = drinkable [rng_number].index                                                
                    preference.item_type = item_type_of (drinkable [rng_number])
                    preference.item_subtype = drinkable [rng_number].subtype
                  end
                
                else
                  if not available_plant [preference.matindex] then
                    local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
                    local rng_number = rng:random (#drinkable - 1) + 1  --  To get it into the Lua vector range
                    
                    while preference.item_type == df.item_type.DRINK and
                          not drinkable [rng_number].material.flags.ALCOHOL do
                      rng_number = rng:random (#drinkable - 1) + 1
                    end
                    
                    dfhack.println ("Replacing unavailable " .. replacement_string (preference, drinkable [rng_number], unit))
                    preference.mattype = drinkable [rng_number].type
                    preference.matindex = drinkable [rng_number].index
                    preference.item_type = item_type_of (drinkable [rng_number])                    
                    preference.item_subtype = drinkable [rng_number].subtype
                  end
                end
        
              else  --  Food
                if material.mode == "creature" then
                  local butcherable = true
                  local too_small = false
                  
                  for i, str in ipairs (material.creature.raws) do
                    if str [0] == "[NOT_BUTCHERABLE]" then
                      butcherable = false
                      break
                    end
                  end
        
                  if min_butcher_size [material.material.id] then
                    if min_butcher_size [material.material.id] > material.creature.adultsize then
                      too_small = true
                      
                      if min_butcher_size ["MUSCLE"] > material.creature.adultsize then
                        butcherable = false  --  Technically possibly, but nothing edible resulting
                      end
                    end
          
                  else
                    dfhack.printerr ("fix_food_needs found unexpected animal food preference (continuing): " .. material.material.id)
                  end
                  
                  if not available_creature [preference.matindex] then
                    local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                    dfhack.println ("Replacing non existent " .. replacement_string (preference, edible [rng_number], unit))
                    
                    if type (edible [rng_number]) == "number" then
                      preference.mattype = edible [rng_number]
                      preference.matindex = -1
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                      
                    else
                      preference.mattype = edible [rng_number].type
                      preference.matindex = edible [rng_number].index
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                   end
                                                         
                  elseif not butcherable then
                    if material.creature.flags.any_vermin then
                      dfhack.println ("Replacing vermin part " .. replacement_string (preference, preference.matindex, unit))
                      preference.mattype = preference.matindex
                      preference.matindex = -1
                      
                    else
                      local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
                      local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                      dfhack.println ("Replacing unbutcherable " .. replacement_string (preference, edible [rng_number], unit))
                    
                      if type (edible [rng_number]) == "number" then
                        preference.mattype = edible [rng_number]
                        preference.matindex = -1
                        preference.item_type = item_type_of (edible [rng_number])
                        preference.item_subtype = edible [rng_number].subtype
                     
                      else
                        preference.mattype = edible [rng_number].type
                        preference.matindex = edible [rng_number].index
                        preference.item_type = item_type_of (edible [rng_number])
                        preference.item_subtype = edible [rng_number].subtype
                      end
                    end
                    
                  elseif too_small then
                    for l, mat in ipairs (material.creature.material) do
                      if mat.id == "MUSCLE" then
                        local material = dfhack.matinfo.find ("CREATURE:" .. material.creature.creature_id .. ":MUSCLE")
                        
                        dfhack.println ("Replacing unobtainable " .. replacement_string (preference, material, unit))

                        if not material then
                          dfhack.printerr ("Replacement failed", preference.mattype, preference.matindex)
                        
                        else
                          preference.mattype = material.type
                          preference.matindex = material.index
                          preference.item_subtype = material.subtype
                        end
                      
                        break
                      end
                    end
                  end
                  
                else
                  if not available_plant [preference.matindex] then
                    local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                    dfhack.println ("Replacing unavailable " .. replacement_string (preference, edible [rng_number], unit))
                    
                    if type (edible [rng_number]) == "number" then
                      preference.mattype = edible [rng_number]
                      preference.matindex = -1
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                      
                    else
                      preference.mattype = edible [rng_number].type
                      preference.matindex = edible [rng_number].index
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                    end
                                     
                  elseif material.matindex == feather_tree then
                    local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                    dfhack.println ("Replacing unobtainable " .. replacement_string (preference, edible [rng_number], unit))
                    
                    if type (edible [rng_number]) == "number" then
                      preference.mattype = edible [rng_number]
                      preference.matindex = -1
                      preference.item_type = item_type_of (edible [rng_number])
                      
                    else
                      preference.mattype = edible [rng_number].type
                      preference.matindex = edible [rng_number].index
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                    end
                  end
                end
              end
              
            elseif not available_creature [preference.mattype] then
              local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
              dfhack.println ("Replacing unavailable " .. replacement_string (preference, edible [rng_number], unit))
                    
              if type (edible [rng_number]) == "number" then
                preference.mattype = edible [rng_number]
                preference.matindex = -1
                preference.item_type = item_type_of (edible [rng_number])
                      
              else
                preference.mattype = edible [rng_number].type
                preference.matindex = edible [rng_number].index
                preference.item_type = item_type_of (edible [rng_number])
                preference.item_subtype = edible [rng_number].subtype
              end
            end
          end
        end
      end
    end
  end
end

fix_food_needs ()

I think my mistake of adding quote rather than code is what caused the indices to go missing (I think the board tries to create a bullet list, or something like that), as they weren't missing in my version (and the index should be "i" in both cases, which might be responsible for some of the weird things you saw (and when I tried this with brackets rather than quotes in this paragraph, the preview shows my subsequent text in italics, so that's probably what it did)).

- I've changed the drinks replacement to ensure booze is replaced with booze.
- I've added setting of item_type and item_subtype on the preferences: the combination of "PLANT" and hippo brain is not a valid one. I didn't see any effect from subtype, but it ought to be provided correctly anyway.
- I wasn't able to replicate any of the weirdness seen. In particular, I modded my first dorf to have the first food preference set to cow cheese, and the script did not try to replace it. Also, I've never seen replacements when the script has been run a second time.
- I've split the longest lines.
- I've added tostring () where indicated, although I've never seen any problem without it (and I don't see any problem with it either, so adding it doesn't seem to cause any trouble).

Saiko Kila · « **Reply #55 on:** November 21, 2018, 08:01:36 am »

Allright, I'll try with changes. Also I removed a follow up answer, where I've seen such things like replacing cow, pig, alpaca and sheep milk and cheese (but not from other animals), and also one instance of replacing available milk with unavailable booze. But this was with this flawed copy of your script, so maybe it was caused by these "printing errors".

OK, I've found an issue, but it is very rare. Sometimes I need a few thousand dwarves to run before it happens. It terminates the script with "attempt to index a number value (field '?')", which always happens in one of

Code: [Select]

preference.item_subtype = edible [rng_number].subtype lines. There are some of these, and I had the error in three of them. Last time it was when trying to replace something with phantom spider, and it was when "Replacing unbutcherable".

PatrikLundell · « **Reply #56 on:** November 21, 2018, 01:28:53 pm »

Ah, bugger. The "preference.item_type = edible [rng_number].subtype" entries where the script has just checked that "edible [rng_number]" is a number rather than a struct will blow up when used as if it was a struct, of course... There are 3 of those.
The element is a number when it references a vermin animal (which may be a fish).
I don't think the field is used in that case, and that it probably ought to be set to -1 (which I haven't done below).

Corrected script:

Spoiler (click to show/hide)

Code: [Select]

--  Bumblebee honey is impossible to obtain in vanilla, and thus does bumblebee mead remain
--  out of reach. Feather trees are bugged so you can't get any eggs, and thus not get at
--  the egg white or yolk (despite the trade depot being contaminated by feather tree egg
--  yolk after the elves have visited).
--
local bumblebee = -1
local feather_tree = -1

for i, creature in ipairs (df.global.world.raws.creatures.all) do
  if creature.creature_id == "BUMBLEBEE" then
    bumblebee = i
    break
  end
end

for i, plant in ipairs (df.global.world.raws.plants.all) do
  if plant.id == "FEATHER" then
    feather_tree = i
    break
  end
end

local min_butcher_size = --  Data taken from http://www.bay12forums.com/smf/index.php?topic=78108.0
                         --  The values are shifted down one order of magnitude to match the ingame (rather than the raw) unit.
  {["MUSCLE"] =          190,  --  Meat in the reference
   ["FAT"] =             190,  --  Haven't seen any preferences for it
   ["TALLOW"] =          190,  --  i.e. rendered fat. Haven't seen any preferences for it, though
   ["SKIN"] =            190,  --  Inedible, but here for completeness
   ["BONE"] =            200,  --  Inedible
   ["INTESTINES"] =      500,
   ["BRAIN"] =          1000,
   ["LUNG"] =           1000,
   ["LIVER"] =          1000,
   ["STOMACH"] =        1000,  --  Called tripe as food
   ["GUT"] =            1000,  --  ###Not in reference. Guessing it's the same most others.
   ["GIZZARD"] =        1000,  --  Not in reference. Wiki claims size similar to brain and liver.
                               --    Wiki DF2014:Prepared_organs does not list Gut or Gizzard.
   ["NERVE"] =          1500,  --  ###Name not checked. Inedible anyway
   ["HOOF"] =           1500,  --  Inedible
   ["HEART"] =          2000,
   ["PANCREAS"] =       2000,  --  Called sweetbread as food
   ["SPLEEN"] =         2000,
   ["KIDNEY"] =         2000,
   ["HORN"] =           2000,  --  Inedible
   ["CARTILAGE"] =     20000,  --  Inedible
   ["HAIR"] =          20000,  --  Inedible
   ["EYE"] =           50000,
   ["TOOTH"] =       2500000,  --  Inedible
   ["CHEESE"] =            0}  --  Not a butcher product, and thus no size relation, but exists as food preferences.

local butcher_edible =
  {["MUSCLE"] =         true,  --  Meat in the reference
   ["FAT"] =           false,  --  Haven't seen any preferences for it
   ["TALLOW"] =        false,  --  i.e. rendered fat. Haven't seen any preferences for it, though
   ["SKIN"] =          false,  --  Inedible, but here for completeness
   ["BONE"] =          false,  --  Inedible
   ["INTESTINES"] =     true,
   ["BRAIN"] =          true,
   ["LUNG"] =           true,
   ["LIVER"] =          true,
   ["STOMACH"] =        true,  --  Called tripe as food
   ["GUT"] =            true,  --  ###Not in reference. Guessing it's the same most others.
   ["GIZZARD"] =        true,  --  Not in reference. Wiki claims size similar to brain and liver.
                               --    Wiki DF2014:Prepared_organs does not list Gut or Gizzard.
   ["NERVE"] =         false,  --  Inedible
   ["HOOF"] =          false,  --  Inedible
   ["HEART"] =          true,
   ["PANCREAS"] =       true,  --  Called sweetbread as food
   ["SPLEEN"] =         true,
   ["KIDNEY"] =         true,
   ["HORN"] =          false,  --  Inedible
   ["CARTILAGE"] =     false,  --  Inedible
   ["HAIR"] =          false,  --  Inedible
   ["EYE"] =            true,
   ["TOOTH"] =         false,  --  Inedible
   ["CHEESE"] =        false}  --  Handled separately, like milk
   

local available_plant = {}
local available_creature = {}

-----------------------------

function item_type_of (matinfo)
  if type (matinfo) == "number" then
    if df.global.world.raws.creatures.all [matinfo].flags.VERMIN_FISH then
      return df.item_type.FISH
      
    else
      return df.item_type.MEAT
    end
    
  else
    if matinfo.material.flags.MEAT then
      return df.item_type.MEAT
      
    elseif matinfo.material.flags.ALCOHOL then
      return df.item_type.DRINK
      
    elseif matinfo.material.flags.POWDER_MISC then
      return df.item_type.POWDER_MISC
      
    elseif matinfo.material.flags.LIQUID_MISC then
      return df.item_type.LIQUID_MISC

    elseif matinfo.material.flags.STRUCTURAL_PLANT_MAT then
      return df.item_type.PLANT
      
    elseif matinfo.material.flags.SEED_MAT then
      return df.item_type.SEEDS
      
    elseif matinfo.material.flags.LEAF_MAT then
      return df.item_type.PLANT_GROWTH

    elseif matinfo.material.flags.CHEESE then
      return df.item_type.CHEESE
    
    else
      dfhack.printerr ("item_type_of encountered item it couldn't classify: " .. matinfo.material.id)
    end
  end
end

-----------------------------

function is_resident (unit)
  return not dfhack.units.isCitizen (unit) and
         unit.civ_id == df.global.ui.civ_id and
         not unit.flags1.marauder and
         not unit.flags1.tame and
         not unit.flags2.visitor and
         not unit.flags1.merchant and
         not unit.flags1.forest and
         not unit.flags1.diplomat
end

-----------------------------

function replacement_string (preference, replacement, unit)
  local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
  
  if preference.item_type == df.item_type.DRINK or 
     preference.item_type == df.item_type.LIQUID_MISC then  --  The state in the preferences seems locked to Solid
    local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
    
    return material.material.state_name.Liquid .. 
           " with " .. replacement.material.state_name.Liquid ..
           " on " .. dfhack.TranslateName (unit.name, true)
   
  else
    if old_mat.mode == "creature"  then
      local old_str = ""
      local new_str = ""
      
      if not old_mat then
        old_str = df.global.world.raws.creatures.all [preference.mattype].name [0]
        
      elseif old_mat.material.prefix == "" then
        old_str = old_mat.material.state_name.Solid
        
      else
        old_str =  old_mat.material.prefix .. " " .. old_mat.material.state_name.Solid
      end
      
      if type (replacement) == "number" then
        new_str = df.global.world.raws.creatures.all [replacement].name [0]
          
      else        
        if replacement.material.prefix == "" then
          new_str = replacement.material.state_name.Solid
          
        else
          new_str = replacement.material.prefix .. " " .. replacement.material.state_name.Solid
        end
      end
      
      return old_str .. " with " .. tostring (new_str) .. " on " .. dfhack.TranslateName (unit.name, true)
      
    else
      local old_str = ""
      local new_str = ""
      
      if not old_mat then
        old_str = df.global.world.raws.plants.all [preference.mattype].name
        
      elseif  old_mat.material.prefix == "" then
        old_str =  mat.material.state_name.Solid
        
      else
        old_str =  mat.material.prefix .. " " .. mat.material.state_name.Solid
      end
      
      if type (replacement) == "number" then
        new_str = df.global.world.raws.plants.all [replacement].name
          
      else        
        if replacement.material.prefix == "" then
          new_str = replacement.material.state_name.Solid
          
        else
          new_str = replacement.material.prefix .. " " .. replacement.material.state_name.Solid
        end
      end
      
      return old_str .. " with " .. tostring (new_str) .. " on " .. dfhack.TranslateName (unit.name, true)
    end
  end
end

-----------------------------

function fix_food_needs ()
--  printall (dfhack.matinfo.find ("PLANT:POD_SWEET:EXTRACT"))
--  printall (dfhack.matinfo.find ("CREATURE:COW:CHEESE"))
  local drinkable = {}  --  Entries will be matinfo structures
  local edible = {}     --  Entries will either be an integer creature index for a whole vermin creature,
                        --  or a matinfo structure
  local rng = dfhack.random.new ()
  
  for i, plant in ipairs (df.global.world.raws.plants.all) do
    available_plant [i] = false
  end
  
  for i, creature in ipairs (df.global.world.raws.creatures.all) do
    available_creature [i] = creature.flags.CASTE_COMMON_DOMESTIC  or               --  Some of them don't exist in the wild
                             creature.flags.BIOME_RIVER_TEMPERATE_FRESHWATER or     --  Don't know how to check availability
                             creature.flags.BIOME_RIVER_TEMPERATE_BRACKISHWATER or  --  -"-
                             creature.flags.BIOME_RIVER_TEMPERATE_SALTWATER or      --  -"-
                             creature.flags.BIOME_RIVER_TROPICAL_FRESHWATER or      --  -"-
                             creature.flags.BIOME_RIVER_TROPICAL_BRACKISHWATER or   --  -"-
                             creature.flags.BIOME_RIVER_TROPICAL_SALTWATER          --  -"-
  end
  
  for i, region in ipairs (df.global.world.world_data.regions) do
    for k, pop in ipairs (region.population) do
      if pop.type == df.world_population_type.Animal or
         pop.type == df.world_population_type.Vermin or
         pop.type == df.world_population_type.VerminInnumerable or
         pop.type == df.world_population_type.ColonyInsect then
        available_creature [pop.race] = true
        
      elseif pop.type == df.world_population_type.Tree or
             pop.type == df.world_population_type.Grass or
             pop.type == df.world_population_type.Bush then
        available_plant [pop.plant] = true
      end
    end
  end
  
  for i, region in ipairs (df.global.world.world_data.underground_regions) do
    for k, pop in ipairs (region.feature_init.feature.population) do
      if pop.type == df.world_population_type.Animal or
         pop.type == df.world_population_type.Vermin or
         pop.type == df.world_population_type.VerminInnumerable or
         pop.type == df.world_population_type.ColonyInsect then
        available_creature [pop.race] = true
        
      elseif pop.type == df.world_population_type.Tree or
             pop.type == df.world_population_type.Grass or
             pop.type == df.world_population_type.Bush then
        available_plant [pop.plant] = true
      end
    end
  end
  
  for i, plant in ipairs (df.global.world.raws.plants.all) do
    if available_plant [i] and
       not plant.flags.GRASS then  -- Grasses can't be harvested in any way, but evil ones are made of meat...
      for k, material in ipairs (plant.material) do
        if (material.flags.ALCOHOL_PLANT or
            material.flags.LIQUID_MISC_PLANT) and
           material.flags.EDIBLE_RAW then
          table.insert (drinkable, dfhack.matinfo.find ("PLANT:" .. plant.id .. ":" .. material.id))
          
        elseif not material.flags.LIQUID_MISC_PLANT and  --  Oils that can't be drunk raw don't seem to be cooked by DF.
               (material.flags.EDIBLE_RAW or
                material.flags.EDIBLE_COOKED) and
               plant.index ~= feather_tree then  --  Feather tree eggs are bugged...
          table.insert (edible, dfhack.matinfo.find ("PLANT:" .. plant.id .. ":" .. material.id))
        end
      end
    end
  end
  
  for i, creature in ipairs (df.global.world.raws.creatures.all) do
    if not creature.flags.GENERATED and  --  Exclude FBs, demons, etc.
       available_creature [i] then
      if creature.flags.any_vermin then
        local can_be_eaten = false

        for k, material in ipairs (creature.material) do
          if material.id == "MUSCLE" then
            can_be_eaten = true
            
          elseif material.id == "MILK" then
            table.insert (drinkable, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
            
          elseif material.id == "CHEESE" then
            table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
          end
        end
        
        if can_be_eaten then  --  Weed out stuff like e.g. fire snakes
          table.insert (edible, i)
        end
        
      else
        local butcherable = true
                  
        for k, str in ipairs (creature.raws) do
          if str [0] == "[NOT_BUTCHERABLE]" then
            butcherable = false
            break
          end
        end
        
        if min_butcher_size ["MUSCLE"] > creature.adultsize then
          butcherable = false  --  Technically possibly, but nothing edible resulting
        end
                
        for k, material in ipairs (creature.material) do
          if material.id == "MILK" then
              table.insert (drinkable, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
            
          elseif material.id == "CHEESE" then
              table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))
            
          elseif butcherable and
                 not creature.flags.CASTE_CAN_LEARN and  --### Is this the correct criterion?
                 min_butcher_size [material.id] and
                 min_butcher_size [material.id] <= creature.adultsize and
                 butcher_edible [material.id] then
            table.insert (edible, dfhack.matinfo.find ("CREATURE:" .. creature.creature_id .. ":" .. material.id))            
          end    
        end
      end
    end
  end
  
--  dfhack.println (#drinkable, #edible)
  
  for i, unit in ipairs (df.global.world.units.all) do
    if (dfhack.units.isCitizen (unit) or
        is_resident (unit)) and
       dfhack.units.isAlive (unit) and
       unit.status.current_soul then
      for k, preference in ipairs (unit.status.current_soul.preferences) do
        if preference.active then
          if preference.type == df.unit_preference.T_type.LikeFood then          
            local material = dfhack.matinfo.decode (preference.mattype, preference.matindex)
            
            if preference.matindex ~= -1 and 
               (material.mode == "plant" or
                material.mode == "creature") then
              if preference.item_type == df.item_type.DRINK or 
                 preference.item_type == df.item_type.LIQUID_MISC then  --  The state in the preferences seems locked to Solid
                if material.mode == "creature"  then
                  if not available_creature [preference.matindex] or
                     preference.matindex == bumblebee then
                    local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
                    local rng_number = rng:random (#drinkable - 1) + 1  --  To get it into the Lua vector range
                    
                    while preference.item_type == df.item_type.DRINK and
                          not drinkable [rng_number].material.flags.ALCOHOL do
                      rng_number = rng:random (#drinkable - 1) + 1
                    end
                    
                    dfhack.println ("Replacing unavailable " .. replacement_string (preference, drinkable [rng_number], unit))
                    
                    preference.mattype = drinkable [rng_number].type
                    preference.matindex = drinkable [rng_number].index                                                
                    preference.item_type = item_type_of (drinkable [rng_number])
                    preference.item_subtype = drinkable [rng_number].subtype
                  end
                
                else
                  if not available_plant [preference.matindex] then
                    local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
                    local rng_number = rng:random (#drinkable - 1) + 1  --  To get it into the Lua vector range
                    
                    while preference.item_type == df.item_type.DRINK and
                          not drinkable [rng_number].material.flags.ALCOHOL do
                      rng_number = rng:random (#drinkable - 1) + 1
                    end
                    
                    dfhack.println ("Replacing unavailable " .. replacement_string (preference, drinkable [rng_number], unit))
                    preference.mattype = drinkable [rng_number].type
                    preference.matindex = drinkable [rng_number].index
                    preference.item_type = item_type_of (drinkable [rng_number])                    
                    preference.item_subtype = drinkable [rng_number].subtype
                  end
                end
        
              else  --  Food
                if material.mode == "creature" then
                  local butcherable = true
                  local too_small = false
                  
                  for i, str in ipairs (material.creature.raws) do
                    if str [0] == "[NOT_BUTCHERABLE]" then
                      butcherable = false
                      break
                    end
                  end
        
                  if min_butcher_size [material.material.id] then
                    if min_butcher_size [material.material.id] > material.creature.adultsize then
                      too_small = true
                      
                      if min_butcher_size ["MUSCLE"] > material.creature.adultsize then
                        butcherable = false  --  Technically possibly, but nothing edible resulting
                      end
                    end
          
                  else
                    dfhack.printerr ("fix_food_needs found unexpected animal food preference (continuing): " .. material.material.id)
                  end
                  
                  if not available_creature [preference.matindex] then
                    local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                    dfhack.println ("Replacing non existent " .. replacement_string (preference, edible [rng_number], unit))
                    
                    if type (edible [rng_number]) == "number" then
                      preference.mattype = edible [rng_number]
                      preference.matindex = -1
                      preference.item_type = item_type_of (edible [rng_number])
                      
                    else
                      preference.mattype = edible [rng_number].type
                      preference.matindex = edible [rng_number].index
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                   end
                                                         
                  elseif not butcherable then
                    if material.creature.flags.any_vermin then
                      dfhack.println ("Replacing vermin part " .. replacement_string (preference, preference.matindex, unit))
                      preference.mattype = preference.matindex
                      preference.matindex = -1
                      
                    else
                      local old_mat = dfhack.matinfo.decode (preference.mattype, preference.matindex)
                      local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                      dfhack.println ("Replacing unbutcherable " .. replacement_string (preference, edible [rng_number], unit))
                    
                      if type (edible [rng_number]) == "number" then
                        preference.mattype = edible [rng_number]
                        preference.matindex = -1
                        preference.item_type = item_type_of (edible [rng_number])
                     
                      else
                        preference.mattype = edible [rng_number].type
                        preference.matindex = edible [rng_number].index
                        preference.item_type = item_type_of (edible [rng_number])
                        preference.item_subtype = edible [rng_number].subtype
                      end
                    end
                    
                  elseif too_small then
                    for l, mat in ipairs (material.creature.material) do
                      if mat.id == "MUSCLE" then
                        local material = dfhack.matinfo.find ("CREATURE:" .. material.creature.creature_id .. ":MUSCLE")
                        
                        dfhack.println ("Replacing unobtainable " .. replacement_string (preference, material, unit))

                        if not material then
                          dfhack.printerr ("Replacement failed", preference.mattype, preference.matindex)
                        
                        else
                          preference.mattype = material.type
                          preference.matindex = material.index
                          preference.item_subtype = material.subtype
                        end
                      
                        break
                      end
                    end
                  end
                  
                else
                  if not available_plant [preference.matindex] then
                    local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                    dfhack.println ("Replacing unavailable " .. replacement_string (preference, edible [rng_number], unit))
                    
                    if type (edible [rng_number]) == "number" then
                      preference.mattype = edible [rng_number]
                      preference.matindex = -1
                      preference.item_type = item_type_of (edible [rng_number])
                      
                    else
                      preference.mattype = edible [rng_number].type
                      preference.matindex = edible [rng_number].index
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                    end
                                     
                  elseif material.matindex == feather_tree then
                    local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
                    dfhack.println ("Replacing unobtainable " .. replacement_string (preference, edible [rng_number], unit))
                    
                    if type (edible [rng_number]) == "number" then
                      preference.mattype = edible [rng_number]
                      preference.matindex = -1
                      preference.item_type = item_type_of (edible [rng_number])
                      
                    else
                      preference.mattype = edible [rng_number].type
                      preference.matindex = edible [rng_number].index
                      preference.item_type = item_type_of (edible [rng_number])
                      preference.item_subtype = edible [rng_number].subtype
                    end
                  end
                end
              end
              
            elseif not available_creature [preference.mattype] then
              local rng_number = rng:random (#edible - 1) + 1  --  To get it into the Lua vector range
                    
              dfhack.println ("Replacing unavailable " .. replacement_string (preference, edible [rng_number], unit))
                    
              if type (edible [rng_number]) == "number" then
                preference.mattype = edible [rng_number]
                preference.matindex = -1
                preference.item_type = item_type_of (edible [rng_number])
                      
              else
                preference.mattype = edible [rng_number].type
                preference.matindex = edible [rng_number].index
                preference.item_type = item_type_of (edible [rng_number])
                preference.item_subtype = edible [rng_number].subtype
              end
            end
          end
        end
      end
    end
  end
end

fix_food_needs ()

Saiko Kila · « **Reply #57 on:** November 22, 2018, 06:12:04 am »

It seems it works in newer games. But I have issue in older games, imported from v0.40.06 (but run in 0.44.12). It gives an error "attempt to index a nil value (global 'mat')" in line

Code: [Select]

old_str = mat.material.prefix .. " " .. mat.material.state_name.Solid Is this "mat" declared at all?

Also regarding the changes: one of them was logged as:
Replacing unavailable bumblebee royal jelly with one-humped camel's milk on `MERC Hode /' Siegeplunged
However, the milk is actually from one-humped camel man...

I was also thinking more generally about replacements like of worm's gut by gut, or fly's brain by fly. Are creatures like these available as food normally in any way? I mean a dwarf can eat them if very hungry and has no other choice I believe (and has to catch them, and the mood change is probably negative), but how to make him eat them under normal circumstances? They can't be butchered, they can't be used as a part of roast, I don't think they can't be obtained other than by trade - but I'm not sure if it's in the form allowing eating (the are live).

I think that only aquatic vermin are obtained in a way allowing eating them (either from trade or from fishing, after preparing)? The only others are maybe purring maggots, moghoppers and various spiders, which are killed after extraction, but I don't remember last time I saw it, so don't know if they are edible (in the same state as prepared vermin fish), or just remains to be thrown away.

PatrikLundell · « **Reply #58 on:** November 22, 2018, 10:02:19 am »

The "mat" is an error: it should be "old_mat". There's another bug in the vicinity, however, causing the no part branch above to be incorrect as well.

Dorfs eat eggs from animal people, so why not milk/cheese?

However, I agree that ought to be changed.

Vermin can be caught in vermin traps, and DF obviously generate preferences for eating vermin, but I haven't seen or heard of anyone catching and eating them except to stave off starvation. I don't know if dorfs with a preference for vermin can actually eat trapped vermin, though. If a dorf caught vermin to eat for a preference it shouldn't generate a bad thought though, as the dorf isn't forced to eat vermin.
The only vermin I know can be eaten "normally" is creepy crawler, which apparently can be slaughtered after being caught. I would expect that the non "fish" vermin that can be processed in other ways wouldn't leave any edible results, but I have never processed any.

I looked into the one humped camel man milk issue, and found it's common to all animal people that yield milk and cheese, namely that the product is named after the base creature, not the man variant. The bug tracker is unavailable at the moment, but I'll write a bug report later.

I tried to get the script to replace vermin, but ran into an unexpected problem: Not all the vermin fish that are edible according to the wiki Vermin page have the VERMIN_FISH flag set. The set of any_vermin and CASTE_MUST_BREATH_WATER includes Moon Snail but excludes Lungfish and Pond Turtle.

Saiko Kila · « **Reply #59 on:** November 22, 2018, 03:08:42 pm »

Quote from: PatrikLundell on November 22, 2018, 10:02:19 am

The "mat" is an error: it should be "old_mat". There's another bug in the vicinity, however, causing the no part branch above to be incorrect as well.

Right.

Quote

Dorfs eat eggs from animal people, so why not milk/cheese? However, I agree that ought to be changed.

Because it's gross

No, seriously I was more concerned that the item is described as camel's milk, but also because I don't see it can be obtained in any
meaningful way.

Quote

Vermin can be caught in vermin traps, and DF obviously generate preferences for eating vermin, but I haven't seen or heard of anyone catching and eating them except to stave off starvation. I don't know if dorfs with a preference for vermin can actually eat trapped vermin, though. If a dorf caught vermin to eat for a preference it shouldn't generate a bad thought though, as the dorf isn't forced to eat vermin.

There are vermin which can't be caught in traps, at least not in baited ones (there's a tag for it), and since some are in places not accessible to animal trappers, I think that these can't be really caught. An being non-fish, can't be bought.

Quote

The only vermin I know can be eaten "normally" is creepy crawler, which apparently can be slaughtered after being caught. I would expect that the non "fish" vermin that can be processed in other ways wouldn't leave any edible results, but I have never processed any.

I wonder what causes it. Maybe because it has no [NOT_BUTCHERABLE] tag.

Quote

I looked into the one humped camel man milk issue, and found it's common to all animal people that yield milk and cheese, namely that the product is named after the base creature, not the man variant. The bug tracker is unavailable at the moment, but I'll write a bug report later.

I noticed after changes that I had three dwarves with three different one-humped camel milk requirements. One of these was normal, another was from giant version, and third was from animal man, despite the same name. Talk about fussy eaters.

Quote

I tried to get the script to replace vermin, but ran into an unexpected problem: Not all the vermin fish that are edible according to the wiki Vermin page have the VERMIN_FISH flag set. The set of any_vermin and CASTE_MUST_BREATH_WATER includes Moon Snail but excludes Lungfish and Pond Turtle.

It think the [FISHITEM] is what causes vermin to be available both in stocks category (as fish), and in trade. It is available in caste flags, I'm not sure if also in general race flags. Since this tag is related specifically to their edibility, I would say it is a good choice for tests. Quite possible it's also the tag which creates this general (no specific part) food preference in the dwarves.

News:

Author Topic: What is a "decent meal"? (Read 17135 times)

PatrikLundell

Re: What is a "decent meal"?

Saiko Kila

Re: What is a "decent meal"?

PatrikLundell

Re: What is a "decent meal"?

Starver

Re: What is a "decent meal"?

Saiko Kila

Re: What is a "decent meal"?

PatrikLundell

Re: What is a "decent meal"?

Saiko Kila

Re: What is a "decent meal"?

PatrikLundell

Re: What is a "decent meal"?

Saiko Kila

Re: What is a "decent meal"?

PatrikLundell

Re: What is a "decent meal"?

Saiko Kila

Re: What is a "decent meal"?

PatrikLundell

Re: What is a "decent meal"?

Saiko Kila

Re: What is a "decent meal"?

PatrikLundell

Re: What is a "decent meal"?

Saiko Kila

Re: What is a "decent meal"?