code:
package com.lilithsthrone.utils;

import java.util.List;

import com.lilithsthrone.game.PropertyValue;
import com.lilithsthrone.main.Main;

import javafx.scene.paint.Color;

/**
 * @since 0.1.0
 * @version 0.3.5.1
 * @author Innoxia
 */
public enum Colour {

	// This class and BaseColour are beyond saving x_x

	BASE_WHITE(false, BaseColour.WHITE, "white", Util.newArrayListOfValues("white")),
	BASE_GREY(false, BaseColour.GREY, "grey", Util.newArrayListOfValues("grey")),
	BASE_GREY_DARK(false, BaseColour.GREY_DARK, "dark grey", Util.newArrayListOfValues("darkGrey", "greyDark")),

	BASE_ROSE(false, BaseColour.ROSE, "rose", Util.newArrayListOfValues("rose")),
	BASE_LILAC(false, BaseColour.LILAC, "lilac", Util.newArrayListOfValues("lilac")),
	BASE_LILAC_LIGHT(false, BaseColour.LILAC_LIGHT, "light lilac", Util.newArrayListOfValues("lightLilac", "lilacLight")),
	BASE_PURPLE_DARK(false, BaseColour.PURPLE_DARK, "violet", Util.newArrayListOfValues("darkPurple", "purpleDark", "violet")),
	BASE_PURPLE(false, BaseColour.PURPLE, "purple", Util.newArrayListOfValues("purple")),
	BASE_PURPLE_LIGHT(false, BaseColour.PURPLE_LIGHT, "light purple", Util.newArrayListOfValues("lightPurple", "purpleLight")),

	BASE_PINK_DEEP(false, BaseColour.PINK_DEEP, "deep pink", Util.newArrayListOfValues("deepPink", "darkPink", "pinkDeep", "pinkDark")),
	BASE_PINK_SALMON(false, BaseColour.PINK_SALMON, "salmon-pink", Util.newArrayListOfValues("pinkSalmon", "salmonPink")),
	BASE_PINK(false, BaseColour.PINK, "pink", Util.newArrayListOfValues("pink")),
	BASE_PINK_LIGHT(false, BaseColour.PINK_LIGHT, "light pink", Util.newArrayListOfValues("lightPink", "pinkLight")),

	BASE_MAGENTA(false, BaseColour.MAGENTA, "magenta", Util.newArrayListOfValues("magenta")),
	BASE_CRIMSON(false, BaseColour.CRIMSON, "crimson", Util.newArrayListOfValues("crimson")),
	BASE_RED(false, BaseColour.RED, "red", Util.newArrayListOfValues("red")),
	BASE_RED_LIGHT(false, BaseColour.RED_LIGHT, "light red", Util.newArrayListOfValues("lightRed", "redLight")),

	BASE_TAN(false, BaseColour.TAN, "tan", Util.newArrayListOfValues("tan")),
	BASE_BROWN(false, BaseColour.BROWN, "brown", Util.newArrayListOfValues("brown")),
	BASE_BROWN_DARK(false, BaseColour.BROWN_DARK, "dark brown", Util.newArrayListOfValues("darkBrown", "brownDark")),
	BASE_ORANGE(false, BaseColour.ORANGE, "orange", Util.newArrayListOfValues("orange")),
	BASE_GINGER(false, BaseColour.GINGER, "ginger", Util.newArrayListOfValues("ginger")),

	BASE_GOLD(false, BaseColour.GOLD, "gold", Util.newArrayListOfValues("gold")),
	BASE_YELLOW(false, BaseColour.YELLOW, "yellow", Util.newArrayListOfValues("yellow")),
	BASE_YELLOW_LIGHT(false, BaseColour.YELLOW_LIGHT, "light yellow", Util.newArrayListOfValues("lightYellow", "yellowLight")),

	BASE_GREEN_LIME(false, BaseColour.GREEN_LIME, "lime green", Util.newArrayListOfValues("limeGreen", "greenLime")),
	BASE_GREEN_LIGHT(false, BaseColour.GREEN_LIGHT, "light green", Util.newArrayListOfValues("lightGreen", "greenLight")),
	BASE_GREEN(false, BaseColour.GREEN, "green", Util.newArrayListOfValues("green")),
	BASE_GREEN_DARK(false, BaseColour.GREEN_DARK, "dark green", Util.newArrayListOfValues("darkGreen", "greenDark")),

	BASE_AQUA(false, BaseColour.AQUA, "aqua", Util.newArrayListOfValues("aqua")),
	BASE_TEAL(false, BaseColour.TEAL, "teal", Util.newArrayListOfValues("teal")),
	BASE_PERIWINKLE(false, BaseColour.PERIWINKLE, "periwinkle", Util.newArrayListOfValues("periwinkle")),
	BASE_BLUE_DARK(false, BaseColour.BLUE_DARK, "dark blue", Util.newArrayListOfValues("darkBlue", "blueDark")),
	BASE_BLUE_LIGHT(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("lightBlue", "blueLight")),
	BASE_BLUE(false, BaseColour.BLUE, "blue", Util.newArrayListOfValues("blue")),
	BASE_BLUE_STEEL(false, BaseColour.BLUE_STEEL, "steely blue", Util.newArrayListOfValues("steelyBlue", "steelBlue", "blueSteel")),

	BASE_BLACK(false, BaseColour.BLACK, "black", Util.newArrayListOfValues("black")),
	BASE_PITCH_BLACK(false, BaseColour.PITCH_BLACK, "black", Util.newArrayListOfValues("black")),

	// Game colours:
	BACKGROUND(false, Util.newColour(0x222222), Util.newColour(0xcccccc), "grey"),
	BACKGROUND_ALT(false, Util.newColour(0x292929), Util.newColour(0xbbbbbb), "grey"),

	BACKGROUND_DAY(false, Util.newColour(0x222222), Util.newColour(0xcccccc), "grey"),
	BACKGROUND_TWILIGHT(false, Util.newColour(0x191919), Util.newColour(0xbbbbbb), "black"),
	BACKGROUND_NIGHT(false, Util.newColour(0x121212), Util.newColour(0xaaaaaa), "pitch black"),

	MAP_BACKGROUND_UNEXPLORED(false, Util.newColour(0x121212), Util.newColour(0x121212), "black"),
	MAP_BACKGROUND_PINK(false, Util.newColour(0xb2a4bb), Util.newColour(0xb2a4bb), "pink"),
	MAP_BACKGROUND(false, Util.newColour(0xbbbbbb), Util.newColour(0xbbbbbb), "grey"),
	MAP_BACKGROUND_DARK(false, Util.newColour(0x888888), Util.newColour(0x8f8f8f), "dark grey"),
	MAP_BACKGROUND_DANGEROUS(false, Util.newColour(0x303030), Util.newColour(0xaaaaaa), "dark grey"),
	MAP_BACKGROUND_BLUE(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("lightBlue")),

	GENERIC_SEX(false, BaseColour.PINK_LIGHT, "light pink", Util.newArrayListOfValues("sex")),
	GENERIC_SEX_AS_DOM(false,Util.newColour(0xFF75BA), Util.newColour(0xD82C8B), "pink", Util.newArrayListOfValues("sexDom", "domSex")),
	DOMINANT(false, BaseColour.CRIMSON, "crimson", Util.newArrayListOfValues("dom", "dominant")),
	SUBMISSIVE(false, BaseColour.PINK_LIGHT, "light pink", Util.newArrayListOfValues("sub", "submissive")),
	GENERIC_COMBAT(false, BaseColour.CRIMSON, "crimson"),
	GENERIC_ARCANE(false, BaseColour.PINK, "pink", Util.newArrayListOfValues("arcane")),
	GENERIC_TERRIBLE(false, BaseColour.CRIMSON, "crimson", Util.newArrayListOfValues("terrible")),
	GENERIC_MINOR_BAD(false, BaseColour.RED_LIGHT, "red", Util.newArrayListOfValues("minorBad", "badMinor")),
	GENERIC_MINOR_GOOD(false, BaseColour.GREEN_LIGHT, "light green", Util.newArrayListOfValues("minorGood", "goodMinor")),
	GENERIC_BAD(false, BaseColour.RED, "red", Util.newArrayListOfValues("bad")),
	GENERIC_GOOD(false, BaseColour.GREEN, "green", Util.newArrayListOfValues("good")),
	GENERIC_EXCELLENT(false, BaseColour.GOLD, "gold", Util.newArrayListOfValues("excellent")),
	GENERIC_ATTRIBUTE(false, BaseColour.MAGENTA, "magenta"),
	GENERIC_EXPERIENCE(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("experience", "xp")),
	GENERIC_ACTION_POINTS(false, BaseColour.AQUA, "aqua", Util.newArrayListOfValues("actionPoint", "actionPoints", "ap")),
	GENERIC_ENCHANTMENT(false, BaseColour.PINK, "pink", Util.newArrayListOfValues("enchantment", "enchanting")),
	COOLDOWN(false, BaseColour.CRIMSON, "crimson", Util.newArrayListOfValues("cooldown")),
	CRIT(false, BaseColour.GOLD, "gold", Util.newArrayListOfValues("crit")),

	SCAR(false, BaseColour.TAN, "tan"),
	TATTOO(false, BaseColour.GREY, "grey"),

	PERK(false, BaseColour.AQUA, "aqua", Util.newArrayListOfValues("perk")),
	TRAIT(false, BaseColour.GREEN_LIGHT, "green", Util.newArrayListOfValues("trait")),
	FETISH(false, BaseColour.PINK_LIGHT, "light pink", Util.newArrayListOfValues("fetish")),
	STATUS_EFFECT(false, BaseColour.YELLOW, "yellow"),
	SPECIAL_ATTACK(false, BaseColour.CRIMSON, "crimson"),
	STATUS_EFFECT_TIME_OVERFLOW(false, BaseColour.BLUE, "aqua"),
	STATUS_EFFECT_TIME_HIGH(false, BaseColour.GREEN_LIGHT, "green"),
	STATUS_EFFECT_TIME_MEDIUM(false, BaseColour.ORANGE, "orange"),
	STATUS_EFFECT_TIME_LOW(false, BaseColour.RED, "red"),

	RACE_BESTIAL(false, BaseColour.TAN, "tan", Util.newArrayListOfValues("bestial", "animal", "feral")),
	RACE_UNKNOWN(false, BaseColour.BLACK, "black", Util.newArrayListOfValues("unknown")),
	RACE_HUMAN(false, BaseColour.BLUE_STEEL, "pale blue", Util.newArrayListOfValues("human")),
	RACE_HALF_DEMON(false, BaseColour.LILAC, "lilac", Util.newArrayListOfValues("halfDemon")),
	RACE_DEMON(false, BaseColour.PURPLE_LIGHT, "light purple", Util.newArrayListOfValues("demon")),
	RACE_LILIN(false, BaseColour.PURPLE, "purple", Util.newArrayListOfValues("lilin")),
	RACE_IMP(false, BaseColour.PURPLE, "purple", Util.newArrayListOfValues("imp")),
	RACE_ANGEL(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("angel")),
	RACE_DOG_MORPH(false, BaseColour.BROWN, "brown", Util.newArrayListOfValues("dogMorph", "dog")),
	RACE_CAT_MORPH(false, BaseColour.PINK_SALMON, "salmon-pink", Util.newArrayListOfValues("catMorph", "cat")),
	RACE_CAT_MORPH_CARACAL(false, BaseColour.PINK_SALMON, "salmon-pink", Util.newArrayListOfValues("ocelotMorph", "ocelot")),
	RACE_CAT_MORPH_LION(false, BaseColour.YELLOW, "yellow", Util.newArrayListOfValues("lionMorph", "lion")),
	RACE_CAT_MORPH_LEOPARD(false, BaseColour.GINGER, "ginger", Util.newArrayListOfValues("leopardMorph", "leopard")),
	RACE_CAT_MORPH_TIGER(false, BaseColour.GINGER, "ginger", Util.newArrayListOfValues("tigerMorph", "tiger")),
	RACE_CAT_MORPH_CHEETAH(false, BaseColour.YELLOW, "yellow", Util.newArrayListOfValues("cheetahMorph", "cheetah")),
	RACE_CAT_MORPH_LYNX(false, BaseColour.SILVER, "silver", Util.newArrayListOfValues("lynxMorph", "lynx")),
	RACE_CAT_MORPH_LEOPARD_SNOW(false, BaseColour.SILVER, "silver", Util.newArrayListOfValues("leopardSnowMorph", "snowLeopard", "snep", "leopardSnow", "snowLeopardMorph")),
	RACE_COW_MORPH(false, BaseColour.TAN, "tan", Util.newArrayListOfValues("cowMorph", "cow")),
	RACE_HORSE_MORPH(false, BaseColour.ORANGE, "orange", Util.newArrayListOfValues("horseMorph", "horse")),
	RACE_PEGASUS(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("pegasusMorph", "pegasus")),
	RACE_UNICORN(false, BaseColour.WHITE, "white", Util.newArrayListOfValues("unicornMorph", "unicorn")),
	RACE_ALICORN(false, BaseColour.YELLOW_LIGHT, "light yellow", Util.newArrayListOfValues("alicornMorph", "alicorn")),
	RACE_CENTAUR(false, BaseColour.BROWN_DARK, "dark brown", Util.newArrayListOfValues("centaur")),
	RACE_PEGATAUR(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("pegataur")),
	RACE_REINDEER_MORPH(false, BaseColour.BROWN_DARK, "dark brown", Util.newArrayListOfValues("reindeerMorph", "reindeer")),
	RACE_WOLF_MORPH(false, BaseColour.BLACK, "black", Util.newArrayListOfValues("wolfMorph", "wolf")),
	RACE_FOX_MORPH(false, BaseColour.GINGER, "ginger", Util.newArrayListOfValues("foxMorph", "fox")),
	RACE_HARPY(false, BaseColour.PINK_LIGHT, "light pink", Util.newArrayListOfValues("harpy")),
	RACE_SLIME(false, BaseColour.GREEN_LIGHT, "light green", Util.newArrayListOfValues("slime")),
	RACE_SQUIRREL_MORPH(false, BaseColour.GINGER, "ginger", Util.newArrayListOfValues("squirrelMorph", "squirrel")),
	RACE_RAT_MORPH(false, BaseColour.BROWN_DARK, "dark brown", Util.newArrayListOfValues("ratMorph", "rat")),
	RACE_RABBIT_MORPH(false, BaseColour.BROWN_DARK, "dark brown", Util.newArrayListOfValues("rabbitMorph", "rabbit")),
	RACE_BAT_MORPH(false, BaseColour.BLACK, "black", Util.newArrayListOfValues("batMorph", "bat")),
	RACE_ALLIGATOR_MORPH(false, BaseColour.GREEN_DARK, "dark green", Util.newArrayListOfValues("alligatorMorph", "alligator", "gatorMorph", "gator")),

	QUEST_MAIN(false, BaseColour.PINK, "pink", Util.newArrayListOfValues("questMain", "mainQuest")),
	QUEST_SIDE(false, BaseColour.BLUE, "blue", Util.newArrayListOfValues("questSide", "sideQuest")),
	QUEST_RELATIONSHIP(false, BaseColour.PINK_LIGHT, "pink", Util.newArrayListOfValues("questRelationship", "relationshipQuest")),

	MAP_MARKER(false, Util.newColour(0x6163DB), Util.newColour(0x6163DB), "blue"),

	ATTRIBUTE_HEALTH(false, BaseColour.CRIMSON, "crimson", Util.newArrayListOfValues("health", "hp", "energy")),
	ATTRIBUTE_MANA(false, BaseColour.PURPLE_LIGHT, "light purple", Util.newArrayListOfValues("willpower", "wp", "mana", "aura")),
//	ATTRIBUTE_STAMINA(BaseColour.LILAC, "lilac", Util.newArrayListOfValues("stamina", "sp", "energy")),

	ATTRIBUTE_PHYSIQUE(false, BaseColour.MAGENTA, "magenta", Util.newArrayListOfValues("physique", "phys", "strength", "str")),
	ATTRIBUTE_ARCANE(false, BaseColour.PURPLE, "purple", Util.newArrayListOfValues("intelligence", "int")),
//	ATTRIBUTE_FITNESS(BaseColour.LILAC, "light purple", Util.newArrayListOfValues("fitness", "fit")),
	ATTRIBUTE_CORRUPTION(false, BaseColour.PINK_DEEP, "pink", Util.newArrayListOfValues("corruption", "cor", "corr")),

