Reusing the same pngs for different "traits"

[Bioxide187]

Hello!

I'm interested in using the same pngs in a folder for more than 1 trait. However I would like the engine to be aware if a png was already selected by the previous layer.

For example, lets say I have:
layers/common-items/asset01#33.png
layers/common-items/asset02#33.png
layers/common-items/asset03#33.png

with the following config:

const layerConfigurations = [ { layersOrder: [ { name: "common-items" trait: "Items"}, { name: "common-items" trait: "Items"}, ], } ]

How can I have the engine say select asset01#33.png for the first layer and prevent it from selecting the same one for the second layer?

What would be the best route for this if possible?

[nftchef]

From what I understand, you want to be able to have two Items for each generated image?
There's no easy way to do this right now.
untested, I think if you created a mapping in incompatible for every file in Items against itself, it could work.

Also, the generator skips duplicate trait_types, so you will need a config like:

      { name: "Items" },
      { name: "Items2", trait: "Items2" },

while not ideal for your use case, after the generation, do a find and replace to change 'Items2' => 'Items'

To setup the incompatible mapping

in config.js, you would need to loop over the Items directory, create an incompatible mapping, then push it to incompatible
First, import fs at the top of the file

const fs = require('fs')

then, before them incompatible, grab the zflag, and clean name function from main.js (easiest is to probably copy paste it), rarity delimiter will need to move up in the file

const zflag = /(z-?\d*,)/;
const rarityDelimiter = "#";
const cleanName = (_str) => {
  const hasZ = zflag.test(_str);

  const zRemoved = _str.replace(zflag, "");

  const extension = /\.[0-9a-zA-Z]+$/;
  const hasExtension = extension.test(zRemoved);
  let nameWithoutExtension = hasExtension ? zRemoved.slice(0, -4) : zRemoved;
  var nameWithoutWeight = nameWithoutExtension.split(rarityDelimiter).shift();
  return nameWithoutWeight;
};

finally, create the incompatible maps by looping over the read items

const incompatible = {};

const ITEMS = fs
  .readdirSync(path.join(layersDir, "Items"))
  .filter((file) => file !== ".DS_Store" && file !== "NONE") // skip NONE
  .map((head) => cleanName(head));

ITEMS.forEach((item) => {
  incompatible[item] = [item];
});

[Bioxide187]

Thank you so much for your reply!

I had similar lines of though when it came to using the incompatible feature to prevent the dups.

My original plan in absence of this reply was to review the code base to implement a feature where a given layer order could share a tag among different layer orders, so they are aware of each other to avoid duplication. Perhaps the key would simply be the clean file name.

I will review your recommendation soon!