Check for future incompatibilities

[ghost]

I've noticed that incompatibles and forced combinations can be... incompatible.

Let's say we have the following:

incompatibles = {
   "Shark suit": ["Space helmet"]
}

forcedCombinations = {
   "Moon background": ["Space helmet"]
}

Now, when the Moon background is picked, we know that in the future, the Space helmet will be forced. However, the result is that a Shark suit should not be picked after Moon background, because Shark suit is in turn incompatible with Space helmet. The current code does not take this situation into account. Instead, it will pick the Shark suit (which as far as it's concerned is a valid combination) and it will later force the Space helmet, which results in an incompatible combination.

I've added some code to check for future incompatibilities. I'm not sure how to do a pull request, so I'm actually hoping to help people with this issue through here 😄 The below might not be the most efficient way of doing this (my JS is a bit rusty), but it seems to do its job 👍

Basically, it checks if the current layer has forced combinations, looks up those forced combinations in the incompatible combinations and finds the layers with which the forced combination would be incompatible. It then simply adds those to the incompatibleDNA array.

Add this function in main.js:

// Find future incompatibilities to prevent a forced combination resulting in an invalid combination
function findFutureIncompatibles(currentLayer) {
  debugLogs
  ? console.log(
    `\nChecking future incompatibilities for ${currentLayer}`
    )
    :null;

  let futureIncompatibilities = [];
  let incompatibleArray = Object.entries(incompatible);
  
  // We check the forcedCombinations object for the current layer
  // to see if any of its values occur as values in the incompatible variable. If so,
  // we know we need to add the key of that value in the incompatible variable to the list
  // of incompatible layers, as it will pose a problem in the future.
  if (forcedCombinations[currentLayer]) {
    forcedCombinations[currentLayer].forEach((value) => {
      incompatibleArray.forEach(([key, values]) => {
        if (values.includes(value)) futureIncompatibilities.push(key);
      });
    });

    if (futureIncompatibilities) {
      debugLogs
      ? console.log(
        chalk.bgYellowBright.black(
        `\nFound future incompatibilities for ${currentLayer}: ${futureIncompatibilities}`
        )
      )
        :null;
    }
  }
  
  return futureIncompatibilities;
}

Add this:

      // If we find future incompatibilities, we add them to the incompatible DNA
      incompatibleDNA.push(...findFutureIncompatibles(currentLayers[i].name));

... in the pickRandomElement function after the part where incompatibilities are checked (which ends somewhere around line 565):

      if (incompatible[currentLayers[i].name]) {
        debugLogs
          ? console.log(
              `Adding the following to incompatible list`,
              ...incompatible[currentLayers[i].name]
            )
          : null;
        incompatibleDNA.push(...incompatible[currentLayers[i].name]);
      }

<<< Add here >>>

[ghost]

@nftchef might be worth checking out, but of course up to you if you wish to include it :)

[cryptofannatic]

@yreuvekamp your code is generating images with layers missing

[ghost]

@cryptofannatic I think this happens when there are no compatible combinations for a layer. If that's not it, I'm gonna need more info to see what's going on.

[cryptofannatic]

@yreuvekamp can you check this? #232

[nftchef]

Thank you for the detailed suggestion. Without testing I'm not sure what issues there are. This is a valid approach, but as it's more of an edge case I won't include it at this time. 🙇‍♂️

I generally try to write functions in the config.js to build the incompatible list for all cases before main.js is run. But that may be tricky in the example situation. I'm open to exploring it more if it's needed.