	ATTRIBUTE_AROUSAL(false, BaseColour.PINK_DEEP, "pink", Util.newArrayListOfValues("arousal", "ars")),
	ATTRIBUTE_LUST(false, BaseColour.MAGENTA, "magenta", Util.newArrayListOfValues("lust", "lst", "seduction")),

	//TODO
	PHYSIQUE_STAGE_ZERO(false, BaseColour.MAGENTA, "magenta"),
	PHYSIQUE_STAGE_ONE(false, BaseColour.MAGENTA, "magenta"),
	PHYSIQUE_STAGE_TWO(false, BaseColour.MAGENTA, "magenta"),
	PHYSIQUE_STAGE_THREE(false, BaseColour.MAGENTA, "magenta"),
	PHYSIQUE_STAGE_FOUR(false, BaseColour.MAGENTA, "magenta"),
	PHYSIQUE_STAGE_FIVE(false, BaseColour.GOLD, "gold"),

	//TODO
	INTELLIGENCE_STAGE_ZERO(false, BaseColour.PURPLE, "purple"),
	INTELLIGENCE_STAGE_ONE(false, BaseColour.PURPLE, "purple"),
	INTELLIGENCE_STAGE_TWO(false, BaseColour.PURPLE, "purple"),
	INTELLIGENCE_STAGE_THREE(false, BaseColour.PURPLE, "purple"),
	INTELLIGENCE_STAGE_FOUR(false, BaseColour.PURPLE, "purple"),
	INTELLIGENCE_STAGE_FIVE(false, BaseColour.GOLD, "gold"),

	//TODO
	FITNESS_STAGE_ZERO(false, BaseColour.LILAC, "light purple"),
	FITNESS_STAGE_ONE(false, BaseColour.LILAC, "light purple"),
	FITNESS_STAGE_TWO(false, BaseColour.LILAC, "light purple"),
	FITNESS_STAGE_THREE(false, BaseColour.LILAC, "light purple"),
	FITNESS_STAGE_FOUR(false, BaseColour.LILAC, "light purple"),
	FITNESS_STAGE_FIVE(false, BaseColour.GOLD, "gold"),

	CORRUPTION_STAGE_ZERO(false, Util.newColour(0xffdf80), Util.newColour(0xffdf80), "gold"),
	CORRUPTION_STAGE_ONE(false, Util.newColour(0xff80bf), Util.newColour(0xff80bf), "pink"),
	CORRUPTION_STAGE_TWO(false, Util.newColour(0xff1a8c), Util.newColour(0xff1a8c), "pink"),
	CORRUPTION_STAGE_THREE(false, Util.newColour(0xe600ac), Util.newColour(0xe600ac), "pink"),
	CORRUPTION_STAGE_FOUR(false, Util.newColour(0xd411d4), Util.newColour(0xd411d4), "pink"),
	CORRUPTION_STAGE_FIVE(false, Util.newColour(0xbf00ff), Util.newColour(0xbf00ff), "pink"),

	AROUSAL_STAGE_ZERO(false, Util.newColour(0xfee6ff), Util.newColour(0xfee6ff), "pink"),
	AROUSAL_STAGE_ONE(false, Util.newColour(0xfcb3ff), Util.newColour(0xfcb3ff), "pink"),
	AROUSAL_STAGE_TWO(false, Util.newColour(0xfb80ff), Util.newColour(0xfb80ff), "pink"),
	AROUSAL_STAGE_THREE(false, Util.newColour(0xf94dff), Util.newColour(0xf94dff), "pink"),
	AROUSAL_STAGE_FOUR(false, Util.newColour(0xf824ff), Util.newColour(0xf824ff), "pink"),
	AROUSAL_STAGE_FIVE(false, Util.newColour(0xf700ff), Util.newColour(0xf700ff), "pink"),

	LUST_STAGE_ZERO(false, Util.newColour(0x80CAFF), Util.newColour(0xfee6ff), "blue"),
	LUST_STAGE_ONE(false, Util.newColour(0xB699FF), Util.newColour(0xfcb3ff), "purple"),
	LUST_STAGE_TWO(false, Util.newColour(0xFF99D1), Util.newColour(0xfb80ff), "pink"),
	LUST_STAGE_THREE(false, Util.newColour(0xFF61AB), Util.newColour(0xf94dff), "pink"),
	LUST_STAGE_FOUR(false, Util.newColour(0xFF3377), Util.newColour(0xf824ff), "dark pink"),
	LUST_STAGE_FIVE(false, Util.newColour(0xFF1A66), Util.newColour(0xf824ff), "dark pink"),

	DESIRE_STAGE_ZERO(false, Util.newColour(0xB699FF), Util.newColour(0xfcb3ff), "purple"),
	DESIRE_STAGE_ONE(false, Util.newColour(0xFF99D1), Util.newColour(0xfb80ff), "pink"),
	DESIRE_STAGE_TWO(false, Util.newColour(0xFF61AB), Util.newColour(0xf94dff), "pink"),
	DESIRE_STAGE_THREE(false, Util.newColour(0xFF3377), Util.newColour(0xf824ff), "dark pink"),
	DESIRE_STAGE_FOUR(false, Util.newColour(0xffdf80), Util.newColour(0xffdf80), "gold"),

	COMPANION(false, BaseColour.GREEN_LIGHT,  "light green", Util.newArrayListOfValues("companion", "companions")),

	AFFECTION(false, BaseColour.PINK_LIGHT,  "light pink", Util.newArrayListOfValues("affection")),
	OBEDIENCE(false, BaseColour.PURPLE_LIGHT,  "light purple", Util.newArrayListOfValues("obedience")),

	AFFECTION_NEGATIVE_FIVE(false, Util.newColour(0xff0066), Util.newColour(0x8e011e), "magenta"),
	AFFECTION_NEGATIVE_FOUR(false, Util.newColour(0xff2a7f), Util.newColour(0xa40123), "magenta"),
	AFFECTION_NEGATIVE_THREE(false, Util.newColour(0xff5599), Util.newColour(0xb21e44), "pink"),
	AFFECTION_NEGATIVE_TWO(false, Util.newColour(0xff80b2), Util.newColour(0xbc325a), "pink"),
	AFFECTION_NEGATIVE_ONE(false, Util.newColour(0xffaacc), Util.newColour(0xc44670), "pink"),
	AFFECTION_NEUTRAL(false, Util.newColour(0xe3dedb), Util.newColour(0xcd5986), "grey"),
	AFFECTION_POSITIVE_ONE(false, Util.newColour(0xffeeaa), Util.newColour(0xd66e9d), "yellow"),
	AFFECTION_POSITIVE_TWO(false, Util.newColour(0xffe680), Util.newColour(0xe082b3), "yellow"),
	AFFECTION_POSITIVE_THREE(false, Util.newColour(0xffdd55), Util.newColour(0xe996c9), "yellow"),
	AFFECTION_POSITIVE_FOUR(false, Util.newColour(0xffd42a), Util.newColour(0xf2aadf), "gold"),
	AFFECTION_POSITIVE_FIVE(false, Util.newColour(0xffcc00), Util.newColour(0xfbbcf4), "gold"),

	MASCULINE_PLUS(false, Util.newColour(0x4D9DFF), Util.newColour(0x4D9DFF), "dark blue", Util.newArrayListOfValues("masculineStrong", "masStr", "masculinePlus")),
	MASCULINE(false, Util.newColour(0x8ABEFF), Util.newColour(0x8ABEFF), "blue", Util.newArrayListOfValues("masculine", "mas")),
	ANDROGYNOUS(false, Util.newColour(0xB39EFF), Util.newColour(0xB39EFF), "purple", Util.newArrayListOfValues("androgynous", "andro")),
	FEMININE(false, Util.newColour(0xFFBDFF), Util.newColour(0xFFFBDFF), "pink", Util.newArrayListOfValues("feminine", "fem")),
	FEMININE_PLUS(false, Util.newColour(0xFF85FF), Util.newColour(0xFF85FF), "pink", Util.newArrayListOfValues("feminineStrong", "femStr", "femininePlus")),

	BODY_SIZE_ZERO(false, Util.newColour(0xFFEBD6), Util.newColour(0x241D00), "tan", Util.newArrayListOfValues("bodySizeZero")),
	BODY_SIZE_ONE(false, Util.newColour(0xFFE0BD), Util.newColour(0x3D3100), "tan", Util.newArrayListOfValues("bodySizeOne")),
	BODY_SIZE_TWO(false, Util.newColour(0xFFC88A), Util.newColour(0x5C4900), "tan", Util.newArrayListOfValues("bodySizeTwo")),
	BODY_SIZE_THREE(false, Util.newColour(0xFFAB57), Util.newColour(0x806600), "tan", Util.newArrayListOfValues("bodySizeThree")),
	BODY_SIZE_FOUR(false, Util.newColour(0xFF9124), Util.newColour(0x9E7E00), "tan", Util.newArrayListOfValues("bodySizeFour")),

	MUSCLE_ZERO(false, Util.newColour(0xDBFFF6), Util.newColour(0x001F17), "teal", Util.newArrayListOfValues("muscleZero")),
	MUSCLE_ONE(false, Util.newColour(0xBDFFED), Util.newColour(0x00382B), "teal", Util.newArrayListOfValues("muscleOne")),
	MUSCLE_TWO(false, Util.newColour(0x8AFFE0), Util.newColour(0x00523F), "teal", Util.newArrayListOfValues("muscleTwo")),
	MUSCLE_THREE(false, Util.newColour(0x57FFD2), Util.newColour(0x006B52), "teal", Util.newArrayListOfValues("muscleThree")),
	MUSCLE_FOUR(false, Util.newColour(0x24FFC5), Util.newColour(0x008566), "teal", Util.newArrayListOfValues("muscleFour")),

	AGE_LOLI(false, Util.newColour(0xAFE9B3), Util.newColour(0xc44670), "green", Util.newArrayListOfValues("ageLoli")), //I wanted to use my own color here originally, but it doesn't work Util.newColour(0xE6EFED), Util.newColour(0x009E27)

	AGE_CHILD(false, Util.newColour(0xE1F0C1), Util.newColour(0x73A112), "green", Util.newArrayListOfValues("ageChild")),
	AGE_PRETEENS(false, Util.newColour(0xE1F0C1), Util.newColour(0x73A112), "green", Util.newArrayListOfValues("agePreTeens")),
	AGE_EARLYTEENS(false, Util.newColour(0xE1F0C1), Util.newColour(0x73A112), "green", Util.newArrayListOfValues("ageEarlyTeens")),
	AGE_TEENS(false, Util.newColour(0xE1F0C1), Util.newColour(0x73A112), "green", Util.newArrayListOfValues("ageTeens")),
	AGE_TWENTIES(false, Util.newColour(0xCCE698), Util.newColour(0x638A0F), "green", Util.newArrayListOfValues("ageTwenties")),
	AGE_THIRTIES(false, Util.newColour(0xB8DC6F), Util.newColour(0x52730D), "green", Util.newArrayListOfValues("ageThirties")),
	AGE_FORTIES(false, Util.newColour(0xA4D246), Util.newColour(0x41590D), "green", Util.newArrayListOfValues("ageForties")),
	AGE_FIFTIES(false, Util.newColour(0x8AB92D), Util.newColour(0x334408), "green", Util.newArrayListOfValues("ageFifties")),
	AGE_SIXTIES(false, Util.newColour(0x6B9023), Util.newColour(0x232E05), "green", Util.newArrayListOfValues("ageSixties")),

	ALCOHOL(false, BaseColour.YELLOW_LIGHT, "light yellow", Util.newArrayListOfValues("alcohol")),
	ALCOHOL_LEVEL_ZERO(false, Util.newColour(0xF2E8C0), Util.newColour(0x967F22), "light yellow"),
	ALCOHOL_LEVEL_ONE(false,  Util.newColour(0xEDDFAB), Util.newColour(0x967F22), "light yellow"),
	ALCOHOL_LEVEL_TWO(false,  Util.newColour(0xE8D696), Util.newColour(0x967F22), "yellow"),
	ALCOHOL_LEVEL_THREE(false,  Util.newColour(0xE3CE82), Util.newColour(0x967F22), "yellow"),
	ALCOHOL_LEVEL_FOUR(false,  Util.newColour(0xDEC66E), Util.newColour(0x967F22), "yellow"),
	ALCOHOL_LEVEL_FIVE(false, Util.newColour(0xD9BD59), Util.newColour(0x967F22), "gold"),

	PSYCHOACTIVE(false, BaseColour.MAGENTA, "magenta", Util.newArrayListOfValues("psychoactive")),

	TRANSFORMATION_SHRINK(false, BaseColour.RED, "red", Util.newArrayListOfValues("tfShrink", "shrink", "tfShrunk", "shrunk", "tfShrinking", "shrinking")),
	TRANSFORMATION_GROW(false, BaseColour.GREEN, "green", Util.newArrayListOfValues("tfGrow", "grow", "tfGrown", "grown", "tfGrowth", "growth")),

	GENERIC_SIZE_ONE(false, Util.newColour(0xAFE9B3), Util.newColour(0xc44670), "green"),
	GENERIC_SIZE_TWO(false, Util.newColour(0xA0E4A3), Util.newColour(0xbc325a), "green"),
	GENERIC_SIZE_THREE(false, Util.newColour(0x8FE096), Util.newColour(0xb21e44), "green"),
	GENERIC_SIZE_FOUR(false, Util.newColour(0x77DA7F), Util.newColour(0xa40123), "green"),
	GENERIC_SIZE_FIVE(false, Util.newColour(0x67D570), Util.newColour(0x8e011e), "green"),
	GENERIC_SIZE_SIX(false, Util.newColour(0x57D161), Util.newColour(0x8e011e), "green"),
	GENERIC_SIZE_SEVEN(false, Util.newColour(0x47CD52), Util.newColour(0x8e011e), "green"),
	GENERIC_SIZE_EIGHT(false, Util.newColour(0x37C843), Util.newColour(0x8e011e), "green"),

	WETNESS(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("wetness", "wet", "tfWetness", "tfWet")),
	PLASTICITY(false, BaseColour.LILAC, "lilac", Util.newArrayListOfValues("plasticity", "tfPlasticity")),
	ELASTICITY(false, BaseColour.PURPLE_LIGHT, "light purple", Util.newArrayListOfValues("elasticity", "tfElasticity")),
	TRANSFORMATION_GENERIC(false, BaseColour.GREEN_LIME, "lime", Util.newArrayListOfValues("tfGeneric", "tfBase", "genericTF")),
	TRANSFORMATION_SEXUAL(false, BaseColour.PINK_LIGHT, "pink", Util.newArrayListOfValues("tfSex", "tfSexual", "sexualTF")),
	TRANSFORMATION_HUMAN(false, BaseColour.BLUE_STEEL, "pale blue", Util.newArrayListOfValues("tfHuman")),
	TRANSFORMATION_PARTIAL(false, Util.newColour(0xff80bf), Util.newColour(0xff80bf), "purple", Util.newArrayListOfValues("tfPartial")),
	TRANSFORMATION_PARTIAL_FULL(false, Util.newColour(0xff1a8c), Util.newColour(0xff1a8c), "purple", Util.newArrayListOfValues("tfMinor")),
	TRANSFORMATION_LESSER(false, Util.newColour(0xe600ac), Util.newColour(0xe600ac), "purple", Util.newArrayListOfValues("tfLesser")),
	TRANSFORMATION_GREATER(false, Util.newColour(0xd411d4), Util.newColour(0xd411d4), "purple-pink", Util.newArrayListOfValues("tfGreater")),

	// Speech colours:
	MASCULINE_PLUS_NPC(false, BaseColour.BLUE, "blue"),
	MASCULINE_NPC(false, BaseColour.BLUE_LIGHT, "blue"),
	ANDROGYNOUS_NPC(false, BaseColour.LILAC_LIGHT, "purple"),
	FEMININE_NPC(false, BaseColour.ROSE, "pink"),
	FEMININE_PLUS_NPC(false, BaseColour.PINK, "pink"),

