Content

This is a script that can generate implications for monster and human substances, clothes and colors. It's also a suggestion of the kind of substances and clothing tags we'd want to encourage users to use.

I formatted the proposal as code to be able to see how bad the combinatorics got, and the current proposal lies at about 2159 implications, which can be reduced by getting rid of some things like clothes (since we're a monster booru, I think monster substances are more important to have powerful searching for).

I'm a little unsure if monster substances/surfaces is really a good idea or if it will just lead to people being overly confident in them all the time, but i do think it's a very good idea to at least encourage users to describe what monster colors are present in an image.

Note that it is not suggesting to add these implications to species directly.

Monster Substances

A monster substance describes the apparent surface or texture of a monster. For example, bulbasaur (usually) consists of turquoise skin and a green plant on its back. These could be described as "turquoise_monster_skin" and "green_monster_plant_(substance)".

For a substance to count, it has to be visible in the image, but might in some cases be reasonably inferred from a species typical design. For example, a Growlithe with only round edges and a flat orange color still probably has "orange_monster_fur".

Unfortunately for us texturespergs, a monsters surface is almost always ambiguous and should use the general "<color>_monster_(substance)". For example, whether machop has a hard rock-like or more skin-like body is not very obvious just by looking at it, while Geodude definitely has a rock-like body, and so the former would use "gray_monster_(substance)" and the latter would use "brown_monster_rock_(substance)".

You can see the monster substances I've proposed under the "// Monster Substances" line in the code below.

Questions

- Should we encourage less or no monster surface descriptors and just stick with the general "<color>_monster_(substance)"?
- Should we deliberately add a bunch of surfaces, knowing people will misuse them, so we at least can have implications back to the general "x_monster_(surface)" tag that would actually be useful for searching?
- Should we generate tags for clothes at all, or is it worth encouraging on a booru for creatures that usually don't wear them?
- Do we want to handle things like monster "primary" colors? Such as Darkrai being primarily black but with red and white features.

Code

This code produces a file things_and_colors.txt that contains the update.

const fs = require('fs')

const COLORS = 
[
    'black',
    'brown',
    'dark_gray',
    'gray',
    'red',
    'green',
    'blue',
    'purple',
    'orange',
    'turquoise',
    'dark_blue',
    'light_blue',
    'yellow',
    'beige',
    'pink',
    'light_gray',
    'white'
]

const COLOR_IMPLICATIONS =
[
    [['dark_blue', 'light_blue', 'turquoise'], ['blue']],
    [['dark_gray', 'light_gray'], ['gray']],
    [['turquoise'], ['green']],
]

const THINGS =
[
    // Monster Substances
    'mon_fur', // unambiguously furry (growlithe)
    'mon_skin', // unambiguously skin-like (bulbasaur's body)
    'mon_scales', // unambiguously reptile-like (these are usually drawn)
    'mon_leaves', // monsters with leaves (roselia)
    'mon_carpace', // unambiguously hard organic surface (scyther, metapod)
    'mon_wood_(substance)', // wood-like (ents, tree stump monsters)
    'mon_rock_(substance)', // rock-like (geodude)
    'mon_plant_(substance)', // plant-like (bellsprout)
    'mon_ether', // almost gas but not quite, or ambiguous (haunter, gastly's body)
    'mon_gas', // definitely a gas (gastly's gas)
    'mon_metal', // metallic (magnemite)
    'mon_slime_(substance)', // all kinds of slime (distinguishing between hard and soft is probably rarely possible)
    'mon_liquid_(substance)', // monsters that contains fully liquid parts (tokutu-kun from yume nikki)
    'mon_hair', // manes or other non-fur hair
    'mon', // for when the skin of a monster is ambiguous (almost always the case)

    // Human substances
    'human_skin', // should this just be "skin" and implied human?
    'human_hair', // should this just be "hair" and implied human?

    // Clothes (do we want these to be very detailed or should we just use top/head/hands/bottom/feet?)

    // Top
    'shirt',
    'sweater',
    'jacket',
    'coat',
    'robe',
    'dress',
    'slim_suit', // anything that fits close to the body
    'bikini',
    'top_(clothing)',

    // Head
    'scarf',
    'hat',
    'bandana',
    'hair_ribbon',
    'crown',
    'cloak',
    'head_(clothing)',

    // Arms / hands
    'armband',
    'wristband',
    'gloves',
    'hands_(clothing)',

    // Bottom
    'pants',
    'skirt',
    'leggings',
    'jeans',
    'shorts',
    'underwear',
    'bottom_(clothing)',

    // Feet
    'socks',
    'shoes',
    'boots',
    'sandals',
    'high_heels',
    'feet_(clothing)',
]

const THING_IMPLICATIONS = [
    [['mon_fur', 'mon_skin', 'mon_scales', 'mon_carpace', 'mon_ether', 'mon_gas', 'mon_metal', 'mon_rock_(substance)', 'mon_plant_(substance)', 'mon_plastic_(substance)', 'mon_slime_(substance)', 'mon_liquid_(substance)', 'mon_hair'], ['mon']],
    [['shirt','sweater','jacket','coat','robe','dress', 'slim_suit', 'bikini'], ['top_(clothing)']],
    [['scarf', 'hat', 'bandana', 'hair_ribbon', 'crown', 'cloak'], ['head_(clothing)']],
    [['armband', 'wristband', 'gloves'], ['hands_(clothing)']],
    [['pants', 'skirt', 'leggings', 'jeans', 'shorts', 'underwear'], ['bottom_(clothing)']],
    [['jeans', 'shorts'], ['pants']],
    [['socks', 'shoes', 'boots', 'sandals', 'high_heels'], ['feet_(clothing)']],
]

const implications = []
for (const thing of THINGS)
{
    const thingImplications = [...new Set(THING_IMPLICATIONS.filter(x=>x[0].includes(thing)).map(x=>x[1]).flat())]
    for (const thingImplication of thingImplications)
    {
        implications.push(`imply ${thing} -> ${thingImplication}`)
    }

    for (const color of COLORS)
    {
        const colorImplications = [...new Set(COLOR_IMPLICATIONS.filter(x=>x[0].includes(color)).map(x=>x[1]).flat())]
        const coloredThing = `${color}_${thing}`
        implications.push(`imply ${coloredThing} -> ${thing}`)

        // a thing of this color is also the things it implies of the same color
        for (const thingImplication of thingImplications)
        {
            implications.push(`imply ${coloredThing} -> ${color}_${thingImplication}`)
        }

        // a thing of this color is also the things of the colors this color implies
        for (const colorImplication of colorImplications)
        {
            implications.push(`imply ${coloredThing} -> ${colorImplication}_${thing}`)
        }

        // a thing of this color is also the things it implies of any of the colors this color implies
        for (const thingImplication of thingImplications)
        {
            for (const colorImplication of colorImplications)
            {
                implications.push(`imply ${coloredThing} -> ${colorImplication}_${thingImplication}`)
            }
        }
    }
}

fs.writeFileSync('./things_and_colors.txt', implications.join('\n'))