	// Combat colours:
	DAMAGE_TYPE_PHYSICAL(false, Util.newColour(0xA79E90), Util.newColour(0x5C4D42), "grey-brown", Util.newArrayListOfValues("dmgPhysical", "resPhysical", "physical")),
	DAMAGE_TYPE_MANA(false, BaseColour.PURPLE_LIGHT, "purple", Util.newArrayListOfValues("dmgMana", "resMana")),
	DAMAGE_TYPE_LUST(false, BaseColour.PINK_LIGHT, "light pink", Util.newArrayListOfValues("dmgLust", "resLust")),
	DAMAGE_TYPE_SPELL(false, Util.newColour(0xFF6BDA), Util.newColour(0xFF6BDA), "pink", Util.newArrayListOfValues("dmgSpell", "resSpell", "spell")),
	DAMAGE_TYPE_FIRE(false, Util.newColour(0xff9955), Util.newColour(0xff9955), "orange", Util.newArrayListOfValues("dmgFire", "resFire", "fire")),
	DAMAGE_TYPE_COLD(false, Util.newColour(0x85C6FF), Util.newColour(0x85C6FF), "blue", Util.newArrayListOfValues("dmgCold", "resCold", "cold", "ice")),
	DAMAGE_TYPE_POISON(false, Util.newColour(0x85FF8B), Util.newColour(0x85FF8B), "green", Util.newArrayListOfValues("dmgPoison", "resPoison", "poison")),
	DAMAGE_TYPE_PURE(false, Util.newColour(0xFFCC00), Util.newColour(0xFFCC00), "gold", Util.newArrayListOfValues("dmgPure", "resPure", "pure")),

	SPELL_SCHOOL_FIRE(false, BaseColour.ORANGE, "orange", Util.newArrayListOfValues("spellFire", "schoolFire")),
	SPELL_SCHOOL_WATER(false, BaseColour.AQUA, "aqua", Util.newArrayListOfValues("water", "spellWater", "schoolWater")),
	SPELL_SCHOOL_EARTH(false, BaseColour.BROWN, "brown", Util.newArrayListOfValues("earth", "spellEarth", "schoolEarth")),
	SPELL_SCHOOL_AIR(false, BaseColour.BLUE_LIGHT, "light blue", Util.newArrayListOfValues("air", "spellAir", "schoolAir")),
	SPELL_SCHOOL_ARCANE(false, BaseColour.PINK, "pink", Util.newArrayListOfValues("spellArcane", "schoolArcane")),

	// Rarity colours:
	RARITY_UNKNOWN(false, BaseColour.BLACK, "grey"),
	RARITY_JINXED(false, BaseColour.RED, "red", Util.newArrayListOfValues("jinx", "jinxed")),
	RARITY_COMMON(false, Util.newColour(0xf2f2f2), Util.newColour(0xf2f2f2), "white", Util.newArrayListOfValues("common")),
	RARITY_UNCOMMON(false, Util.newColour(0x57f17c), Util.newColour(0x108228), "green", Util.newArrayListOfValues("uncommon")),
	RARITY_RARE(false, Util.newColour(0x47C2FF), Util.newColour(0x47C2FF), "blue", Util.newArrayListOfValues("rare")),
	RARITY_EPIC(false, Util.newColour(0xFF4DFC), Util.newColour(0xFF4DFC), "purple", Util.newArrayListOfValues("epic")),
	RARITY_LEGENDARY(false, Util.newColour(0xffcc00), Util.newColour(0xffcc00), "gold", Util.newArrayListOfValues("legendary")),
	RARITY_QUEST(false, BaseColour.TEAL, "teal", Util.newArrayListOfValues("teal")),

	RARITY_UNKNOWN_BACKGROUND(false, Util.newColour(0x252527), Util.newColour(0xAFAFB6), "grey"),
	RARITY_JINXED_BACKGROUND(false, Util.newColour(0x694b4e), Util.newColour(0xE3B5B5), "red"),
	RARITY_COMMON_BACKGROUND(false, Util.newColour(0x404040), Util.newColour(0xBDBDC1), "white"),
	RARITY_UNCOMMON_BACKGROUND(false, Util.newColour(0x3D5C47), Util.newColour(0x3D5C47), "green"),
	RARITY_RARE_BACKGROUND(false, Util.newColour(0x4b4b6c), Util.newColour(0xB4D0EE), "blue"),
	RARITY_EPIC_BACKGROUND(false, Util.newColour(0x523455), Util.newColour(0xDDC1E2), "purple"),
	RARITY_LEGENDARY_BACKGROUND(false, Util.newColour(0x4b4b33), Util.newColour(0xF1DEA7), "gold"),
	RARITY_QUEST_BACKGROUND(false, Util.newColour(0x344C4B), Util.newColour(0xBEE4E4), "teal"),

	// Inventory colours:
	CURRENCY_GOLD(true, BaseColour.GOLD, "gold", Util.newArrayListOfValues("currency", "currencyGold")),
	CURRENCY_SILVER(true, BaseColour.SILVER, "silver", Util.newArrayListOfValues("currencySilver")),
	CURRENCY_COPPER(true, BaseColour.COPPER, "copper", Util.newArrayListOfValues("currencyCopper")),

	MILK(false, BaseColour.YELLOW_LIGHT,  "light yellow", Util.newArrayListOfValues("milk", "lactation")),
	CUM(false, BaseColour.BLUE_LIGHT,  "light blue", Util.newArrayListOfValues("cum", "cummed", "dirty")),
	GIRLCUM(false, BaseColour.PINK_LIGHT,  "light pink", Util.newArrayListOfValues("girlcum", "gcum")),

	VAGINA(false, BaseColour.PINK,  "pink", Util.newArrayListOfValues("vagina", "pussy", "cunt")),
	ANUS(false, BaseColour.PINK_DEEP,  "deep pink", Util.newArrayListOfValues("asshole", "anus", "ass")),
	PENIS(false, BaseColour.PURPLE,  "purple", Util.newArrayListOfValues("penis", "cock")),
	NIPPLES(false, BaseColour.PINK_LIGHT,  "light pink", Util.newArrayListOfValues("nipples", "nipple")),
	NIPPLES_CROTCH(false, BaseColour.PURPLE_LIGHT,  "light purple", Util.newArrayListOfValues("nipplesCrotch", "crotchNipples")),
	URETHRA_PENIS(false, BaseColour.PINK_SALMON,  "salmon-pink", Util.newArrayListOfValues("penisUrethra", "urethraPenis", "urethra")),
	UREHTRA_VAGINA(false, BaseColour.LILAC,  "lilac", Util.newArrayListOfValues("vaginaUrethra", "urethraVagina")),

	SEALED(false, BaseColour.PINK_DEEP, "pink"),
	DISPLACED(false, BaseColour.CRIMSON, "crimson"),

	// Text colours:
	TEXT(false, Util.newColour(0xDDDDDD), Util.newColour(0x262626), "grey", Util.newArrayListOfValues("text")),
	TEXT_HALF_GREY(false, Util.newColour(0xBBBBBB), Util.newColour(0x444444), "grey", Util.newArrayListOfValues("halfDisabled")),
	TEXT_GREY(false, Util.newColour(0x777777), Util.newColour(0x777777), "grey", Util.newArrayListOfValues("disabled")),
	TEXT_GREY_DARK(false, Util.newColour(0x444444), Util.newColour(0xcccccc), "grey", Util.newArrayListOfValues("disabledDark")),

	// Standard colours used for clothing:
	CLOTHING_WHITE(false, Util.newColour(0xdddddd), Util.newColour(0xdddddd), "white"),
	CLOTHING_GREY_LIGHT(false, Util.newColour(0xaaaaaa), Util.newColour(0xaaaaaa), "light grey"),
	CLOTHING_GREY(false, Util.newColour(0x777777), Util.newColour(0x777777), "grey"),
	CLOTHING_GREY_DARK(false, Util.newColour(0x555555), Util.newColour(0x555555), "dark grey"),
	CLOTHING_BLACK(false, Util.newColour(0x333333), Util.newColour(0x333333), "black"),
	CLOTHING_BLACK_JET(false, Util.newColour(0x1a1a1a), Util.newColour(0x1a1a1a), "pitch black"),

	CLOTHING_RED_VERY_DARK(false, Util.newColour(0x660016), Util.newColour(0x660016), "midnight red"),
	CLOTHING_RED_DARK(false, Util.newColour(0x900020), Util.newColour(0x900020), "burgundy"),
	CLOTHING_RED_BRIGHT(false, Util.newColour(0xFA2424), Util.newColour(0xFA2424), "bright red"),
	CLOTHING_RED(false, Util.newColour(0xD84646), Util.newColour(0xD84646), "red"),
	CLOTHING_DESATURATED_BROWN(false, Util.newColour(0x6c5d53), Util.newColour(0x6c5d53), "desaturated brown"),
	CLOTHING_BROWN(false, Util.newColour(0xC87137), Util.newColour(0xC87137), "brown"),
	CLOTHING_BROWN_DARK(false, Util.newColour(0x63391C), Util.newColour(0x63391C), "dark brown"),
	CLOTHING_BROWN_VERY_DARK(false, Util.newColour(0x3C2211), Util.newColour(0x3C2211), "midnight brown"),
	CLOTHING_ORANGE(false, Util.newColour(0xE79F6F), Util.newColour(0xE79F6F), "orange"),
	CLOTHING_ORANGE_BRIGHT(false, Util.newColour(0xFF7900), Util.newColour(0xFF7900), "bright orange"),
	CLOTHING_ORANGE_DARK(false, Util.newColour(0xE56D00), Util.newColour(0xE56D00), "dark orange"),
	CLOTHING_TAN(false, Util.newColour(0xEDC491), Util.newColour(0xEDC491), "tan"),
	CLOTHING_KHAKI(false, Util.newColour(0xaa9e76), Util.newColour(0xaa9e76), "khaki"),
	CLOTHING_OLIVE(false, Util.newColour(0x5f4a2a), Util.newColour(0x5f4a2a), "olive"),//0x887509 0x5f4a2a
	CLOTHING_YELLOW(false, Util.newColour(0xE2C360), Util.newColour(0xE2C360), "yellow"),
	CLOTHING_YELLOW_DARK(false, Util.newColour(0x7F691A), Util.newColour(0x7F691A), "mustard yellow"),
	CLOTHING_GREEN_LIME(false, Util.newColour(0xD0E37D), Util.newColour(0xD0E37D), "lime green"),
	CLOTHING_GREEN(false, Util.newColour(0x74AA74), Util.newColour(0x74AA74), "green"),
	CLOTHING_GREEN_DRAB(false, Util.newColour(0x4C5D4C), Util.newColour(0x4C5D4C), "drab green"),
	CLOTHING_GREEN_DARK(false, Util.newColour(0x3B6F3D), Util.newColour(0x3B6F3D), "dark green"),
	CLOTHING_GREEN_VERY_DARK(false, Util.newColour(0x1C311C), Util.newColour(0x1C311C), "midnight green"),
	CLOTHING_TURQUOISE(false, Util.newColour(0x6EC4B3), Util.newColour(0x6EC4B3), "turquoise"),
	CLOTHING_BLUE_LIGHT(false, Util.newColour(0x72CFE3), Util.newColour(0x72CFE3), "light blue"),
	CLOTHING_BLUE(false, Util.newColour(0x3971C6), Util.newColour(0x3971C6), "blue"),
	CLOTHING_BLUE_GREY(false, Util.newColour(0x5D8AA8), Util.newColour(0x5D8AA8), "blue-grey"),
	CLOTHING_BLUE_NAVY(false, Util.newColour(0x1f2c3f), Util.newColour(0x1f2c3f), "navy blue"),
	CLOTHING_BLUE_DARK(false, Util.newColour(0x003C89), Util.newColour(0x003C89), "dark blue"),
	CLOTHING_BLUE_VERY_DARK(false, Util.newColour(0x002C66), Util.newColour(0x002C66), "midnight blue"),
	CLOTHING_PURPLE_VERY_DARK(false, Util.newColour(0x322145), Util.newColour(0x322145), "midnight purple"),
	CLOTHING_PURPLE_DARK(false, Util.newColour(0x674A95), Util.newColour(0x674A95), "dark purple"),
	CLOTHING_PURPLE(false, Util.newColour(0xA382D3), Util.newColour(0xA382D3), "purple"),
	CLOTHING_PURPLE_LIGHT(false, Util.newColour(0xC58ED7), Util.newColour(0xC58ED7), "violet"),
	CLOTHING_PERIWINKLE(false, Util.newColour(0xCCCCFF), Util.newColour(0xCCCCFF), "periwinkle"),
	CLOTHING_PINK_LIGHT(false, Util.newColour(0xF4B3F4), Util.newColour(0xF4B3F4), "light pink"),
	CLOTHING_PINK(false, Util.newColour(0xD75086), Util.newColour(0xD75086), "pink"),
	CLOTHING_PINK_DARK(false, Util.newColour(0xFF1493), Util.newColour(0xFF1493), "deep pink"),
	CLOTHING_PINK_HOT(false, Util.newColour(0xff69b4), Util.newColour(0xff69b4), "hot pink"),

	CLOTHING_BLACK_STEEL(true, Util.newColour(0x333333), Util.newColour(0x333333), "black steel"),
	CLOTHING_GUNMETAL(true, Util.newColour(0x555555), Util.newColour(0x555555), "gunmetal gray"),
	CLOTHING_STEEL(true, Util.newColour(0x969696), Util.newColour(0x969696), "steel"),
	CLOTHING_BRASS(true, Util.newColour(0xab8317), Util.newColour(0xab8317), "brass"),
	CLOTHING_COPPER(true, Util.newColour(0xD46F2B), Util.newColour(0xD46F2B), "copper", Util.newArrayListOfValues("copper")),
	CLOTHING_SILVER(true, Util.newColour(0xC4C4C4), Util.newColour(0xC4C4C4), "silver", Util.newArrayListOfValues("silver")),
	CLOTHING_GOLD(true, Util.newColour(0xEBC633), Util.newColour(0xEBC633), "gold"),
	CLOTHING_ROSE_GOLD(true, BaseColour.ROSE_GOLD, "rose gold"),
	CLOTHING_PLATINUM(true, BaseColour.PLATINUM, "platinum"),

	// For special use with rainbow clothing:
	CLOTHING_MULTICOLOURED(false, Util.newColour(0xff3030), Util.newColour(0xccffff), "multicoloured"),

	// Body parts:

	// Skin (Human and Demon):
	SKIN_PALE(false, Util.newColour(0xFBF4E9), Util.newColour(0x534946), "pale"),
	SKIN_LIGHT(false, Util.newColour(0xEFDBD7), Util.newColour(0x534946), "light"),
	SKIN_PORCELAIN(false, Util.newColour(0xDBCDB9), Util.newColour(0xDBCDB9), "porcelain"),
	SKIN_ROSY(false, Util.newColour(0xDDAA93), Util.newColour(0xDDAA93), "rosy"),
	SKIN_OLIVE(false, BaseColour.TAN, "olive"),
	SKIN_TANNED(false, Util.newColour(0xC39D6B), Util.newColour(0xC39D6B), "tanned"),
	SKIN_DARK(false, BaseColour.BROWN_DARK, "dark"),
	SKIN_CHOCOLATE(false, Util.newColour(0x59372D), Util.newColour(0x59372D), "chocolate"),
	SKIN_EBONY(false, BaseColour.BLACK, "ebony"),

	SKIN_RED(false, BaseColour.CRIMSON, "scarlet"),
	SKIN_RED_DARK(false, BaseColour.RED_DARK, "dark red"),
	SKIN_BROWN(false, BaseColour.BROWN, "brown"),
	SKIN_YELLOW(false, BaseColour.YELLOW, "yellow"),
	SKIN_AMBER(false, BaseColour.AMBER, "amber"),
	SKIN_PINK(false, BaseColour.PINK, "pink"),
	SKIN_PINK_LIGHT(false, BaseColour.PINK_LIGHT, "light pink"),
	SKIN_GREEN(false, BaseColour.GREEN, "green"),
	SKIN_GREEN_DARK(false, BaseColour.GREEN_DARK, "dark green"),
	SKIN_BLUE_LIGHT(false, BaseColour.BLUE_LIGHT, "light blue"),
	SKIN_BLUE(false, BaseColour.BLUE, "blue"),
	SKIN_BLUE_DARK(false, BaseColour.BLUE_DARK, "dark blue"),
	SKIN_PERIWINKLE(false, BaseColour.PERIWINKLE, "periwinkle"),
	SKIN_LILAC(false, BaseColour.LILAC, "lilac"),
	SKIN_PURPLE(false, BaseColour.PURPLE, "purple"),
	SKIN_PURPLE_DARK(false, BaseColour.PURPLE_DARK, "dark purple"),
	SKIN_IVORY(false, BaseColour.WHITE, "ivory"),
	SKIN_GREY(false, BaseColour.GREY, "grey"),
	SKIN_JET_BLACK(false, BaseColour.BLACK, "pitch black") {
		public boolean isJetBlack() { return true; }
	},

	// Slime types:

	SLIME_RED(false, BaseColour.RED, "translucent red"),
	SLIME_RED_DARK(false, BaseColour.RED_DARK, "translucent dark red"),
	SLIME_BROWN_DARK(false, BaseColour.BROWN_DARK, "translucent dark brown"),
	SLIME_BROWN(false, BaseColour.BROWN, "translucent brown"),
	SLIME_ORANGE(false, BaseColour.ORANGE, "translucent orange"),
	SLIME_TAN(false, BaseColour.TAN, "translucent tan"),
	SLIME_YELLOW(false, BaseColour.YELLOW, "translucent yellow"),
	SLIME_AMBER(false, BaseColour.AMBER, "translucent amber"),
	SLIME_PINK_DARK(false, BaseColour.PINK_DEEP, "translucent dark pink"),
	SLIME_PINK(false, BaseColour.PINK, "translucent pink"),
	SLIME_PINK_LIGHT(false, BaseColour.PINK_LIGHT, "translucent light pink"),
	SLIME_GREEN(false, BaseColour.GREEN, "translucent green"),
	SLIME_GREEN_DARK(false, BaseColour.GREEN_DARK, "translucent dark green"),
	SLIME_BLUE_LIGHT(false, BaseColour.BLUE_LIGHT, "translucent light blue"),
	SLIME_BLUE(false, BaseColour.BLUE, "translucent blue"),
	SLIME_BLUE_DARK(false, BaseColour.BLUE_DARK, "translucent dark blue"),
	SLIME_PERIWINKLE(false, BaseColour.PERIWINKLE, "translucent periwinkle"),
	SLIME_LILAC(false, BaseColour.LILAC, "translucent lilac"),
	SLIME_PURPLE(false, BaseColour.PURPLE, "translucent purple"),
	SLIME_PURPLE_DARK(false, BaseColour.PURPLE_DARK, "translucent dark purple"),
	SLIME_CLEAR(false, BaseColour.WHITE, "clear"),
	SLIME_GREY(false, BaseColour.GREY, "translucent grey"),
	SLIME_BLACK(false, BaseColour.BLACK, "translucent black"),
	SLIME_JET_BLACK(false, BaseColour.BLACK, "translucent pitch black") {
		public boolean isJetBlack() { return true; }
	},
	SLIME_WHITE(false, BaseColour.WHITE, "translucent white"),
	SLIME_RAINBOW(false, BaseColour.BLUE_LIGHT,
			"translucent "
			+ "<span style='color:#E64C4C;'>r</span>"
			+ "<span style='color:#E6854C;'>a</span>"
			+ "<span style='color:#E6C74C;'>i</span>"
			+ "<span style='color:#6EE64C;'>n</span>"
			+ "<span style='color:#4CB2E6;'>b</span>"
			+ "<span style='color:#AD4CE6;'>o</span>"
			+ "<span style='color:#E64CA8;'>w</span>") {
		@Override
		public List<String> getRainbowColours() {
			return Util.newArrayListOfValues(
					"#E64C4C",
					"#E6854C",
					"#E6C74C",
					"#6EE64C",
					"#4CB2E6",
					"#AD4CE6",
					"#E64CA8");
		}
	},
	SLIME_RAINBOW_PASTEL(false, BaseColour.PINK_LIGHT,
			"<span style='color:#4bb1d0;'>p</span>"
			+ "<span style='color:#7bd8b0;'>a</span>"
			+ "<span style='color:#83a5ef;'>s</span>"
			+ "<span style='color:#ecb6f9;'>t</span>"
			+ "<span style='color:#4bb1d0;'>e</span>"
			+ "<span style='color:#7bd8b0;'>l</span>"
			+ " "
			+ "<span style='color:#83a5ef;'>r</span>"
			+ "<span style='color:#ecb6f9;'>a</span>"
			+ "<span style='color:#4bb1d0;'>i</span>"
			+ "<span style='color:#7bd8b0;'>n</span>"
			+ "<span style='color:#83a5ef;'>b</span>"
			+ "<span style='color:#ecb6f9;'>o</span>"
			+ "<span style='color:#4bb1d0;'>w</span>") {
		@Override
		public List<String> getRainbowColours() {
			return Util.newArrayListOfValues(
					"#4bb1d0",
					"#7bd8b0",
					"#83a5ef",
					"#ecb6f9");
		}
	},

	// Feathers:
//	FEATHERS_RED(false, BaseColour.RED, "red"),
//	FEATHERS_RED_DARK(false, BaseColour.RED_DARK, "dark red"),
//	FEATHERS_BROWN_DARK(false, BaseColour.BROWN_DARK, "dark brown"),
//	FEATHERS_BROWN(false, BaseColour.BROWN, "brown"),
//	FEATHERS_TAN(false, BaseColour.TAN, "tan"),
//	FEATHERS_ORANGE(false, BaseColour.ORANGE, "orange"),
//	FEATHERS_GINGER(false, BaseColour.GINGER, "ginger"),
//	FEATHERS_BLEACH_BLONDE(false, BaseColour.YELLOW_LIGHT, "bleach-blonde"),
//	FEATHERS_AMBER(false, BaseColour.AMBER, "amber"),
//	FEATHERS_PINK(false, BaseColour.PINK, "pink"),
//	FEATHERS_GREEN(false, BaseColour.GREEN, "green"),
//	FEATHERS_GREEN_DARK(false, BaseColour.GREEN_DARK, "dark green"),
//	FEATHERS_BLUE_LIGHT(false, BaseColour.BLUE_LIGHT, "light blue"),
//	FEATHERS_BLUE(false, BaseColour.BLUE, "blue"),
//	FEATHERS_BLUE_DARK(false, BaseColour.BLUE_DARK, "dark blue"),
//	FEATHERS_PERIWINKLE(false, BaseColour.PERIWINKLE, "periwinkle"),
//	FEATHERS_PURPLE(false, BaseColour.PURPLE, "purple"),
//	FEATHERS_PURPLE_DARK(false, BaseColour.PURPLE_DARK, "dark purple"),
//	FEATHERS_GREY(false, BaseColour.GREY, "grey"),
//	FEATHERS_BLACK(false, BaseColour.BLACK, "black"),
//	FEATHERS_WHITE(false, BaseColour.WHITE, "white"),

	// Horns:
	HORN_WHITE(false, BaseColour.WHITE, "ivory"),
	HORN_GREY(false, BaseColour.GREY, "grey"),
	HORN_DARK_GREY(false, BaseColour.GREY_DARK, "dark-grey"),
	HORN_BLACK(false, BaseColour.BLACK, "black"),
	HORN_JET_BLACK(false, BaseColour.BLACK, "pitch black") {
		public boolean isJetBlack() { return true; }
	},

	HORN_RED(false, BaseColour.RED, "red"),
	HORN_SCARLET(false, BaseColour.CRIMSON, "scarlet"),
	HORN_BROWN(false, BaseColour.BROWN, "brown"),
	HORN_DARK_BROWN(false, BaseColour.BROWN_DARK, "dark brown"),
	HORN_AMBER(false, BaseColour.AMBER, "amber"),
	HORN_PINK(false, BaseColour.PINK_LIGHT, "light pink"),
	HORN_GREEN(false, BaseColour.GREEN, "green"),
	HORN_BLUE(false, BaseColour.BLUE_LIGHT, "light blue"),
	HORN_LILAC(false, BaseColour.LILAC, "lilac"),
	HORN_PURPLE(false, BaseColour.PURPLE, "purple"),

	// Antlers:
	ANTLER_WHITE(false, BaseColour.WHITE, "ivory"),
	ANTLER_TAN(false, BaseColour.TAN, "tan"),
	ANTLER_BROWN(false, BaseColour.BROWN, "brown"),
	ANTLER_DARK_BROWN(false, BaseColour.BROWN_DARK, "dark brown"),
	ANTLER_GREY(false, BaseColour.GREY, "grey"),
	ANTLER_DARK_GREY(false, BaseColour.GREY_DARK, "dark-grey"),
	ANTLER_BLACK(false, BaseColour.BLACK, "black"),
	ANTLER_JET_BLACK(false, BaseColour.BLACK, "pitch black") {
		public boolean isJetBlack() { return true; }
	},

	ANTLER_RED(false, BaseColour.RED, "red"),
	ANTLER_SCARLET(false, BaseColour.CRIMSON, "scarlet"),
	ANTLER_AMBER(false, BaseColour.AMBER, "amber"),
	ANTLER_PINK(false, BaseColour.PINK_LIGHT, "light pink"),
	ANTLER_GREEN(false, BaseColour.GREEN, "green"),
	ANTLER_BLUE(false, BaseColour.BLUE_LIGHT, "light blue"),
	ANTLER_LILAC(false, BaseColour.LILAC, "lilac"),
	ANTLER_PURPLE(false, BaseColour.PURPLE, "purple"),

	// Orifices:
	ORIFICE_INTERIOR(false, BaseColour.ROSE, "fleshy-pink"),

	// Misc:
	TONGUE(false, BaseColour.ROSE, "pink"),

	// Generic colours:
	COVERING_SILVER(true, BaseColour.GREY, "metallic silver"),
	COVERING_GOLD(true, BaseColour.GOLD, "metallic gold"),
	COVERING_PLATINUM(true, BaseColour.PLATINUM, "metallic platinum"),
	COVERING_ROSE_GOLD(true, BaseColour.ROSE_GOLD, "metallic rose gold"),
	COVERING_COPPER(true, BaseColour.COPPER, "metallic copper"),
	COVERING_STEEL(true, Util.newColour(0x969696), Util.newColour(0x969696), "metallic steel"),
	COVERING_TAN(false, BaseColour.TAN, "tan"),
	COVERING_BROWN(false, BaseColour.BROWN, "brown"),
	COVERING_BROWN_DARK(false, BaseColour.BROWN_DARK, "dark brown"),
	COVERING_BLACK(false, BaseColour.BLACK, "black"),
	COVERING_JET_BLACK(false, BaseColour.BLACK, "pitch black") {
		public boolean isJetBlack() { return true; }
	},
	COVERING_GREY(false, BaseColour.GREY, "grey"),
	COVERING_DIRTY_BLONDE(false, BaseColour.TAN, "dirty-blonde"),
	COVERING_BLONDE(false, BaseColour.YELLOW, "blonde"),
	COVERING_BLEACH_BLONDE(false, BaseColour.YELLOW_LIGHT, "bleach-blonde"),
	COVERING_YELLOW(false, BaseColour.YELLOW, "yellow"),
	COVERING_GINGER(false, BaseColour.GINGER, "ginger"),
	COVERING_ORANGE(false, BaseColour.ORANGE, "orange"),
	COVERING_AMBER(false, BaseColour.AMBER, "amber"),
	COVERING_RED_LIGHT(false, BaseColour.RED_LIGHT, "red"),
	COVERING_RED(false, BaseColour.RED, "red"),
	COVERING_RED_DARK(false, BaseColour.RED_DARK, "dark red"),
	COVERING_AUBURN(false, BaseColour.AUBURN, "auburn"),
	COVERING_WHITE(false, BaseColour.WHITE, "white"),
	COVERING_BLUE_LIGHT(false, BaseColour.BLUE_LIGHT, "light blue"),
	COVERING_BLUE(false, BaseColour.BLUE, "blue"),
	COVERING_BLUE_DARK(false, BaseColour.BLUE_DARK, "dark blue"),
	COVERING_PERIWINKLE(false, BaseColour.PERIWINKLE, "periwinkle"),
	COVERING_LILAC(false, BaseColour.LILAC, "lilac"),
	COVERING_PURPLE_LIGHT(false, BaseColour.PURPLE_LIGHT, "light purple"),
	COVERING_PURPLE(false, BaseColour.PURPLE, "purple"),
	COVERING_PURPLE_DARK(false, BaseColour.PURPLE_DARK, "dark purple"),
	COVERING_PINK_LIGHT(false, BaseColour.PINK_LIGHT, "light pink"),
	COVERING_PINK(false, BaseColour.PINK, "pink"),
	COVERING_PINK_DARK(false, BaseColour.PINK_DEEP, "dark pink"),
	COVERING_GREEN(false, BaseColour.GREEN, "green"),
	COVERING_GREEN_DARK(false, BaseColour.GREEN_DARK, "dark green"),

	// Specials:
	COVERING_CLEAR(false, BaseColour.WHITE, "clear"), // For nail-polish
	COVERING_RAINBOW(false, BaseColour.BLUE_LIGHT,
			"<span style='color:#E64C4C;'>r</span>"
			+ "<span style='color:#E6854C;'>a</span>"
			+ "<span style='color:#E6C74C;'>i</span>"
			+ "<span style='color:#6EE64C;'>n</span>"
			+ "<span style='color:#4CB2E6;'>b</span>"
			+ "<span style='color:#AD4CE6;'>o</span>"
			+ "<span style='color:#E64CA8;'>w</span>") {
		@Override
		public List<String> getRainbowColours() {
			return Util.newArrayListOfValues(
					"#E64C4C",
					"#E6854C",
					"#E6C74C",
					"#6EE64C",
					"#4CB2E6",
					"#AD4CE6",
					"#E64CA8");
		}
	},
	COVERING_RAINBOW_PASTEL(false, BaseColour.PINK_LIGHT,
			"<span style='color:#4bb1d0;'>p</span>"
			+ "<span style='color:#7bd8b0;'>a</span>"
			+ "<span style='color:#83a5ef;'>s</span>"
			+ "<span style='color:#ecb6f9;'>t</span>"
			+ "<span style='color:#4bb1d0;'>e</span>"
			+ "<span style='color:#7bd8b0;'>l</span>"
			+ " "
			+ "<span style='color:#83a5ef;'>r</span>"
			+ "<span style='color:#ecb6f9;'>a</span>"
			+ "<span style='color:#4bb1d0;'>i</span>"
			+ "<span style='color:#7bd8b0;'>n</span>"
			+ "<span style='color:#83a5ef;'>b</span>"
			+ "<span style='color:#ecb6f9;'>o</span>"
			+ "<span style='color:#4bb1d0;'>w</span>") {
		@Override
		public List<String> getRainbowColours() {
			return Util.newArrayListOfValues(
					"#4bb1d0",
					"#7bd8b0",
					"#83a5ef",
					"#ecb6f9");
		}
	},
	COVERING_NONE(false, BaseColour.GREY, "none"),

	// Eye colours:
	EYE_WHITE(false, BaseColour.WHITE, "white"),

	EYE_BROWN(false, BaseColour.BROWN, "brown"),
	EYE_BLUE(false, BaseColour.BLUE_LIGHT, "blue"),
	EYE_HAZEL(false, BaseColour.TAN, "hazel"),
	EYE_AQUA(false, BaseColour.AQUA, "aqua"),
	EYE_GREEN(false, BaseColour.GREEN, "green"),
	EYE_GREY(false, BaseColour.GREY, "grey"),

	EYE_PERIWINKLE(false, BaseColour.PERIWINKLE, "periwinkle"),
	EYE_LILAC(false, BaseColour.LILAC, "lilac"),
	EYE_PURPLE(false, BaseColour.PURPLE, "purple"),
	EYE_VIOLET(false, BaseColour.PURPLE_DARK, "violet"),
	EYE_PINK_SALMON(false, BaseColour.PINK_SALMON, "salmon-pink"),
	EYE_CRIMSON(false, BaseColour.CRIMSON, "crimson"),
	EYE_GOLD(false, BaseColour.GOLD, "golden"),
	EYE_SILVER(false, BaseColour.SILVER, "silver"),

	EYE_YELLOW(false, BaseColour.YELLOW, "yellow"),
	EYE_AMBER(false, BaseColour.AMBER, "amber"),
	EYE_RED(false, BaseColour.RED, "red"),
	EYE_PINK(false, BaseColour.PINK, "pink"),
	EYE_ORANGE(false, BaseColour.ORANGE, "orange"),
	EYE_BLACK(false, BaseColour.BLACK, "black"),
	EYE_PITCH_BLACK(false, BaseColour.BLACK, "pitch black") {
		public boolean isJetBlack() { return true; }
	};

	public static final Colour[] ACTION_POINT_COLOURS = new Colour[] {Colour.GENERIC_EXCELLENT, Colour.GENERIC_GOOD, Colour.GENERIC_MINOR_GOOD, Colour.GENERIC_MINOR_BAD, Colour.GENERIC_BAD, Colour.GENERIC_TERRIBLE};

	// Skin/fur/body part groups:

	public static List<Colour> humanSkinColours = Util.newArrayListOfValues(
			Colour.SKIN_PALE,
			Colour.SKIN_LIGHT,
			Colour.SKIN_PORCELAIN,
			Colour.SKIN_ROSY,
			Colour.SKIN_OLIVE,
			Colour.SKIN_TANNED,
			Colour.SKIN_DARK,
			Colour.SKIN_CHOCOLATE,
			Colour.SKIN_EBONY);

	public static List<Colour> ratSkinColours = Util.newArrayListOfValues(
			Colour.SKIN_PINK_LIGHT);

	public static List<Colour> demonSkinColours = Util.newArrayListOfValues(
			Colour.SKIN_PALE,
			Colour.SKIN_LIGHT,
			Colour.SKIN_PORCELAIN,
			Colour.SKIN_ROSY,
			Colour.SKIN_OLIVE,
			Colour.SKIN_TANNED,
			Colour.SKIN_DARK,
			Colour.SKIN_CHOCOLATE,
			Colour.SKIN_EBONY,
			Colour.SKIN_IVORY,
			Colour.SKIN_GREY,
			Colour.SKIN_JET_BLACK,
			Colour.SKIN_RED,
			Colour.SKIN_RED_DARK,
			Colour.SKIN_BROWN,
			Colour.SKIN_AMBER,
			Colour.SKIN_YELLOW,
			Colour.SKIN_GREEN,
			Colour.SKIN_GREEN_DARK,
			Colour.SKIN_BLUE_LIGHT,
			Colour.SKIN_BLUE,
			Colour.SKIN_BLUE_DARK,
			Colour.SKIN_PERIWINKLE,
			Colour.SKIN_LILAC,
			Colour.SKIN_PURPLE,
			Colour.SKIN_PURPLE_DARK,
			Colour.SKIN_PINK_LIGHT,
			Colour.SKIN_PINK);

	public static List<Colour> allSkinColours = Util.newArrayListOfValues(
			Colour.SKIN_PALE,
			Colour.SKIN_LIGHT,
			Colour.SKIN_PORCELAIN,
			Colour.SKIN_ROSY,
			Colour.SKIN_OLIVE,
			Colour.SKIN_TANNED,
			Colour.SKIN_DARK,
			Colour.SKIN_CHOCOLATE,
			Colour.SKIN_EBONY,
			Colour.SKIN_IVORY,
			Colour.SKIN_GREY,
			Colour.SKIN_JET_BLACK,
			Colour.SKIN_RED,
			Colour.SKIN_RED_DARK,
			Colour.SKIN_BROWN,
			Colour.SKIN_AMBER,
			Colour.SKIN_YELLOW,
			Colour.SKIN_GREEN,
			Colour.SKIN_GREEN_DARK,
			Colour.SKIN_BLUE_LIGHT,
			Colour.SKIN_BLUE,
			Colour.SKIN_BLUE_DARK,
			Colour.SKIN_PERIWINKLE,
			Colour.SKIN_LILAC,
			Colour.SKIN_PURPLE,
			Colour.SKIN_PURPLE_DARK,
			Colour.SKIN_PINK_LIGHT,
			Colour.SKIN_PINK,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	public static List<Colour> naturalSlimeColours = Util.newArrayListOfValues(
			Colour.SLIME_CLEAR,
			Colour.SLIME_WHITE,
			Colour.SLIME_GREY,
			Colour.SLIME_BLACK,
			Colour.SLIME_JET_BLACK,
			Colour.SLIME_RED,
			Colour.SLIME_RED_DARK,
			Colour.SLIME_BROWN_DARK,
			Colour.SLIME_BROWN,
			Colour.SLIME_TAN,
			Colour.SLIME_YELLOW,
			Colour.SLIME_AMBER,
			Colour.SLIME_GREEN,
			Colour.SLIME_GREEN_DARK,
			Colour.SLIME_BLUE_LIGHT,
			Colour.SLIME_BLUE,
			Colour.SLIME_BLUE_DARK,
			Colour.SLIME_PERIWINKLE,
			Colour.SLIME_LILAC,
			Colour.SLIME_PURPLE,
			Colour.SLIME_PURPLE_DARK,
			Colour.SLIME_PINK_DARK,
			Colour.SLIME_PINK,
			Colour.SLIME_PINK_LIGHT
			);

	public static List<Colour> dyeSlimeColours = Util.newArrayListOfValues(
			Colour.SLIME_RAINBOW,
			Colour.SLIME_RAINBOW_PASTEL
	);

	public static List<Colour> naturalFeatherColours = Util.newArrayListOfValues(
			Colour.COVERING_WHITE,
			Colour.COVERING_GREY,
			Colour.COVERING_BLACK,
			Colour.COVERING_JET_BLACK,
			Colour.COVERING_RED_LIGHT,
			Colour.COVERING_RED,
			Colour.COVERING_RED_DARK,
			Colour.COVERING_AUBURN,
			Colour.COVERING_BROWN_DARK,
			Colour.COVERING_BROWN,
			Colour.COVERING_TAN,
			Colour.COVERING_ORANGE,
			Colour.COVERING_GINGER,
			Colour.COVERING_BLEACH_BLONDE,
			Colour.COVERING_YELLOW,
			Colour.COVERING_AMBER,
			Colour.COVERING_GREEN,
			Colour.COVERING_GREEN_DARK,
			Colour.COVERING_BLUE_LIGHT,
			Colour.COVERING_BLUE,
			Colour.COVERING_BLUE_DARK,
			Colour.COVERING_PERIWINKLE,
			Colour.COVERING_LILAC,
			Colour.COVERING_PURPLE_LIGHT,
			Colour.COVERING_PURPLE,
			Colour.COVERING_PURPLE_DARK,
			Colour.COVERING_PINK,
			Colour.COVERING_PINK_LIGHT
			);

	public static List<Colour> dyeFeatherColours = Util.newArrayListOfValues(
			Colour.COVERING_PLATINUM,
			Colour.COVERING_GOLD,
			Colour.COVERING_SILVER,
			Colour.COVERING_COPPER,
			Colour.COVERING_STEEL,
			Colour.COVERING_ROSE_GOLD,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL
			);

	public static List<Colour> naturalFurColours = Util.newArrayListOfValues(
			Colour.COVERING_WHITE,
			Colour.COVERING_SILVER,
			Colour.COVERING_BLONDE,
			Colour.COVERING_GINGER,
			Colour.COVERING_BROWN,
			Colour.COVERING_TAN,
			Colour.COVERING_BROWN_DARK,
			Colour.COVERING_GREY,
			Colour.COVERING_BLACK,
			Colour.COVERING_JET_BLACK);

	public static List<Colour> allCoveringColours = Util.newArrayListOfValues(
			Colour.COVERING_PLATINUM,
			Colour.COVERING_GOLD,
			Colour.COVERING_SILVER,
			Colour.COVERING_COPPER,
			Colour.COVERING_STEEL,
			Colour.COVERING_ROSE_GOLD,

			Colour.COVERING_WHITE,
			Colour.COVERING_GREY,
			Colour.COVERING_BLACK,
			Colour.COVERING_JET_BLACK,
			Colour.COVERING_RED_LIGHT,
			Colour.COVERING_RED,
			Colour.COVERING_RED_DARK,
			Colour.COVERING_AUBURN,
			Colour.COVERING_BROWN_DARK,
			Colour.COVERING_BROWN,
			Colour.COVERING_TAN,
			Colour.COVERING_ORANGE,
			Colour.COVERING_GINGER,
			Colour.COVERING_BLEACH_BLONDE,
			Colour.COVERING_BLONDE,
			Colour.COVERING_YELLOW,
			Colour.COVERING_AMBER,
			Colour.COVERING_GREEN,
			Colour.COVERING_GREEN_DARK,
			Colour.COVERING_BLUE_LIGHT,
			Colour.COVERING_BLUE,
			Colour.COVERING_BLUE_DARK,
			Colour.COVERING_PERIWINKLE,
			Colour.COVERING_LILAC,
			Colour.COVERING_PURPLE_LIGHT,
			Colour.COVERING_PURPLE,
			Colour.COVERING_PURPLE_DARK,
			Colour.COVERING_PINK,
			Colour.COVERING_PINK_LIGHT,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL
			);

	public static List<Colour> allMakeupColours = Util.mergeLists(Util.newArrayListOfValues(Colour.COVERING_CLEAR), allCoveringColours);

	public static List<Colour> naturalScaleColours = Util.newArrayListOfValues(
			Colour.COVERING_WHITE,
			Colour.COVERING_BROWN,
			Colour.COVERING_TAN,
			Colour.COVERING_BROWN_DARK,
			Colour.COVERING_BLACK,
			Colour.COVERING_JET_BLACK);

	public static List<Colour> hornColours = Util.newArrayListOfValues(
			Colour.HORN_WHITE,
			Colour.HORN_GREY,
			Colour.HORN_DARK_GREY,
			Colour.HORN_BLACK,
			Colour.HORN_JET_BLACK);

	public static List<Colour> dyeHornColours = Util.newArrayListOfValues(
			Colour.HORN_RED,
			Colour.HORN_SCARLET,
			Colour.HORN_BROWN,
			Colour.HORN_DARK_BROWN,
			Colour.HORN_AMBER,
			Colour.HORN_PINK,
			Colour.HORN_GREEN,
			Colour.HORN_BLUE,
			Colour.HORN_LILAC,
			Colour.HORN_PURPLE,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	// Antlers:
	public static List<Colour> antlerColours = Util.newArrayListOfValues(
			Colour.ANTLER_WHITE,
			Colour.ANTLER_TAN,
			Colour.ANTLER_BROWN,
			Colour.ANTLER_DARK_BROWN,
			Colour.ANTLER_GREY,
			Colour.ANTLER_DARK_GREY,
			Colour.ANTLER_BLACK,
			Colour.ANTLER_JET_BLACK);

	public static List<Colour> dyeAntlerColours = Util.newArrayListOfValues(
			Colour.ANTLER_RED,
			Colour.ANTLER_SCARLET,
			Colour.ANTLER_AMBER,
			Colour.ANTLER_PINK,
			Colour.ANTLER_GREEN,
			Colour.ANTLER_BLUE,
			Colour.ANTLER_LILAC,
			Colour.ANTLER_PURPLE,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	// Hair:

	public static List<Colour> naturalHairColours = Util.newArrayListOfValues(
			Colour.COVERING_WHITE,
			Colour.COVERING_BLONDE,
			Colour.COVERING_DIRTY_BLONDE,
			Colour.COVERING_GINGER,
			Colour.COVERING_BROWN,
			Colour.COVERING_BROWN_DARK,
			Colour.COVERING_AUBURN,
			Colour.COVERING_GREY,
			Colour.COVERING_BLACK,
			Colour.COVERING_JET_BLACK);

	// Eyes:

	public static List<Colour> naturalIrisColours = Util.newArrayListOfValues(
			Colour.EYE_BROWN,
			Colour.EYE_AMBER,
			Colour.EYE_HAZEL,
			Colour.EYE_BLUE,
			Colour.EYE_AQUA,
			Colour.EYE_GREEN,
			Colour.EYE_GREY);

	public static List<Colour> dyeIrisColours = Util.newArrayListOfValues(
			Colour.EYE_SILVER,
			Colour.EYE_YELLOW,
			Colour.EYE_GOLD,
			Colour.EYE_RED,
			Colour.EYE_CRIMSON,
			Colour.EYE_ORANGE,
			Colour.EYE_PINK,
			Colour.EYE_PINK_SALMON,
			Colour.EYE_PERIWINKLE,
			Colour.EYE_LILAC,
			Colour.EYE_PURPLE,
			Colour.EYE_VIOLET,
			Colour.EYE_BLACK,
			Colour.EYE_PITCH_BLACK,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	public static List<Colour> naturalDemonIrisColours = Util.newArrayListOfValues(
			Colour.EYE_BROWN,
			Colour.EYE_AMBER,
			Colour.EYE_HAZEL,
			Colour.EYE_BLUE,
			Colour.EYE_AQUA,
			Colour.EYE_GREEN,
			Colour.EYE_GREY,
			Colour.EYE_RED,
			Colour.EYE_CRIMSON,
			Colour.EYE_ORANGE,
			Colour.EYE_YELLOW,
			Colour.EYE_PINK,
			Colour.EYE_PINK_SALMON,
			Colour.EYE_PERIWINKLE,
			Colour.EYE_LILAC,
			Colour.EYE_PURPLE,
			Colour.EYE_VIOLET,
			Colour.EYE_BLACK,
			Colour.EYE_PITCH_BLACK);

	public static List<Colour> dyeDemonIrisColours = Util.newArrayListOfValues(
			Colour.EYE_SILVER,
			Colour.EYE_GOLD,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	public static List<Colour> naturalPredatorIrisColours = Util.newArrayListOfValues(
			Colour.EYE_BROWN,
			Colour.EYE_AMBER,
			Colour.EYE_YELLOW,
			Colour.EYE_BLUE,
			Colour.EYE_AQUA,
			Colour.EYE_GREEN,
			Colour.EYE_GREY);

	public static List<Colour> dyePredatorIrisColours = Util.newArrayListOfValues(
			Colour.EYE_SILVER,
			Colour.EYE_GOLD,
			Colour.EYE_RED,
			Colour.EYE_CRIMSON,
			Colour.EYE_ORANGE,
			Colour.EYE_PINK,
			Colour.EYE_PINK_SALMON,
			Colour.EYE_LILAC,
			Colour.EYE_PURPLE,
			Colour.EYE_VIOLET,
			Colour.EYE_BLACK,
			Colour.EYE_PITCH_BLACK,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	public static List<Colour> naturalPupilColours = Util.newArrayListOfValues(
			Colour.EYE_BLACK);

	public static List<Colour> dyePupilColours = Util.newArrayListOfValues(
			Colour.EYE_WHITE,
			Colour.EYE_SILVER,
			Colour.EYE_BROWN,
			Colour.EYE_BLUE,
			Colour.EYE_AQUA,
			Colour.EYE_GREEN,
			Colour.EYE_GREY,
			Colour.EYE_YELLOW,
			Colour.EYE_GOLD,
			Colour.EYE_RED,
			Colour.EYE_CRIMSON,
			Colour.EYE_ORANGE,
			Colour.EYE_AMBER,
			Colour.EYE_PINK,
			Colour.EYE_PINK_SALMON,
			Colour.EYE_PERIWINKLE,
			Colour.EYE_LILAC,
			Colour.EYE_PURPLE,
			Colour.EYE_VIOLET,
			Colour.EYE_PITCH_BLACK,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	public static List<Colour> naturalScleraColours = Util.newArrayListOfValues(
			Colour.EYE_WHITE);

	public static List<Colour> dyeScleraColours = Util.newArrayListOfValues(
			Colour.EYE_BLACK,
			Colour.EYE_SILVER,
			Colour.EYE_BROWN,
			Colour.EYE_BLUE,
			Colour.EYE_AQUA,
			Colour.EYE_GREEN,
			Colour.EYE_GREY,
			Colour.EYE_YELLOW,
			Colour.EYE_GOLD,
			Colour.EYE_RED,
			Colour.EYE_CRIMSON,
			Colour.EYE_ORANGE,
			Colour.EYE_AMBER,
			Colour.EYE_PINK,
			Colour.EYE_PINK_SALMON,
			Colour.EYE_PERIWINKLE,
			Colour.EYE_LILAC,
			Colour.EYE_PURPLE,
			Colour.EYE_VIOLET,
			Colour.EYE_PITCH_BLACK,
			Colour.COVERING_RAINBOW,
			Colour.COVERING_RAINBOW_PASTEL);

	private Color colour;
	private Color lightColour;
	private boolean metallic;
	private String name;
	private List<String> formattingNames;

	private Colour(boolean metallic, Color colour, Color lightColour, String name) {
		this.metallic = metallic;
		this.colour = colour;
		this.lightColour = lightColour;
		this.name = name;
	}

	private Colour(boolean metallic, BaseColour colour, String name) {
		this.metallic = metallic;
		this.colour = colour.getColour();
		this.lightColour = colour.getLightColour();
		this.name = name;
	}

	// Constructors with formatting names:
	private Colour(boolean metallic, Color colour, Color lightColour, String name, List<String> formattingNames) {
		this.metallic = metallic;
		this.colour = colour;
		this.lightColour = lightColour;
		this.name = name;
		this.formattingNames=formattingNames;
	}

	private Colour(boolean metallic, BaseColour colour, String name, List<String> formattingNames) {
		this.metallic = metallic;
		this.colour = colour.getColour();
		this.lightColour = colour.getLightColour();
		this.name = name;
		this.formattingNames=formattingNames;
	}

	/**
	 * Returns a String in the format RRGGBB
	 *
	 * @return
	 */
	public String toWebHexString() {
		return "#"+getColor().toString().substring(2, 8);
	}

	public Color getColor() {
		if(Main.getProperties()!=null) {
			if(Main.getProperties().hasValue(PropertyValue.lightTheme))
				return lightColour;
			else
				return colour;

		} else {
			return colour;
		}
	}

	public boolean isMetallic() {
		return metallic;
	}

	public List<String> getRainbowColours() {
		return null;
	}

	public boolean isJetBlack() {
		return false;
	}

	public String getName() {
		return name;
	}

	/**
	 * @return An array of length 5, with [0] being darkest, [4] being lightest.
	 */
	public String[] getShades() {
		return getShades(5);
	}

	public String[] getShades(int shadesCount) {
		return getShades(shadesCount, false, 1);
	}

	public String[] getShadesRgbaFormat(float opacity) {
		return getShades(5, true, opacity);
	}

	/**
	 * @param shadesCount Number of shades to calculate.
	 * @return Array of Strings, with each one being in the format:<br/>
	 * {@code rgba(63,107,169, opacity)}
	 */
	public String[] getShadesRgbaFormat(int shadesCount, float opacity) {
		return getShades(shadesCount, true, opacity);
	}

	private String[] getShades(int shadesCount, boolean rgba, float opacity) {
		String[] shadesString = new String[shadesCount];
		float luminosity = -0.5f;
		float increment = (Math.abs(luminosity)*2)/(shadesCount-1);
		int red = Integer.parseInt(colour.toString().substring(2, 4), 16);
		int gre = Integer.parseInt(colour.toString().substring(4, 6), 16);
		int blu = Integer.parseInt(colour.toString().substring(6, 8), 16);
		int r, g, b;

		for (int i = 0; i < shadesCount; i++) {
			r = red + (int)(red * (i * increment + luminosity));
			r = Math.max(Math.min(r, 255), 0);

			g = gre + (int)(gre * (i * increment + luminosity));
			g = Math.max(Math.min(g, 255), 0);

			b = blu + (int)(blu * (i * increment + luminosity));
			b = Math.max(Math.min(b, 255), 0);

			if(rgba) {
				shadesString[i] = "rgba("+r+","+g+","+b+", "+opacity+")";
			} else {
				shadesString[i] = String.format("#%02X%02X%02X", r, g, b);
			}
		}

		return shadesString;
	}

	public List<String> getFormattingNames() {
		return formattingNames;
	}

}


code:
package com.lilithsthrone.utils;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

/**
 * @since 0.2.4
 * @version 0.3.2
 * @author Innoxia
 */
@SuppressWarnings("unchecked")
public class ColourListPresets {

	public static ArrayList<Colour> NONE = new ArrayList<>();

	public static ArrayList<Colour> JUST_WHITE = Util.newArrayListOfValues(
			Colour.CLOTHING_WHITE);

	public static ArrayList<Colour> JUST_BLACK = Util.newArrayListOfValues(
			Colour.CLOTHING_BLACK);

	public static ArrayList<Colour> JUST_DARK_RED = Util.newArrayListOfValues(
			Colour.CLOTHING_RED_DARK);

	public static ArrayList<Colour> JUST_RED = Util.newArrayListOfValues(
			Colour.CLOTHING_RED);

	public static ArrayList<Colour> JUST_TAN = Util.newArrayListOfValues(
			Colour.CLOTHING_TAN);

	public static ArrayList<Colour> JUST_BROWN = Util.newArrayListOfValues(
			Colour.CLOTHING_BROWN);

	public static ArrayList<Colour> JUST_DARK_BROWN = Util.newArrayListOfValues(
			Colour.CLOTHING_BROWN_DARK);

	public static ArrayList<Colour> JUST_ORANGE = Util.newArrayListOfValues(
			Colour.CLOTHING_ORANGE);

	public static ArrayList<Colour> JUST_YELLOW = Util.newArrayListOfValues(
			Colour.CLOTHING_YELLOW);

	public static ArrayList<Colour> JUST_PINK = Util.newArrayListOfValues(
			Colour.CLOTHING_PINK);

	public static ArrayList<Colour> JUST_GREY = Util.newArrayListOfValues(
			Colour.CLOTHING_GREY);

	public static ArrayList<Colour> JUST_GOLD = Util.newArrayListOfValues(
			Colour.CLOTHING_GOLD);

	public static ArrayList<Colour> JUST_ROSE_GOLD = Util.newArrayListOfValues(
			Colour.CLOTHING_ROSE_GOLD);

	public static ArrayList<Colour> JUST_STEEL = Util.newArrayListOfValues(
			Colour.CLOTHING_STEEL);

	public static ArrayList<Colour> JUST_SILVER = Util.newArrayListOfValues(
			Colour.CLOTHING_SILVER);

	public static ArrayList<Colour> JUST_COPPER = Util.newArrayListOfValues(
			Colour.CLOTHING_COPPER);

	public static ArrayList<Colour> BLACK_OR_WHITE = Util.newArrayListOfValues(
			Colour.CLOTHING_BLACK,
			Colour.CLOTHING_WHITE);

	public static ArrayList<Colour> SHADES_OF_GREY = Util.newArrayListOfValues(
			Colour.CLOTHING_BLACK_JET,
			Colour.CLOTHING_BLACK,
			Colour.CLOTHING_GREY_DARK,
			Colour.CLOTHING_GREY,
			Colour.CLOTHING_WHITE);

	public static ArrayList<Colour> DARK_SHADES = Util.newArrayListOfValues(
			Colour.CLOTHING_GREY,
			Colour.CLOTHING_GREY_DARK,
			Colour.CLOTHING_BLACK,
			Colour.CLOTHING_BLACK_JET,
			Colour.CLOTHING_BROWN_VERY_DARK,
			Colour.CLOTHING_RED_VERY_DARK,
			Colour.CLOTHING_GREEN_VERY_DARK,
			Colour.CLOTHING_BLUE_VERY_DARK);

	public static ArrayList<Colour> DENIM = Util.newArrayListOfValues(
			Colour.CLOTHING_BLUE_GREY,
			Colour.CLOTHING_BLUE_NAVY,
			Colour.CLOTHING_PINK_LIGHT,
			Colour.CLOTHING_DESATURATED_BROWN,
			Colour.CLOTHING_WHITE,
			Colour.CLOTHING_GREY,
			Colour.CLOTHING_BLACK);

	public static ArrayList<Colour> KIMONO = Util.newArrayListOfValues(
			Colour.CLOTHING_BLUE_LIGHT,
			Colour.CLOTHING_PINK_LIGHT,
			Colour.CLOTHING_PINK,
			Colour.CLOTHING_PURPLE,
			Colour.CLOTHING_PURPLE_LIGHT,
			Colour.CLOTHING_RED,
			Colour.CLOTHING_TURQUOISE,
			Colour.CLOTHING_WHITE,
			Colour.CLOTHING_YELLOW);

	public static ArrayList<Colour> MAID = Util.newArrayListOfValues(
			Colour.CLOTHING_PINK_LIGHT,
			Colour.CLOTHING_PINK,
			Colour.CLOTHING_BLACK);

	public static ArrayList<Colour> MILK_MAID = Util.newArrayListOfValues(
			Colour.CLOTHING_PINK_LIGHT,
			Colour.CLOTHING_BLUE_LIGHT,
			Colour.CLOTHING_PURPLE_LIGHT,
			Colour.CLOTHING_GREEN,
			Colour.CLOTHING_TAN,
			Colour.CLOTHING_KHAKI,
			Colour.CLOTHING_BROWN,
			Colour.CLOTHING_BLACK);

	public static ArrayList<Colour> LEATHER = Util.newArrayListOfValues(
			Colour.CLOTHING_WHITE,
			Colour.CLOTHING_BLACK,
			Colour.CLOTHING_BLACK_JET,
			Colour.CLOTHING_GREY,
			Colour.CLOTHING_DESATURATED_BROWN,
			Colour.CLOTHING_BROWN,
			Colour.CLOTHING_BROWN_DARK,
			Colour.CLOTHING_BROWN_VERY_DARK,
			Colour.CLOTHING_TAN,
			Colour.CLOTHING_KHAKI);

	public static ArrayList<Colour> LINGERIE = Util.newArrayListOfValues(
			Colour.CLOTHING_WHITE,
			Colour.CLOTHING_GREY_LIGHT,
			Colour.CLOTHING_GREY,
			Colour.CLOTHING_GREY_DARK,
			Colour.CLOTHING_BLACK,
			Colour.CLOTHING_BLACK_JET,
			Colour.CLOTHING_RED_VERY_DARK,
			Colour.CLOTHING_RED_DARK,
			Colour.CLOTHING_RED,
			Colour.CLOTHING_RED_BRIGHT,
			Colour.CLOTHING_ORANGE,
			Colour.CLOTHING_ORANGE_BRIGHT,
			Colour.CLOTHING_ORANGE_DARK,
			Colour.CLOTHING_BROWN,
			Colour.CLOTHING_BROWN_DARK,
			Colour.CLOTHING_BROWN_VERY_DARK,
			Colour.CLOTHING_TAN,
			Colour.CLOTHING_KHAKI,
			Colour.CLOTHING_OLIVE,
			Colour.CLOTHING_YELLOW,
			Colour.CLOTHING_YELLOW_DARK,
			Colour.CLOTHING_GREEN_LIME,
			Colour.CLOTHING_GREEN,
			Colour.CLOTHING_GREEN_DRAB,
			Colour.CLOTHING_GREEN_DARK,
			Colour.CLOTHING_GREEN_VERY_DARK,
			Colour.CLOTHING_TURQUOISE,
			Colour.CLOTHING_BLUE_LIGHT,
			Colour.CLOTHING_BLUE,
			Colour.CLOTHING_BLUE_GREY,
			Colour.CLOTHING_BLUE_NAVY,
			Colour.CLOTHING_BLUE_DARK,
			Colour.CLOTHING_BLUE_VERY_DARK,
			Colour.CLOTHING_PURPLE_VERY_DARK,
			Colour.CLOTHING_PURPLE_DARK,
			Colour.CLOTHING_PURPLE,
			Colour.CLOTHING_PURPLE_LIGHT,
			Colour.CLOTHING_PERIWINKLE,
			Colour.CLOTHING_PINK_LIGHT,
			Colour.CLOTHING_PINK,
			Colour.CLOTHING_PINK_HOT,
			Colour.CLOTHING_PINK_DARK);

	public static ArrayList<Colour> ALL_METAL = Util.newArrayListOfValues(
			Colour.CLOTHING_BLACK_STEEL,
			Colour.CLOTHING_GUNMETAL,
			Colour.CLOTHING_STEEL,
			Colour.CLOTHING_BRASS,
			Colour.CLOTHING_COPPER,
			Colour.CLOTHING_SILVER,
			Colour.CLOTHING_ROSE_GOLD,
			Colour.CLOTHING_GOLD,
			Colour.CLOTHING_PLATINUM);

	public static ArrayList<Colour> ALL = Util.newArrayListOfValues(
			Colour.CLOTHING_WHITE,
			Colour.CLOTHING_GREY_LIGHT,
			Colour.CLOTHING_GREY,
			Colour.CLOTHING_GREY_DARK,
			Colour.CLOTHING_BLACK,
			Colour.CLOTHING_BLACK_JET,
			Colour.CLOTHING_RED_VERY_DARK,
			Colour.CLOTHING_RED_DARK,
			Colour.CLOTHING_RED,
			Colour.CLOTHING_RED_BRIGHT,
			Colour.CLOTHING_ORANGE,
			Colour.CLOTHING_ORANGE_BRIGHT,
			Colour.CLOTHING_ORANGE_DARK,
			Colour.CLOTHING_DESATURATED_BROWN,
			Colour.CLOTHING_BROWN,
			Colour.CLOTHING_BROWN_DARK,
			Colour.CLOTHING_BROWN_VERY_DARK,
			Colour.CLOTHING_TAN,
			Colour.CLOTHING_KHAKI,
			Colour.CLOTHING_OLIVE,
			Colour.CLOTHING_YELLOW,
			Colour.CLOTHING_YELLOW_DARK,
			Colour.CLOTHING_GREEN_LIME,
			Colour.CLOTHING_GREEN,
			Colour.CLOTHING_GREEN_DRAB,
			Colour.CLOTHING_GREEN_DARK,
			Colour.CLOTHING_GREEN_VERY_DARK,
			Colour.CLOTHING_TURQUOISE,
			Colour.CLOTHING_BLUE_LIGHT,
			Colour.CLOTHING_BLUE,
			Colour.CLOTHING_BLUE_GREY,
			Colour.CLOTHING_BLUE_NAVY,
			Colour.CLOTHING_BLUE_DARK,
			Colour.CLOTHING_BLUE_VERY_DARK,
			Colour.CLOTHING_PURPLE_VERY_DARK,
			Colour.CLOTHING_PURPLE_DARK,
			Colour.CLOTHING_PURPLE,
			Colour.CLOTHING_PURPLE_LIGHT,
			Colour.CLOTHING_PERIWINKLE,
			Colour.CLOTHING_PINK_LIGHT,
			Colour.CLOTHING_PINK,
			Colour.CLOTHING_PINK_HOT,
			Colour.CLOTHING_PINK_DARK);

	public static ArrayList<Colour> ALL_WITH_METALS = Util.newArrayListOfValues(
			Colour.CLOTHING_WHITE,
			Colour.CLOTHING_GREY_LIGHT,
			Colour.CLOTHING_GREY,
			Colour.CLOTHING_GREY_DARK,
			Colour.CLOTHING_BLACK,
			Colour.CLOTHING_BLACK_JET,
			Colour.CLOTHING_RED_VERY_DARK,
			Colour.CLOTHING_RED_DARK,
			Colour.CLOTHING_RED,
			Colour.CLOTHING_RED_BRIGHT,
			Colour.CLOTHING_ORANGE,
			Colour.CLOTHING_ORANGE_BRIGHT,
			Colour.CLOTHING_ORANGE_DARK,
			Colour.CLOTHING_DESATURATED_BROWN,
			Colour.CLOTHING_BROWN,
			Colour.CLOTHING_BROWN_DARK,
			Colour.CLOTHING_BROWN_VERY_DARK,
			Colour.CLOTHING_TAN,
			Colour.CLOTHING_KHAKI,
			Colour.CLOTHING_OLIVE,
			Colour.CLOTHING_YELLOW_DARK,
			Colour.CLOTHING_YELLOW,
			Colour.CLOTHING_GREEN_LIME,
			Colour.CLOTHING_GREEN,
			Colour.CLOTHING_GREEN_DRAB,
			Colour.CLOTHING_GREEN_DARK,
			Colour.CLOTHING_GREEN_VERY_DARK,
			Colour.CLOTHING_TURQUOISE,
			Colour.CLOTHING_BLUE_LIGHT,
			Colour.CLOTHING_BLUE,
			Colour.CLOTHING_BLUE_GREY,
			Colour.CLOTHING_BLUE_NAVY,
			Colour.CLOTHING_BLUE_DARK,
			Colour.CLOTHING_BLUE_VERY_DARK,
			Colour.CLOTHING_PURPLE_VERY_DARK,
			Colour.CLOTHING_PURPLE_DARK,
			Colour.CLOTHING_PURPLE,
			Colour.CLOTHING_PURPLE_LIGHT,
			Colour.CLOTHING_PERIWINKLE,
			Colour.CLOTHING_PINK_LIGHT,
			Colour.CLOTHING_PINK,
			Colour.CLOTHING_PINK_HOT,
			Colour.CLOTHING_PINK_DARK,
			Colour.CLOTHING_BLACK_STEEL,
			Colour.CLOTHING_GUNMETAL,
			Colour.CLOTHING_STEEL,
			Colour.CLOTHING_BRASS,
			Colour.CLOTHING_COPPER,
			Colour.CLOTHING_SILVER,
			Colour.CLOTHING_ROSE_GOLD,
			Colour.CLOTHING_GOLD,
			Colour.CLOTHING_PLATINUM);

	public static ArrayList<Colour> NOT_WHITE = new ArrayList<>(ALL);

	public static ArrayList<Colour> NOT_BLACK = new ArrayList<>(ALL);

	static {
		NOT_WHITE.remove(Colour.CLOTHING_WHITE);
		NOT_BLACK.remove(Colour.CLOTHING_BLACK);
		NOT_BLACK.remove(Colour.CLOTHING_BLACK_JET);
	}

	private static Map<String, ArrayList<Colour>> idToColourListMap = new HashMap<>();

	public static Map<String, ArrayList<Colour>> getIdToColourListMap() {
		return idToColourListMap;
	}

	public static ArrayList<Colour> getColourListFromId(String id) {
		// Fix inconsistent naming:
		if(id.equals("ALL_METALS")) {
			id = "ALL_METAL";
		} else if(id.equals("ALL_WITH_METAL")) {
			id = "ALL_WITH_METALS";
		}

		id = Util.getClosestStringMatch(id, idToColourListMap.keySet());
		return idToColourListMap.get(id);
	}

	static {
		Field[] fields = ColourListPresets.class.getFields();

		for(Field f : fields){

			if (ArrayList.class.isAssignableFrom(f.getType())) {

				ArrayList<Colour> ct;
				try {
					ct = ((ArrayList<Colour>) f.get(null));

					idToColourListMap.put(f.getName(), ct);

				} catch (IllegalArgumentException | IllegalAccessException e) {
					e.printStackTrace();
				}

			}
		}
	}
}

repo_name: klorpa/Pedo

license: unknown


code:
package com.lilithsthrone.utils;

import com.lilithsthrone.game.character.race.Subspecies;

/**
 * @since 0.1.82
 * @version 0.3.3
 * @author Innoxia
 */
public class CreditsSlot {

	private String name;
	private String tagLine;

	private int uncommonCount;
	private int rareCount;
	private int epicCount;
	private int legendaryCount;

	private Subspecies subspeciesTier;

	public CreditsSlot(String name, String tagLine, int uncommonCount, int rareCount, int epicCount, int legendaryCount) {
		this.name = name;
		this.tagLine = tagLine;
		this.uncommonCount = uncommonCount;
		this.rareCount = rareCount;
		this.epicCount = epicCount;
		this.legendaryCount = legendaryCount;
	}

	public CreditsSlot(String name, String tagLine, int uncommonCount, int rareCount, int epicCount, int legendaryCount, Subspecies subspeciesTier) {
		this(name, tagLine, uncommonCount, rareCount, epicCount, legendaryCount);
		this.subspeciesTier = subspeciesTier;
	}

	public String getName() {
		return name;
	}

	public String getTagLine() {
		return tagLine;
	}

	public int getUncommonCount() {
		return uncommonCount;
	}

	public int getRareCount() {
		return rareCount;
	}

	public int getEpicCount() {
		return epicCount;
	}

	public int getLegendaryCount() {
		return legendaryCount;
	}

	public Subspecies getSubspeciesTier() {
		return subspeciesTier;
	}

}


code:
package com.lilithsthrone.utils;

/**
 * @since 0.1.0
 * @version 0.1.0
 * @author Innoxia
 */
public class Node {
	private Node parent;
	// f = g + h
	// g = the movement cost to move from the starting point A to this node,
	// following the path generated to get there.
	// h = the estimated movement cost to move from this node to the final
	// destination. This is often referred to as the heuristic, because it is a
	// guess.
	private int f, g, h, x, y;

	public Node(Node parent, int x, int y, int f, int g, int h) {
		this.parent = parent;
		this.x = x;
		this.y = y;
		this.f = f;
		this.g = g;
		this.h = h;
	}

	public Node getParent() {
		return parent;
	}

	public void setParent(Node parent) {
		this.parent = parent;
	}

	public int getF() {
		return f;
	}

	public void setF() {
		f = g + h;
	}

	public int getG() {
		return g;
	}

	public void setG(int g) {
		this.g = g;
	}

	public int getH() {
		return h;
	}

	public void setH(int h) {
		this.h = h;
	}

	public int getX() {
		return x;
	}

	public void setX(int x) {
		this.x = x;
	}

	public int getY() {
		return y;
	}

	public void setY(int y) {
		this.y = y;
	}
}


code:
package com.lilithsthrone.utils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;

import com.lilithsthrone.game.character.GameCharacter;
import com.lilithsthrone.game.character.effects.AbstractPerk;
import com.lilithsthrone.game.character.effects.PerkCategory;
import com.lilithsthrone.game.character.effects.PerkManager;
import com.lilithsthrone.game.character.effects.TreeEntry;
import com.lilithsthrone.game.dialogue.DialogueNode;
import com.lilithsthrone.game.dialogue.responses.Response;
import com.lilithsthrone.game.dialogue.utils.MapTravelType;
import com.lilithsthrone.main.Main;
import com.lilithsthrone.world.Cell;
import com.lilithsthrone.world.WorldType;
import com.lilithsthrone.world.places.PlaceType;

/**
 * I had plans to add pathing into the game at one stage of development.
 * Although it's not used at the moment, I think this will be useful later on.
 *
 * It was useful later on.
 *
 * @since 0.1.0
 * @version 0.3.5
 * @author Innoxia
 */
public class Pathing {

	private static List<Cell> pathingCells = new ArrayList<>();
	private static Vector2i endPoint = new Vector2i(0, 0);
	private static WorldType destinationWorld = WorldType.DOMINION;

	private static int travelTime = 0;
	private static int dangerousTiles = 0;

	private static boolean impossibleDestination = true;

	private static MapTravelType mapTravelType = MapTravelType.WALK_SAFE;

	public Pathing() {
	}

	public static List<Cell> aStarPathing(Cell[][] grid, Vector2i start, Vector2i end, boolean preferSafe) {
		return aStarPathing(grid, start.getX(), start.getY(), end.getX(), end.getY(), preferSafe);
	}

	public static List<Cell> aStarPathing(Cell[][] grid, Vector2i start, int endX, int endY, boolean preferSafe) {
		return aStarPathing(grid, start.getX(), start.getY(), endX, endY, preferSafe);
	}

	// Implemented using http://www.policyalmanac.org/games/aStarTutorial.htm
	public static List<Cell> aStarPathing(Cell[][] grid, int startX, int startY, int endX, int endY, boolean preferSafe) {
		/*
		 * 1) Add the starting square (or node) to the open list.
		 *
		 * 2) Repeat the following:
		 *
		 * a) Look for the lowest F cost square on the open list. We refer to
		 * this as the current square.
		 *
		 * b) Switch it to the closed list.
		 *
		 * c) For each of the 8 squares adjacent to this current square �
		 *
		 * i) If it is not walkable or if it is on the closed list, ignore it.
		 * Otherwise do the following.
		 *
		 * ii) If it isn't on the open list, add it to the open list. Make the
		 * current square the parent of this square. Record the F, G, and H
		 * costs of the square.
		 *
		 * iii) If it is on the open list already, check to see if this path to
		 * that square is better, using G cost as the measure. A lower G cost
		 * means that this is a better path. If so, change the parent of the
		 * square to the current square, and recalculate the G and F scores of
		 * the square. If you are keeping your open list sorted by F score, you
		 * may need to resort the list to account for the change.
		 *
		 * d) Stop when you:
		 *
		 * i) Add the target square to the closed list, in which case the path
		 * has been found (see note below), or ii) Fail to find the target
		 * square, and the open list is empty. In this case, there is no path.
		 *
		 * 3) Save the path. Working backwards from the target square, go from
		 * each square to its parent square until you reach the starting square.
		 * That is your path.
		 */
		List<Cell> path = new ArrayList<>();
		impossibleDestination = true;

		Node[][] nodeArray = new Node[grid.length][grid[0].length];
		for (int i = 0; i < grid.length; i++) {
			for (int j = 0; j < grid[0].length; j++) {
				nodeArray[i][j] = new Node(null, i, j, 0, 0, 0);
			}
		}

		Queue<Node> openList = new PriorityQueue<>(10, new Comparator<Node>() {
			@Override
			// Sort by F value
			public int compare(Node o1, Node o2) {
				return o1.getF() - o2.getF();
			}
		});
		List<Node> closedList = new ArrayList<>();

		// 1)
		openList.add(nodeArray[startX][startY]);

		Node n;
		// 2) d) ii)
		while (!openList.isEmpty()) {
			// 2) a) Priority queue always gives the lowest F cost square
			n = openList.poll();

			// 2) b)
			closedList.add(n);

			// 2) d) i)
			if (n.getX() == endX && n.getY() == endY) {
				impossibleDestination = false;
				break;
			}

			// 2) c)
			for (int i = -1; i <= 1; i++) {
				for (int j = -1; j <= 1; j++) {
					if (!(i == 0 && j == 0) // Do not calculate the current tile
							// Make sure we don't go out of bounds:
							&& n.getX() + i >= 0
							&& n.getX() + i < grid.length
							&& n.getY() + j >= 0
							&& n.getY() + j < grid[0].length) {
						if (!closedList.contains(nodeArray[n.getX() + i][n.getY() + j])) { // c) i)
							// Deny diagonals unless in main world map
							Cell c = grid[n.getX() + i][n.getY() + j];

							int time = Main.game.getModifierTravelTime(c.getPlace().getPlaceType().isLand(), (c.getPlace().getPlaceType().getDialogue(false)!=null? c.getPlace().getPlaceType().getDialogue(false).getSecondsPassed() : 10000));

							int g = ((i == 0 || j == 0) ? 10 : c.getType().equals(WorldType.WORLD_MAP)?12:1_000_000)
									+ time
									+ (c.getPlace().getPlaceType().equals(PlaceType.GENERIC_IMPASSABLE)?100_000_000:0)
									+ (preferSafe && c.getPlace().getPlaceType()!=null && c.getPlace().getPlaceType().isDangerous()?100_000:0);

							if (!openList.contains(nodeArray[n.getX() + i][n.getY() + j])) { // c) ii)
								nodeArray[n.getX() + i][n.getY() + j].setParent(n);
								nodeArray[n.getX() + i][n.getY() + j].setG(n.getG() + g);
//								if (heuristic) {
									nodeArray[n.getX() + i][n.getY() + j].setH(Math.abs((n.getX() + i) - endX) + Math.abs((n.getX() + j) - endY)); // Manhattan distance
//								} else {
//									nodeArray[n.getX() + i][n.getY() + j].setH(0);
//								}
								nodeArray[n.getX() + i][n.getY() + j].setF();

								openList.add(nodeArray[n.getX() + i][n.getY() + j]);

							} else { // c) iii)
								if ((n.getG() + g) < nodeArray[n.getX() + i][n.getY() + j].getG()) {
									openList.remove(nodeArray[n.getX() + i][n.getY() + j]);

									nodeArray[n.getX() + i][n.getY() + j].setParent(n);
									nodeArray[n.getX() + i][n.getY() + j].setG(n.getG() + g);
									nodeArray[n.getX() + i][n.getY() + j].setF();

									openList.add(nodeArray[n.getX() + i][n.getY() + j]);
								}
							}
						}
					}
				}
			}
		}

		// 3)
		n = nodeArray[endX][endY];
		while (n.getParent() != null) {
			path.add(grid[n.getX()][n.getY()]);
			n = n.getParent();
		}
		Collections.reverse(path);
		return path;
	}

	public static Response walkPath(MapTravelType travelType) {
		int totalTimePassed = 0;
		for(Cell c : getPathingCells()) {
			Main.game.getPlayer().setLocation(c.getType(), c.getLocation(), false);
			DialogueNode dialogue = c.getPlace().getDialogue(true);

			if(dialogue!=null) {
				totalTimePassed += Main.game.getModifierTravelTime(c.getPlace().getPlaceType().isLand(), dialogue.getSecondsPassed());
//				c.setDiscovered(true);
//				c.setTravelledTo(true);

//				Main.game.endTurn(null, dialogue);

				if(dialogue.isTravelDisabled()) {
					int time = totalTimePassed;
					Main.game.getPlayer().setLocation(c.getType(), c.getLocation(), false);
					return new Response("", "", dialogue) {
						@Override
						public int getSecondsPassed() {
							return time;
						}
						@Override
						public void effects() {
							Main.game.getTextStartStringBuilder().append(
									"
"
											+ "[style.italicsBad(Your travel was interrupted!)]"
									+ "
");
						}
					};
				}

				if(totalTimePassed>=2*60*60) { // Every 2 hours, perform an end turn. I didn't encounter any lag when just ending the turn on every tile moved, but I'm sure it could lag when moving huge distances.
					Main.game.endTurn(totalTimePassed);
					totalTimePassed = 0;
				}
			}
		}

		// Return destination:
		Cell destination = getPathingCells().get(getPathingCells().size()-1);
		Main.game.getPlayer().setLocation(destination.getType(), destination.getLocation(), false);

		Main.game.endTurn(totalTimePassed);

		return new Response("", "", destination.getPlace().getDialogue(false));
	}

	public static void initPathingVariables() {
		if(!getMapTravelType().isAvailable(null, Main.game.getPlayer())) {
			setMapTravelType(MapTravelType.WALK_SAFE);
		}
		setPathingCells(new ArrayList<>(), new Vector2i(-1, -1));//new Vector2i(Main.game.getPlayer().getLocation()));
		destinationWorld = Main.game.getPlayer().getWorldLocation();
	}

	public static List<Cell> getPathingCells() {
		return pathingCells;
	}

	public static void setPathingCells(List<Cell> pathingCells, Vector2i endPoint) {
		Pathing.pathingCells = pathingCells;
		Pathing.endPoint = endPoint;
		travelTime = calculateTravelTime(Pathing.pathingCells, true);
		dangerousTiles = calculateDangerousTiles(Pathing.pathingCells);
	}

	public static void appendPathingCells(List<Cell> pathingCells, Vector2i endPoint) {
		Pathing.pathingCells.addAll(pathingCells);
		Pathing.endPoint = endPoint;
		travelTime = calculateTravelTime(Pathing.pathingCells, true);
		dangerousTiles = calculateDangerousTiles(Pathing.pathingCells);
	}

	public static Vector2i getEndPoint() {
		return endPoint;
	}

	private static int calculateTravelTime(List<Cell> cellRoute, boolean withModifiedTravelTime) {
		int seconds = 0;
		for(Cell c : cellRoute) {
			DialogueNode dialogue = c.getPlace().getDialogue(false);
			if(dialogue!=null) {
				if(withModifiedTravelTime) {
					seconds += Main.game.getModifierTravelTime(c.getPlace().getPlaceType().isLand(), dialogue.getSecondsPassed());
				} else {
					seconds += dialogue.getSecondsPassed();
				}
			}
		}
		return seconds;
	}

	private static int calculateDangerousTiles(List<Cell> cellRoute) {
		int dangerous = 0;
		for(Cell c : cellRoute) {
			if(c.getPlace().getPlaceType().isDangerous()) {
				dangerous++;
			}
		}
		return dangerous;
	}

	/**
	 * @param endPoint New endPoint.
	 * @param worldForRecalculatingFlyTime Pass in null if you don't want to recalculate the flight time.
	 */
	public static void setEndPoint(Vector2i endPoint, Cell cell, WorldType worldForRecalculatingFlyTime) {
		Pathing.endPoint = endPoint;
		if(worldForRecalculatingFlyTime!=null) {
			List<Cell> route = Pathing.aStarPathing(Main.game.getWorlds().get(worldForRecalculatingFlyTime).getCellGrid(), Main.game.getPlayer().getLocation(), endPoint, false);
			travelTime = calculateTravelTime(route, false)/10; // flying is 10 times faster than walking
		}
		dangerousTiles = cell.getPlace().getPlaceType().isDangerous()?1:0;
		destinationWorld = cell.getType();
	}

	public static MapTravelType getMapTravelType() {
		return mapTravelType;
	}

	public static void setMapTravelType(MapTravelType mapTravelType) {
		Pathing.mapTravelType = mapTravelType;
	}

	/**
	 * Automatically calculated when calling setPathingCells() and appendPathingCells().
	 * @return How many tiles on the path are considered dangerous (chance of bad encounter).
	 */
	public static int getDangerousTilesCrossed() {
		return dangerousTiles;
	}

	/**
	 * Automatically calculated when calling setPathingCells() and appendPathingCells().
	 * @return How long it will take the character to travel down the calculated path.
	 */
	public static int getTravelTime() {
		return travelTime;
	}

	public static WorldType getDestinationWorld() {
		return destinationWorld;
	}

	/**
	 * @return true if the last calculated aStarPathing did not reach its destination.
	 */
	public static boolean isImpossibleDestination() {
		return impossibleDestination;
	}

	public static List<TreeEntry<PerkCategory, AbstractPerk>> aStarPathingPerkTree(GameCharacter character, TreeEntry<PerkCategory, AbstractPerk> destination) {
		List<TreeEntry<PerkCategory, AbstractPerk>> startingPerks = PerkManager.getStartingPerks(character);

		// Set starting point to the same category as the destination, if available:
		TreeEntry<PerkCategory, AbstractPerk> start = startingPerks.get(0);
		for(TreeEntry<PerkCategory, AbstractPerk> perk : startingPerks) {
			if(perk.getCategory()==destination.getCategory()) {
				start = perk;
			}
		}

		return  aStarPathingPerkTree(
						PerkManager.MANAGER.getPerkTree(character),
						start,
						destination);
	}

	public static List<TreeEntry<PerkCategory, AbstractPerk>> aStarPathingPerkTree(
			Map<Integer, Map<PerkCategory, List<TreeEntry<PerkCategory, AbstractPerk>>>> perkTree,
			TreeEntry<PerkCategory, AbstractPerk> start,
			TreeEntry<PerkCategory, AbstractPerk> destination) {

		List<TreeEntry<PerkCategory, AbstractPerk>> perkList = new ArrayList<>();

		for(Map<PerkCategory, List<TreeEntry<PerkCategory, AbstractPerk>>> entry1 : perkTree.values()) {
			for(List<TreeEntry<PerkCategory, AbstractPerk>> entry2 : entry1.values()) {
				for(TreeEntry<PerkCategory, AbstractPerk> entry3 : entry2) {
					if(entry3.getRow()>0) {
						perkList.add(entry3);
					}
				}
			}
		}

		List<TreeEntry<PerkCategory, AbstractPerk>> path = new ArrayList<>();

		List<PerkNode> nodeArray = new ArrayList<>();
		PerkNode startNode = null;
		for (int i = 0; i < perkList.size(); i++) {
			PerkNode createdNode = new PerkNode(null, perkList.get(i), 0, 0, 0);
			if(perkList.get(i).equals(start)) {
				startNode = createdNode;
			}
			nodeArray.add(createdNode);
//			System.out.println("Added:: "+perkList.get(i).getEntry().getName(null));
		}

		Queue<PerkNode> openList = new PriorityQueue<>(10, new Comparator<PerkNode>() {
			@Override
			// Sort by F value
			public int compare(PerkNode o1, PerkNode o2) {
				return o1.getF() - o2.getF();
			}
		});
		List<PerkNode> closedList = new ArrayList<>();

		// 1)
		openList.add(startNode);//nodeArray.get(0));

		PerkNode n = null;
		PerkNode destinationNode = null;
		// 2) d) ii)
		while (!openList.isEmpty()) {
			// 2) a) Priority queue always gives the lowest F cost square
			n = openList.poll();

			// 2) b)
			closedList.add(n);

			// 2) d) i)
//			if (n.getPerkTreeEntry().equals(destination)) {
			if(n.getPerkTreeEntry().equals(destination)) {
				destinationNode = n;
				break;
			}

			// 2) c)
			for(TreeEntry<PerkCategory, AbstractPerk> link : Util.mergeLists(n.getPerkTreeEntry().getSiblingLinks(), n.getPerkTreeEntry().getChildLinks())) {
				boolean containsLink = false;
				PerkNode closedNode = null;
				for(PerkNode node : closedList) {
					if(node.getPerkTreeEntry().equals(link)) {
						containsLink = true;
						break;
					}
				}
				for(PerkNode node : nodeArray) {
					if(node.getPerkTreeEntry().equals(link)) {
						closedNode = node;
						break;
					}
				}
//				if(closedNode!=null) {
				if(!containsLink) { // c) i)
					int g = 1;

					if (!openList.contains(closedNode)) { // c) ii)
						closedNode.setParent(n);
						closedNode.setG(n.getG() + g);
						closedNode.setH(1); //0?
						closedNode.setF();

						openList.add(closedNode);

					} else { // c) iii)
						if ((n.getG() + g) < closedNode.getG()) {
							openList.remove(closedNode);

							closedNode.setParent(n);
							closedNode.setG(n.getG() + g);
							closedNode.setF();

							openList.add(closedNode);
						}
					}
				}
//				}
			}
		}

		// 3)
		n = destinationNode;
		path.add(n.getPerkTreeEntry());
		while(n.getParent() != null) {
			path.add(n.getParent().getPerkTreeEntry());
			n = n.getParent();
		}
		Collections.reverse(path);

//		for(TreeEntry<PerkCategory, AbstractPerk> link : path) {
//			System.out.println(link.getEntry().getName(null)+", "+link.getRow()+", "+link.getCategory());
//		}
		return path;
	}
}


code:
package com.lilithsthrone.utils;

import com.lilithsthrone.game.character.effects.AbstractPerk;
import com.lilithsthrone.game.character.effects.PerkCategory;
import com.lilithsthrone.game.character.effects.TreeEntry;

/**
 * @since 0.3.4
 * @version 0.3.4
 * @author Innoxia
 */
public class PerkNode {
	private PerkNode parent;
	// f = g + h
	// g = the movement cost to move from the starting point A to this node,
	// following the path generated to get there.
	// h = the estimated movement cost to move from this node to the final
	// destination. This is often referred to as the heuristic, because it is a
	// guess.
	private TreeEntry<PerkCategory, AbstractPerk> perkTreeEntry;
	private int f, g, h;

	public PerkNode(PerkNode parent, TreeEntry<PerkCategory, AbstractPerk> perkTreeEntry, int f, int g, int h) {
		this.parent = parent;
		this.perkTreeEntry = new TreeEntry<PerkCategory, AbstractPerk>(perkTreeEntry.getCategory(), perkTreeEntry.getRow(), perkTreeEntry.getEntry());
		this.perkTreeEntry.setLinks(perkTreeEntry.getLinks());
		this.f = f;
		this.g = g;
		this.h = h;
	}

	public PerkNode getParent() {
		return parent;
	}

	public void setParent(PerkNode parent) {
		this.parent = parent;
	}

	public int getF() {
		return f;
	}

	public void setF() {
		f = g + h;
	}

	public int getG() {
		return g;
	}

	public void setG(int g) {
		this.g = g;
	}

	public int getH() {
		return h;
	}

	public void setH(int h) {
		this.h = h;
	}

	public TreeEntry<PerkCategory, AbstractPerk> getPerkTreeEntry() {
		return perkTreeEntry;
	}

	public void setPerkTreeEntry(TreeEntry<PerkCategory, AbstractPerk> perkTreeEntry) {
		this.perkTreeEntry = perkTreeEntry;
	}
}


code:
package com.lilithsthrone.utils;

/**
 * @since 0.1.69
 * @version 0.1.69
 * @author Innoxia
 */
public class ResponseAvailableData {

	public boolean available;
	public String tooltipText;
	public float corruptionIncrease;

	public ResponseAvailableData(boolean available, String tooltipText, float corruptionIncrease) {
		this.available = available;
		this.tooltipText = tooltipText;
		this.corruptionIncrease = corruptionIncrease;
	}

}


code:
package com.lilithsthrone.utils;

import java.util.Comparator;

import com.lilithsthrone.game.inventory.clothing.AbstractClothing;

/**
 * Compares by zLayer.
 *
 * @since 0.1.0
 * @version 0.1.0
 * @author Innoxia
 */
public class ReverseClothingZLayerComparator implements Comparator<AbstractClothing> {
	@Override
	public int compare(AbstractClothing o1, AbstractClothing o2) {
		if (o2.getClothingType().getzLayer() < o1.getClothingType().getzLayer())
			return 1;
		else if (o2.getClothingType().getzLayer() == o1.getClothingType().getzLayer())
			return 0;
		else
			return -1;
	}
}


code:
package com.lilithsthrone.utils;

import java.util.Stack;

/**
 * @since 0.2.?
 * @version 0.3.1
 * @author Innoxia
 */
public class SizedStack<T> extends Stack<T> {
	private static final long serialVersionUID = 1L;

	private int maxSize;

	public SizedStack(int maxSize) {
		super();
		this.maxSize = maxSize;
	}

	public int getMaxSize() {
		return maxSize;
	}

	@Override
	public T push(T object) {
		// If the stack is too big, remove elements until it's the right size.
		while (this.size() >= maxSize) {
			this.remove(0);
		}
		return super.push(object);
	}
}


code:
package com.lilithsthrone.utils;

/**
 * Put any static util methods related to .svg files in here.
 *
 * @since 0.2.12
 * @version 0.2.12
 * @author Innoxia
 */
public class SvgUtil {

	public static String colourReplacementPattern(String gradientReplacementID, Colour colour, Colour colourSecondary, Colour colourTertiary, String inputString) {
		String s = inputString;

		s = s.replaceAll("linearGradient\\d|innoGrad\\d|radialGradient\\d",
				gradientReplacementID + colour.toString() + (colourSecondary!=null?colourSecondary.toString():"") + (colourTertiary!=null?colourTertiary.toString():"") + "$0");

		s = sanitizeImageString(s, false);

		if(colour!=null) {
			s = s.replaceAll("#f4d7d7", colour.getShades()[0]);
			s = s.replaceAll("#e9afaf", colour.getShades()[1]);
			s = s.replaceAll("#de8787", colour.getShades()[2]);
			s = s.replaceAll("#d35f5f", colour.getShades()[3]);
			s = s.replaceAll("#c83737", colour.getShades()[4]);
		}

		if(colourSecondary!=null) {
			s = s.replaceAll("#f4e3d7", colourSecondary.getShades()[0]);
			s = s.replaceAll("#e9c6af", colourSecondary.getShades()[1]);
			s = s.replaceAll("#deaa87", colourSecondary.getShades()[2]);
			s = s.replaceAll("#d38d5f", colourSecondary.getShades()[3]);
			s = s.replaceAll("#c87137", colourSecondary.getShades()[4]);
		}

		if(colourTertiary!=null) {
			s = s.replaceAll("#f4eed7", colourTertiary.getShades()[0]);
			s = s.replaceAll("#e9ddaf", colourTertiary.getShades()[1]);
			s = s.replaceAll("#decd87", colourTertiary.getShades()[2]);
			s = s.replaceAll("#d3bc5f", colourTertiary.getShades()[3]);
			s = s.replaceAll("#c8ab37", colourTertiary.getShades()[4]);
		}

		return s;
	}

	public static String colourReplacement(String gradientReplacementID, Colour colour, String inputString) {
		return colourReplacement(gradientReplacementID, colour, null, null, inputString);
	}

	public static String colourReplacement(String gradientReplacementID, Colour colour, Colour colourSecondary, Colour colourTertiary, String inputString) {
		String s = inputString;

		if(gradientReplacementID!=null) {
			s = s.replaceAll("linearGradient\\d|innoGrad\\d|radialGradient\\d",
					gradientReplacementID + colour.toString() + (colourSecondary!=null?colourSecondary.toString():"") + (colourTertiary!=null?colourTertiary.toString():"") + "$0");
		}

		s = sanitizeImageString(s, true);

		if(colour!=null) {
			s = s.replaceAll("#ff2a2a", colour.getShades()[0]);
			s = s.replaceAll("#ff5555|#f55(?!\\d)", colour.getShades()[1]);
			s = s.replaceAll("#ff8080", colour.getShades()[2]);
			s = s.replaceAll("#ffaaaa|#faa(?!\\d)", colour.getShades()[3]);
			s = s.replaceAll("#ffd5d5", colour.getShades()[4]);
		}

		if(colourSecondary!=null) {
			s = s.replaceAll("#ff7f2a", colourSecondary.getShades()[0]);
			s = s.replaceAll("#ff9955|#f95(?!\\d)", colourSecondary.getShades()[1]);
			s = s.replaceAll("#ffb380", colourSecondary.getShades()[2]);
			s = s.replaceAll("#ffccaa|#fca(?!\\d)", colourSecondary.getShades()[3]);
			s = s.replaceAll("#ffe6d5", colourSecondary.getShades()[4]);
		}

		if(colourTertiary!=null) {
			s = s.replaceAll("#ffd42a", colourTertiary.getShades()[0]);
			s = s.replaceAll("#ffdd55|#fd5(?!\\d)", colourTertiary.getShades()[1]);
			s = s.replaceAll("#ffe680", colourTertiary.getShades()[2]);
			s = s.replaceAll("#ffeeaa|#fea(?!\\d)", colourTertiary.getShades()[3]);
			s = s.replaceAll("#fff6d5", colourTertiary.getShades()[4]);
		}

		return s;
	}

	public static String colourReplacement(String gradientReplacementID, BaseColour colour, String inputString) {
		return colourReplacement(gradientReplacementID, colour, null, null, inputString);
	}

	public static String colourReplacement(String gradientReplacementID, BaseColour colour, BaseColour colourSecondary, BaseColour colourTertiary, String inputString) {
		String s = inputString;

		if(gradientReplacementID!=null) {
			s = s.replaceAll("linearGradient\\d|innoGrad\\d|radialGradient\\d",
					gradientReplacementID + colour.toString() + (colourSecondary!=null?colourSecondary.toString():"") + (colourTertiary!=null?colourTertiary.toString():"") + "$0");
		}

		s = sanitizeImageString(s, true);

		if(colour!=null) {
			s = s.replaceAll("#ff2a2a", colour.getShades()[0]);
			s = s.replaceAll("#ff5555|#f55(?!\\d)", colour.getShades()[1]);
			s = s.replaceAll("#ff8080", colour.getShades()[2]);
			s = s.replaceAll("#ffaaaa|#faa(?!\\d)", colour.getShades()[3]);
			s = s.replaceAll("#ffd5d5", colour.getShades()[4]);
		}

		if(colourSecondary!=null) {
			s = s.replaceAll("#ff7f2a", colourSecondary.getShades()[0]);
			s = s.replaceAll("#ff9955|#f95(?!\\d)", colourSecondary.getShades()[1]);
			s = s.replaceAll("#ffb380", colourSecondary.getShades()[2]);
			s = s.replaceAll("#ffccaa|#fca(?!\\d)", colourSecondary.getShades()[3]);
			s = s.replaceAll("#ffe6d5", colourSecondary.getShades()[4]);
		}

		if(colourTertiary!=null) {
			s = s.replaceAll("#ffd42a", colourTertiary.getShades()[0]);
			s = s.replaceAll("#ffdd55|#fd5(?!\\d)", colourTertiary.getShades()[1]);
			s = s.replaceAll("#ffe680", colourTertiary.getShades()[2]);
			s = s.replaceAll("#ffeeaa|#fea(?!\\d)", colourTertiary.getShades()[3]);
			s = s.replaceAll("#fff6d5", colourTertiary.getShades()[4]);
		}

		return s;
	}

	public static String colourReplacement(String gradientReplacementID, String colour, String inputString) {
		String s = inputString;

		if(gradientReplacementID!=null) {
			s = s.replaceAll("linearGradient\\d|innoGrad\\d|radialGradient\\d",
					gradientReplacementID + colour.toString() + "$0");
		}

		s = sanitizeImageString(s, true);

		if(colour!=null) {
			s = s.replaceAll("#ff2a2a", colour);
			s = s.replaceAll("#ff5555|#f55(?!\\d)", colour);
			s = s.replaceAll("#ff8080", colour);
			s = s.replaceAll("#ffaaaa|#faa(?!\\d)", colour);
			s = s.replaceAll("#ffd5d5", colour);
		}

		return s;
	}

	private static String sanitizeImageString(String imageString, boolean sanitizeSizes) {
		String s = imageString;

		// Remove xml header from svg, if it has one
		s = s.replaceFirst("<\\?xml[^?]*\\?>", "");

		if (sanitizeSizes) {
			// Fixes issue of SVG icons overflowing:
			s = s.replaceFirst("width=\"100%\"\\R   height=\"100%\"", "");
		}

		return s;
	}
}


code:
package com.lilithsthrone.utils;

import java.util.ArrayList;
import java.util.List;

/**
 * @since 0.1.99
 * @version 0.1.99
 * @author Innoxia
 */
public class TreeNode<T> {

	private T data;
	private TreeNode<T> parent;
	private List<TreeNode<T>> children;

	public TreeNode(T data) {
		super();
		this.data = data;
		children = new ArrayList<>();
	}

	public T getData() {
		return data;
	}

	public TreeNode<T> getParent() {
		return parent;
	}

	public List<TreeNode<T>> getChildren() {
		return children;
	}

	public void addChild(TreeNode<T> child) {
		children.add(child);
		child.parent = this;
	}

	public boolean childrenContainsData(T data) {
		for(TreeNode<T> node : children) {
			if(node.childrenContainsData(data)) {
				return true;
			}
		}

		return (this.data.equals(data));
	}

	public TreeNode<T> getFirstNodeWithData(T data) {

		if(this.getData().equals(data)) {
			return this;
		}

		for(TreeNode<T> node : children) {
			TreeNode<T> returnedNode = node.getFirstNodeWithData(data);
			if(returnedNode!=null) {
				return returnedNode;
			}
		}

		return null;
	}
}