Allen
1107 lines
40 KiB
JavaScript
1107 lines
40 KiB
JavaScript
/**
|
|
* Asset Compatibility System
|
|
* Defines compatibility rules between music, backgrounds, and avatar contexts
|
|
*/
|
|
(function() {
|
|
'use strict';
|
|
|
|
// ============================================================================
|
|
// MOOD → BACKGROUND THEME COMPATIBILITY
|
|
// ============================================================================
|
|
var MOOD_BACKGROUND_COMPAT = {
|
|
Epic: {
|
|
excellent: ['space', 'fantasy', 'sports', 'sky'],
|
|
good: ['urban', 'mechanical', 'nature'],
|
|
neutral: ['retro', 'colorful', 'indoor'],
|
|
poor: ['abstract']
|
|
},
|
|
Chill: {
|
|
excellent: ['nature', 'underwater', 'indoor', 'seasonal'],
|
|
good: ['sky', 'colorful', 'abstract'],
|
|
neutral: ['fantasy', 'retro'],
|
|
poor: ['urban', 'mechanical', 'spooky']
|
|
},
|
|
Intense: {
|
|
excellent: ['urban', 'mechanical', 'sports', 'weather'],
|
|
good: ['space', 'spooky', 'retro'],
|
|
neutral: ['nature', 'sky'],
|
|
poor: ['colorful', 'indoor', 'seasonal']
|
|
},
|
|
Playful: {
|
|
excellent: ['colorful', 'retro', 'nature', 'indoor'],
|
|
good: ['underwater', 'seasonal', 'abstract'],
|
|
neutral: ['fantasy', 'sky'],
|
|
poor: ['spooky', 'mechanical', 'urban']
|
|
},
|
|
Mysterious: {
|
|
excellent: ['spooky', 'fantasy', 'underwater', 'weather'],
|
|
good: ['nature', 'urban', 'abstract'],
|
|
neutral: ['space', 'indoor'],
|
|
poor: ['colorful', 'sports', 'retro']
|
|
},
|
|
Heroic: {
|
|
excellent: ['space', 'fantasy', 'urban', 'sky'],
|
|
good: ['nature', 'sports', 'mechanical'],
|
|
neutral: ['retro', 'weather'],
|
|
poor: ['indoor', 'colorful', 'abstract']
|
|
},
|
|
Quirky: {
|
|
excellent: ['retro', 'colorful', 'abstract', 'indoor'],
|
|
good: ['nature', 'mechanical', 'seasonal'],
|
|
neutral: ['urban', 'fantasy'],
|
|
poor: ['spooky', 'space', 'sports']
|
|
},
|
|
Ambient: {
|
|
excellent: ['nature', 'underwater', 'sky', 'seasonal'],
|
|
good: ['abstract', 'indoor', 'weather'],
|
|
neutral: ['space', 'fantasy'],
|
|
poor: ['urban', 'mechanical', 'sports', 'spooky']
|
|
}
|
|
};
|
|
|
|
// ============================================================================
|
|
// BACKGROUND THEME → AVATAR CONTEXT COMPATIBILITY
|
|
// ============================================================================
|
|
var THEME_CONTEXT_COMPAT = {
|
|
space: {
|
|
excellent: ['spaceship-cockpit', 'space-suit', 'mech-suit'],
|
|
good: ['jetpack', 'platformer-standard', 'adventure-hero'],
|
|
neutral: ['ninja-outfit', 'superhero-cape', 'wizard-robes'],
|
|
poor: ['chef-outfit', 'cowboy-gear', 'pirate-outfit', 'race-car', 'submarine', 'hot-air-balloon']
|
|
},
|
|
fantasy: {
|
|
excellent: ['knight-armor', 'wizard-robes', 'dragon-rider'],
|
|
good: ['adventure-hero', 'ninja-outfit', 'fairy-wings'],
|
|
neutral: ['platformer-standard', 'superhero-cape', 'pirate-outfit'],
|
|
poor: ['race-car', 'motorcycle', 'submarine', 'spaceship-cockpit', 'space-suit', 'mech-suit']
|
|
},
|
|
nature: {
|
|
excellent: ['adventure-hero', 'platformer-standard', 'fairy-wings'],
|
|
good: ['ninja-outfit', 'cowboy-gear', 'safari-outfit'],
|
|
neutral: ['wizard-robes', 'pirate-outfit', 'superhero-cape'],
|
|
poor: ['race-car', 'motorcycle', 'submarine', 'spaceship-cockpit', 'mech-suit', 'skateboard']
|
|
},
|
|
urban: {
|
|
excellent: ['skateboard', 'motorcycle', 'superhero-cape', 'parkour-outfit'],
|
|
good: ['platformer-standard', 'ninja-outfit', 'race-car'],
|
|
neutral: ['adventure-hero', 'chef-outfit', 'detective-outfit'],
|
|
poor: ['dragon-rider', 'fairy-wings', 'pirate-outfit', 'submarine', 'space-suit', 'cowboy-gear']
|
|
},
|
|
underwater: {
|
|
excellent: ['submarine', 'scuba-gear', 'mermaid-tail'],
|
|
good: ['pirate-outfit', 'adventure-hero', 'platformer-standard'],
|
|
neutral: ['ninja-outfit', 'wizard-robes', 'fairy-wings'],
|
|
poor: ['race-car', 'motorcycle', 'skateboard', 'cowboy-gear', 'knight-armor', 'hot-air-balloon']
|
|
},
|
|
retro: {
|
|
excellent: ['platformer-standard', 'arcade-classic', 'superhero-cape'],
|
|
good: ['adventure-hero', 'ninja-outfit', 'skateboard'],
|
|
neutral: ['wizard-robes', 'knight-armor', 'pirate-outfit'],
|
|
poor: ['mech-suit', 'spaceship-cockpit', 'submarine', 'dragon-rider', 'safari-outfit']
|
|
},
|
|
sports: {
|
|
excellent: ['race-car', 'motorcycle', 'skateboard', 'sports-uniform'],
|
|
good: ['platformer-standard', 'adventure-hero', 'superhero-cape'],
|
|
neutral: ['ninja-outfit', 'parkour-outfit', 'jetpack'],
|
|
poor: ['wizard-robes', 'knight-armor', 'pirate-outfit', 'submarine', 'fairy-wings', 'mermaid-tail']
|
|
},
|
|
spooky: {
|
|
excellent: ['wizard-robes', 'vampire-cloak', 'ghost-costume'],
|
|
good: ['ninja-outfit', 'adventure-hero', 'detective-outfit'],
|
|
neutral: ['platformer-standard', 'superhero-cape', 'pirate-outfit'],
|
|
poor: ['fairy-wings', 'chef-outfit', 'sports-uniform', 'safari-outfit', 'hot-air-balloon', 'race-car']
|
|
},
|
|
colorful: {
|
|
excellent: ['platformer-standard', 'superhero-cape', 'fairy-wings', 'arcade-classic'],
|
|
good: ['adventure-hero', 'skateboard', 'jetpack'],
|
|
neutral: ['ninja-outfit', 'wizard-robes', 'pirate-outfit'],
|
|
poor: ['vampire-cloak', 'ghost-costume', 'detective-outfit', 'mech-suit']
|
|
},
|
|
mechanical: {
|
|
excellent: ['mech-suit', 'race-car', 'motorcycle', 'jetpack'],
|
|
good: ['spaceship-cockpit', 'ninja-outfit', 'superhero-cape'],
|
|
neutral: ['platformer-standard', 'adventure-hero', 'skateboard'],
|
|
poor: ['fairy-wings', 'wizard-robes', 'pirate-outfit', 'cowboy-gear', 'mermaid-tail', 'safari-outfit']
|
|
},
|
|
indoor: {
|
|
excellent: ['platformer-standard', 'chef-outfit', 'detective-outfit', 'arcade-classic'],
|
|
good: ['adventure-hero', 'ninja-outfit', 'superhero-cape'],
|
|
neutral: ['wizard-robes', 'skateboard', 'parkour-outfit'],
|
|
poor: ['submarine', 'race-car', 'motorcycle', 'dragon-rider', 'hot-air-balloon', 'safari-outfit']
|
|
},
|
|
sky: {
|
|
excellent: ['jetpack', 'hot-air-balloon', 'dragon-rider', 'fairy-wings'],
|
|
good: ['superhero-cape', 'spaceship-cockpit', 'platformer-standard'],
|
|
neutral: ['adventure-hero', 'ninja-outfit', 'wizard-robes'],
|
|
poor: ['submarine', 'race-car', 'motorcycle', 'skateboard', 'chef-outfit', 'mermaid-tail']
|
|
},
|
|
seasonal: {
|
|
excellent: ['platformer-standard', 'adventure-hero', 'fairy-wings'],
|
|
good: ['superhero-cape', 'wizard-robes', 'chef-outfit'],
|
|
neutral: ['ninja-outfit', 'skateboard', 'detective-outfit'],
|
|
poor: ['submarine', 'mech-suit', 'spaceship-cockpit', 'vampire-cloak', 'race-car']
|
|
},
|
|
weather: {
|
|
excellent: ['adventure-hero', 'superhero-cape', 'wizard-robes'],
|
|
good: ['platformer-standard', 'ninja-outfit', 'jetpack'],
|
|
neutral: ['dragon-rider', 'hot-air-balloon', 'detective-outfit'],
|
|
poor: ['submarine', 'race-car', 'chef-outfit', 'mermaid-tail', 'arcade-classic']
|
|
},
|
|
abstract: {
|
|
excellent: ['platformer-standard', 'arcade-classic', 'superhero-cape'],
|
|
good: ['adventure-hero', 'ninja-outfit', 'wizard-robes'],
|
|
neutral: ['fairy-wings', 'jetpack', 'skateboard'],
|
|
poor: ['cowboy-gear', 'safari-outfit', 'chef-outfit', 'detective-outfit', 'pirate-outfit']
|
|
}
|
|
};
|
|
|
|
// ============================================================================
|
|
// CONTEXT → ANIMATION COMPATIBILITY
|
|
// ============================================================================
|
|
var CONTEXT_ANIMATIONS = {
|
|
'spaceship-cockpit': {
|
|
required: ['idle'],
|
|
recommended: ['bob', 'hurt', 'celebrate'],
|
|
incompatible: ['walk', 'run', 'jump', 'swim']
|
|
},
|
|
'space-suit': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['jump', 'float', 'hurt', 'celebrate'],
|
|
incompatible: ['swim']
|
|
},
|
|
'mech-suit': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['attack', 'hurt', 'celebrate', 'stomp'],
|
|
incompatible: ['swim', 'fly']
|
|
},
|
|
'race-car': {
|
|
required: ['idle'],
|
|
recommended: ['hurt', 'celebrate', 'boost'],
|
|
incompatible: ['walk', 'run', 'jump', 'fly', 'swim']
|
|
},
|
|
'motorcycle': {
|
|
required: ['idle'],
|
|
recommended: ['hurt', 'celebrate', 'wheelie'],
|
|
incompatible: ['walk', 'run', 'fly', 'swim']
|
|
},
|
|
'submarine': {
|
|
required: ['idle'],
|
|
recommended: ['hurt', 'celebrate', 'dive'],
|
|
incompatible: ['walk', 'run', 'jump', 'fly']
|
|
},
|
|
'platformer-standard': {
|
|
required: ['idle', 'walk', 'jump'],
|
|
recommended: ['run', 'fall', 'hurt', 'celebrate', 'crouch'],
|
|
incompatible: []
|
|
},
|
|
'adventure-hero': {
|
|
required: ['idle', 'walk', 'jump'],
|
|
recommended: ['run', 'attack', 'hurt', 'celebrate', 'climb'],
|
|
incompatible: []
|
|
},
|
|
'ninja-outfit': {
|
|
required: ['idle', 'walk', 'jump'],
|
|
recommended: ['run', 'attack', 'throw', 'hurt', 'celebrate', 'crouch', 'wallslide'],
|
|
incompatible: []
|
|
},
|
|
'knight-armor': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['attack', 'block', 'hurt', 'celebrate'],
|
|
incompatible: ['fly', 'swim']
|
|
},
|
|
'wizard-robes': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['cast', 'float', 'hurt', 'celebrate', 'teleport'],
|
|
incompatible: []
|
|
},
|
|
'dragon-rider': {
|
|
required: ['idle', 'fly'],
|
|
recommended: ['attack', 'hurt', 'celebrate', 'dive', 'breathe-fire'],
|
|
incompatible: ['walk', 'run', 'swim']
|
|
},
|
|
'fairy-wings': {
|
|
required: ['idle', 'fly'],
|
|
recommended: ['hover', 'hurt', 'celebrate', 'sparkle'],
|
|
incompatible: ['swim']
|
|
},
|
|
'jetpack': {
|
|
required: ['idle', 'fly'],
|
|
recommended: ['boost', 'hurt', 'celebrate', 'hover'],
|
|
incompatible: ['swim']
|
|
},
|
|
'hot-air-balloon': {
|
|
required: ['idle'],
|
|
recommended: ['float', 'hurt', 'celebrate'],
|
|
incompatible: ['walk', 'run', 'jump', 'swim', 'attack']
|
|
},
|
|
'pirate-outfit': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['attack', 'jump', 'hurt', 'celebrate', 'swim'],
|
|
incompatible: ['fly']
|
|
},
|
|
'cowboy-gear': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['shoot', 'jump', 'hurt', 'celebrate', 'lasso'],
|
|
incompatible: ['fly', 'swim']
|
|
},
|
|
'superhero-cape': {
|
|
required: ['idle', 'walk', 'fly'],
|
|
recommended: ['run', 'jump', 'attack', 'hurt', 'celebrate', 'land'],
|
|
incompatible: []
|
|
},
|
|
'skateboard': {
|
|
required: ['idle'],
|
|
recommended: ['trick', 'grind', 'hurt', 'celebrate', 'push'],
|
|
incompatible: ['walk', 'run', 'fly', 'swim']
|
|
},
|
|
'scuba-gear': {
|
|
required: ['idle', 'swim'],
|
|
recommended: ['dive', 'hurt', 'celebrate'],
|
|
incompatible: ['walk', 'run', 'jump', 'fly']
|
|
},
|
|
'mermaid-tail': {
|
|
required: ['idle', 'swim'],
|
|
recommended: ['dive', 'hurt', 'celebrate', 'splash'],
|
|
incompatible: ['walk', 'run', 'jump', 'fly']
|
|
},
|
|
'chef-outfit': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['chop', 'throw', 'hurt', 'celebrate'],
|
|
incompatible: ['fly', 'swim']
|
|
},
|
|
'safari-outfit': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['run', 'jump', 'hurt', 'celebrate', 'crouch'],
|
|
incompatible: ['fly']
|
|
},
|
|
'vampire-cloak': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['attack', 'fly', 'hurt', 'celebrate', 'transform'],
|
|
incompatible: ['swim']
|
|
},
|
|
'ghost-costume': {
|
|
required: ['idle', 'float'],
|
|
recommended: ['fly', 'phase', 'hurt', 'celebrate', 'fade'],
|
|
incompatible: ['walk', 'run', 'swim']
|
|
},
|
|
'detective-outfit': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['run', 'crouch', 'hurt', 'celebrate', 'inspect'],
|
|
incompatible: ['fly', 'swim']
|
|
},
|
|
'parkour-outfit': {
|
|
required: ['idle', 'walk', 'run', 'jump'],
|
|
recommended: ['wallrun', 'vault', 'roll', 'hurt', 'celebrate', 'climb'],
|
|
incompatible: ['fly', 'swim']
|
|
},
|
|
'arcade-classic': {
|
|
required: ['idle', 'walk'],
|
|
recommended: ['jump', 'hurt', 'celebrate'],
|
|
incompatible: []
|
|
},
|
|
'sports-uniform': {
|
|
required: ['idle', 'walk', 'run'],
|
|
recommended: ['jump', 'kick', 'throw', 'hurt', 'celebrate'],
|
|
incompatible: ['fly', 'swim']
|
|
}
|
|
};
|
|
|
|
// ============================================================================
|
|
// COLOR PALETTE HARMONY
|
|
// ============================================================================
|
|
var PALETTE_HARMONY = {
|
|
'space-blue': {
|
|
harmonious: ['fantasy-purple', 'ocean-teal', 'spooky-grey', 'cyber-neon'],
|
|
neutral: ['nature-green', 'retro-warm', 'neutral-earth'],
|
|
clash: ['sunset-orange', 'sports-red', 'candy-rainbow']
|
|
},
|
|
'fantasy-purple': {
|
|
harmonious: ['space-blue', 'spooky-grey', 'cyber-neon', 'sunset-orange'],
|
|
neutral: ['nature-green', 'ocean-teal', 'neutral-earth'],
|
|
clash: ['sports-red', 'candy-rainbow', 'retro-warm']
|
|
},
|
|
'nature-green': {
|
|
harmonious: ['ocean-teal', 'neutral-earth', 'sunset-orange', 'retro-warm'],
|
|
neutral: ['space-blue', 'fantasy-purple', 'candy-rainbow'],
|
|
clash: ['cyber-neon', 'spooky-grey', 'sports-red']
|
|
},
|
|
'ocean-teal': {
|
|
harmonious: ['space-blue', 'nature-green', 'fantasy-purple', 'neutral-earth'],
|
|
neutral: ['cyber-neon', 'spooky-grey', 'retro-warm'],
|
|
clash: ['sports-red', 'candy-rainbow', 'sunset-orange']
|
|
},
|
|
'sunset-orange': {
|
|
harmonious: ['fantasy-purple', 'nature-green', 'retro-warm', 'neutral-earth'],
|
|
neutral: ['spooky-grey', 'candy-rainbow', 'sports-red'],
|
|
clash: ['space-blue', 'ocean-teal', 'cyber-neon']
|
|
},
|
|
'sports-red': {
|
|
harmonious: ['neutral-earth', 'spooky-grey', 'retro-warm'],
|
|
neutral: ['sunset-orange', 'candy-rainbow', 'fantasy-purple'],
|
|
clash: ['space-blue', 'ocean-teal', 'nature-green', 'cyber-neon']
|
|
},
|
|
'retro-warm': {
|
|
harmonious: ['sunset-orange', 'nature-green', 'neutral-earth', 'sports-red'],
|
|
neutral: ['fantasy-purple', 'candy-rainbow', 'spooky-grey'],
|
|
clash: ['space-blue', 'ocean-teal', 'cyber-neon']
|
|
},
|
|
'spooky-grey': {
|
|
harmonious: ['space-blue', 'fantasy-purple', 'cyber-neon', 'sports-red'],
|
|
neutral: ['neutral-earth', 'ocean-teal', 'retro-warm'],
|
|
clash: ['candy-rainbow', 'nature-green', 'sunset-orange']
|
|
},
|
|
'candy-rainbow': {
|
|
harmonious: ['retro-warm', 'sunset-orange', 'fantasy-purple'],
|
|
neutral: ['nature-green', 'sports-red', 'neutral-earth'],
|
|
clash: ['space-blue', 'ocean-teal', 'spooky-grey', 'cyber-neon']
|
|
},
|
|
'cyber-neon': {
|
|
harmonious: ['space-blue', 'fantasy-purple', 'spooky-grey'],
|
|
neutral: ['ocean-teal', 'neutral-earth', 'candy-rainbow'],
|
|
clash: ['nature-green', 'sunset-orange', 'retro-warm', 'sports-red']
|
|
},
|
|
'neutral-earth': {
|
|
harmonious: ['nature-green', 'ocean-teal', 'retro-warm', 'sunset-orange'],
|
|
neutral: ['space-blue', 'fantasy-purple', 'sports-red', 'spooky-grey'],
|
|
clash: ['candy-rainbow', 'cyber-neon']
|
|
}
|
|
};
|
|
|
|
// ============================================================================
|
|
// ENERGY LEVEL MAPPINGS
|
|
// ============================================================================
|
|
var MOOD_ENERGY = {
|
|
Epic: 'high',
|
|
Chill: 'low',
|
|
Intense: 'high',
|
|
Playful: 'medium',
|
|
Mysterious: 'low',
|
|
Heroic: 'high',
|
|
Quirky: 'medium',
|
|
Ambient: 'low'
|
|
};
|
|
|
|
var CONTEXT_ENERGY = {
|
|
'spaceship-cockpit': 'medium',
|
|
'space-suit': 'medium',
|
|
'mech-suit': 'high',
|
|
'race-car': 'high',
|
|
'motorcycle': 'high',
|
|
'submarine': 'low',
|
|
'platformer-standard': 'medium',
|
|
'adventure-hero': 'medium',
|
|
'ninja-outfit': 'high',
|
|
'knight-armor': 'medium',
|
|
'wizard-robes': 'medium',
|
|
'dragon-rider': 'high',
|
|
'fairy-wings': 'low',
|
|
'jetpack': 'high',
|
|
'hot-air-balloon': 'low',
|
|
'pirate-outfit': 'medium',
|
|
'cowboy-gear': 'medium',
|
|
'superhero-cape': 'high',
|
|
'skateboard': 'high',
|
|
'scuba-gear': 'low',
|
|
'mermaid-tail': 'low',
|
|
'chef-outfit': 'low',
|
|
'safari-outfit': 'medium',
|
|
'vampire-cloak': 'medium',
|
|
'ghost-costume': 'low',
|
|
'detective-outfit': 'low',
|
|
'parkour-outfit': 'high',
|
|
'arcade-classic': 'medium',
|
|
'sports-uniform': 'high'
|
|
};
|
|
|
|
// ============================================================================
|
|
// THEME → DEFAULT PALETTE MAPPING
|
|
// ============================================================================
|
|
var THEME_DEFAULT_PALETTES = {
|
|
space: ['space-blue', 'cyber-neon', 'spooky-grey'],
|
|
fantasy: ['fantasy-purple', 'nature-green', 'sunset-orange'],
|
|
nature: ['nature-green', 'neutral-earth', 'ocean-teal'],
|
|
urban: ['neutral-earth', 'spooky-grey', 'cyber-neon'],
|
|
underwater: ['ocean-teal', 'space-blue', 'nature-green'],
|
|
retro: ['retro-warm', 'candy-rainbow', 'sunset-orange'],
|
|
sports: ['sports-red', 'neutral-earth', 'cyber-neon'],
|
|
spooky: ['spooky-grey', 'fantasy-purple', 'cyber-neon'],
|
|
colorful: ['candy-rainbow', 'sunset-orange', 'fantasy-purple'],
|
|
mechanical: ['spooky-grey', 'cyber-neon', 'sports-red'],
|
|
indoor: ['neutral-earth', 'retro-warm', 'sunset-orange'],
|
|
sky: ['space-blue', 'sunset-orange', 'ocean-teal'],
|
|
seasonal: ['nature-green', 'sunset-orange', 'neutral-earth'],
|
|
weather: ['spooky-grey', 'space-blue', 'nature-green'],
|
|
abstract: ['cyber-neon', 'candy-rainbow', 'fantasy-purple']
|
|
};
|
|
|
|
// ============================================================================
|
|
// MECHANICS → CONTEXT MAPPING
|
|
// ============================================================================
|
|
var MECHANICS_CONTEXTS = {
|
|
flying: ['dragon-rider', 'fairy-wings', 'jetpack', 'superhero-cape', 'hot-air-balloon'],
|
|
racing: ['race-car', 'motorcycle', 'skateboard'],
|
|
platforming: ['platformer-standard', 'adventure-hero', 'ninja-outfit', 'parkour-outfit', 'arcade-classic'],
|
|
swimming: ['submarine', 'scuba-gear', 'mermaid-tail'],
|
|
combat: ['knight-armor', 'ninja-outfit', 'superhero-cape', 'mech-suit', 'wizard-robes'],
|
|
exploration: ['adventure-hero', 'safari-outfit', 'detective-outfit', 'pirate-outfit'],
|
|
puzzle: ['platformer-standard', 'detective-outfit', 'wizard-robes', 'arcade-classic'],
|
|
stealth: ['ninja-outfit', 'ghost-costume', 'vampire-cloak', 'detective-outfit'],
|
|
cooking: ['chef-outfit'],
|
|
sports: ['sports-uniform', 'skateboard']
|
|
};
|
|
|
|
// ============================================================================
|
|
// VALIDATION FUNCTIONS
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Get mood-background compatibility level
|
|
* @param {string} mood - Music mood
|
|
* @param {string} theme - Background theme
|
|
* @returns {string} - 'excellent', 'good', 'neutral', or 'poor'
|
|
*/
|
|
function getMoodBackgroundCompat(mood, theme) {
|
|
var compat = MOOD_BACKGROUND_COMPAT[mood];
|
|
if (!compat) return 'neutral';
|
|
if (compat.excellent && compat.excellent.indexOf(theme) !== -1) return 'excellent';
|
|
if (compat.good && compat.good.indexOf(theme) !== -1) return 'good';
|
|
if (compat.poor && compat.poor.indexOf(theme) !== -1) return 'poor';
|
|
return 'neutral';
|
|
}
|
|
|
|
/**
|
|
* Get theme-context compatibility level
|
|
* @param {string} theme - Background theme
|
|
* @param {string} context - Avatar context
|
|
* @returns {string} - 'excellent', 'good', 'neutral', or 'poor'
|
|
*/
|
|
function getThemeContextCompat(theme, context) {
|
|
var compat = THEME_CONTEXT_COMPAT[theme];
|
|
if (!compat) return 'neutral';
|
|
if (compat.excellent && compat.excellent.indexOf(context) !== -1) return 'excellent';
|
|
if (compat.good && compat.good.indexOf(context) !== -1) return 'good';
|
|
if (compat.poor && compat.poor.indexOf(context) !== -1) return 'poor';
|
|
return 'neutral';
|
|
}
|
|
|
|
/**
|
|
* Get context-animation compatibility
|
|
* @param {string} context - Avatar context
|
|
* @param {string} animation - Animation name
|
|
* @returns {string} - 'required', 'recommended', 'compatible', or 'incompatible'
|
|
*/
|
|
function getContextAnimationCompat(context, animation) {
|
|
var compat = CONTEXT_ANIMATIONS[context];
|
|
if (!compat) return 'compatible';
|
|
if (compat.required && compat.required.indexOf(animation) !== -1) return 'required';
|
|
if (compat.recommended && compat.recommended.indexOf(animation) !== -1) return 'recommended';
|
|
if (compat.incompatible && compat.incompatible.indexOf(animation) !== -1) return 'incompatible';
|
|
return 'compatible';
|
|
}
|
|
|
|
/**
|
|
* Get palette harmony level
|
|
* @param {string} palette1 - First palette
|
|
* @param {string} palette2 - Second palette
|
|
* @returns {string} - 'harmonious', 'neutral', or 'clash'
|
|
*/
|
|
function getPaletteHarmony(palette1, palette2) {
|
|
if (palette1 === palette2) return 'harmonious';
|
|
var compat = PALETTE_HARMONY[palette1];
|
|
if (!compat) return 'neutral';
|
|
if (compat.harmonious && compat.harmonious.indexOf(palette2) !== -1) return 'harmonious';
|
|
if (compat.clash && compat.clash.indexOf(palette2) !== -1) return 'clash';
|
|
return 'neutral';
|
|
}
|
|
|
|
/**
|
|
* Check energy level compatibility
|
|
* @param {string} moodEnergy - Music energy level
|
|
* @param {string} contextEnergy - Context energy level
|
|
* @returns {string} - 'match', 'close', or 'mismatch'
|
|
*/
|
|
function getEnergyCompat(moodEnergy, contextEnergy) {
|
|
if (moodEnergy === contextEnergy) return 'match';
|
|
var levels = ['low', 'medium', 'high'];
|
|
var diff = Math.abs(levels.indexOf(moodEnergy) - levels.indexOf(contextEnergy));
|
|
return diff === 1 ? 'close' : 'mismatch';
|
|
}
|
|
|
|
/**
|
|
* Validate a complete asset configuration
|
|
* @param {Object} config - Configuration object with music, background, avatarContext, palette
|
|
* @returns {Object} - { valid, score, issues }
|
|
*/
|
|
function validate(config) {
|
|
var issues = [];
|
|
var score = 100;
|
|
|
|
// Check music/background compatibility
|
|
if (config.music && config.background) {
|
|
var mood = config.music.mood || config.music;
|
|
var theme = config.background.theme || config.background;
|
|
var compat = getMoodBackgroundCompat(mood, theme);
|
|
|
|
if (compat === 'poor') {
|
|
issues.push({
|
|
type: 'warning',
|
|
category: 'mood-background',
|
|
message: 'Music mood "' + mood + '" doesn\'t match background theme "' + theme + '" well'
|
|
});
|
|
score -= 15;
|
|
} else if (compat === 'neutral') {
|
|
score -= 5;
|
|
} else if (compat === 'excellent') {
|
|
score += 10;
|
|
} else if (compat === 'good') {
|
|
score += 5;
|
|
}
|
|
}
|
|
|
|
// Check background/context compatibility
|
|
if (config.background && config.avatarContext) {
|
|
var theme = config.background.theme || config.background;
|
|
var context = config.avatarContext.context || config.avatarContext;
|
|
var compat = getThemeContextCompat(theme, context);
|
|
|
|
if (compat === 'poor') {
|
|
issues.push({
|
|
type: 'warning',
|
|
category: 'theme-context',
|
|
message: 'Avatar context "' + context + '" doesn\'t fit background theme "' + theme + '"'
|
|
});
|
|
score -= 20;
|
|
} else if (compat === 'excellent') {
|
|
score += 10;
|
|
} else if (compat === 'good') {
|
|
score += 5;
|
|
}
|
|
}
|
|
|
|
// Check energy level appropriateness
|
|
if (config.music && config.avatarContext) {
|
|
var mood = config.music.mood || config.music;
|
|
var context = config.avatarContext.context || config.avatarContext;
|
|
var moodEnergy = MOOD_ENERGY[mood];
|
|
var contextEnergy = CONTEXT_ENERGY[context];
|
|
|
|
if (moodEnergy && contextEnergy) {
|
|
var energyCompat = getEnergyCompat(moodEnergy, contextEnergy);
|
|
|
|
if (energyCompat === 'mismatch') {
|
|
issues.push({
|
|
type: 'info',
|
|
category: 'energy',
|
|
message: 'Music energy (' + moodEnergy + ') doesn\'t match avatar context energy (' + contextEnergy + ')'
|
|
});
|
|
score -= 10;
|
|
} else if (energyCompat === 'match') {
|
|
score += 5;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check palette harmony with theme
|
|
if (config.palette && config.background) {
|
|
var theme = config.background.theme || config.background;
|
|
var palette = config.palette.name || config.palette;
|
|
var themePalettes = THEME_DEFAULT_PALETTES[theme];
|
|
|
|
if (themePalettes) {
|
|
if (themePalettes.indexOf(palette) === -1) {
|
|
// Check if it's harmonious with any default palette
|
|
var hasHarmony = false;
|
|
for (var i = 0; i < themePalettes.length; i++) {
|
|
if (getPaletteHarmony(palette, themePalettes[i]) === 'harmonious') {
|
|
hasHarmony = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!hasHarmony) {
|
|
var clashes = false;
|
|
for (var i = 0; i < themePalettes.length; i++) {
|
|
if (getPaletteHarmony(palette, themePalettes[i]) === 'clash') {
|
|
clashes = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (clashes) {
|
|
issues.push({
|
|
type: 'info',
|
|
category: 'palette',
|
|
message: 'Color palette "' + palette + '" may clash with theme "' + theme + '"'
|
|
});
|
|
score -= 5;
|
|
}
|
|
}
|
|
} else {
|
|
score += 5;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check animation compatibility with context
|
|
if (config.avatarContext && config.animations) {
|
|
var context = config.avatarContext.context || config.avatarContext;
|
|
var contextAnims = CONTEXT_ANIMATIONS[context];
|
|
|
|
if (contextAnims) {
|
|
// Check for missing required animations
|
|
var animations = Array.isArray(config.animations) ? config.animations : [config.animations];
|
|
|
|
if (contextAnims.required) {
|
|
for (var i = 0; i < contextAnims.required.length; i++) {
|
|
var required = contextAnims.required[i];
|
|
if (animations.indexOf(required) === -1) {
|
|
issues.push({
|
|
type: 'error',
|
|
category: 'animation',
|
|
message: 'Context "' + context + '" requires animation "' + required + '"'
|
|
});
|
|
score -= 25;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for incompatible animations
|
|
if (contextAnims.incompatible) {
|
|
for (var i = 0; i < animations.length; i++) {
|
|
if (contextAnims.incompatible.indexOf(animations[i]) !== -1) {
|
|
issues.push({
|
|
type: 'warning',
|
|
category: 'animation',
|
|
message: 'Animation "' + animations[i] + '" is incompatible with context "' + context + '"'
|
|
});
|
|
score -= 10;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
valid: issues.filter(function(i) { return i.type === 'error'; }).length === 0,
|
|
score: Math.max(0, Math.min(100, score)),
|
|
issues: issues
|
|
};
|
|
}
|
|
|
|
// ============================================================================
|
|
// SUGGESTION FUNCTIONS
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Get compatible music moods for a background theme
|
|
* @param {string} theme - Background theme
|
|
* @returns {Array} - Sorted array of { mood, compatibility }
|
|
*/
|
|
function getMusicForTheme(theme) {
|
|
var results = [];
|
|
var moods = Object.keys(MOOD_BACKGROUND_COMPAT);
|
|
|
|
for (var i = 0; i < moods.length; i++) {
|
|
var mood = moods[i];
|
|
var compat = getMoodBackgroundCompat(mood, theme);
|
|
results.push({ mood: mood, compatibility: compat });
|
|
}
|
|
|
|
// Sort by compatibility
|
|
var order = { excellent: 0, good: 1, neutral: 2, poor: 3 };
|
|
results.sort(function(a, b) {
|
|
return order[a.compatibility] - order[b.compatibility];
|
|
});
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Get compatible background themes for a music mood
|
|
* @param {string} mood - Music mood
|
|
* @returns {Array} - Sorted array of { theme, compatibility }
|
|
*/
|
|
function getBackgroundsForMood(mood) {
|
|
var compat = MOOD_BACKGROUND_COMPAT[mood];
|
|
if (!compat) return [];
|
|
|
|
var results = [];
|
|
var allThemes = Object.keys(THEME_CONTEXT_COMPAT);
|
|
|
|
for (var i = 0; i < allThemes.length; i++) {
|
|
var theme = allThemes[i];
|
|
var level = getMoodBackgroundCompat(mood, theme);
|
|
results.push({ theme: theme, compatibility: level });
|
|
}
|
|
|
|
var order = { excellent: 0, good: 1, neutral: 2, poor: 3 };
|
|
results.sort(function(a, b) {
|
|
return order[a.compatibility] - order[b.compatibility];
|
|
});
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Get compatible contexts for game mechanics
|
|
* @param {Array|string} mechanics - Game mechanics
|
|
* @returns {Array} - Array of context names with relevance scores
|
|
*/
|
|
function getContextsForMechanics(mechanics) {
|
|
var mechs = Array.isArray(mechanics) ? mechanics : [mechanics];
|
|
var contextScores = {};
|
|
|
|
for (var i = 0; i < mechs.length; i++) {
|
|
var mech = mechs[i];
|
|
var contexts = MECHANICS_CONTEXTS[mech];
|
|
|
|
if (contexts) {
|
|
for (var j = 0; j < contexts.length; j++) {
|
|
var ctx = contexts[j];
|
|
contextScores[ctx] = (contextScores[ctx] || 0) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
var results = [];
|
|
var ctxNames = Object.keys(contextScores);
|
|
|
|
for (var i = 0; i < ctxNames.length; i++) {
|
|
results.push({
|
|
context: ctxNames[i],
|
|
relevance: contextScores[ctxNames[i]] / mechs.length
|
|
});
|
|
}
|
|
|
|
results.sort(function(a, b) {
|
|
return b.relevance - a.relevance;
|
|
});
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Get compatible contexts for a background theme
|
|
* @param {string} theme - Background theme
|
|
* @returns {Array} - Sorted array of { context, compatibility }
|
|
*/
|
|
function getContextsForTheme(theme) {
|
|
var compat = THEME_CONTEXT_COMPAT[theme];
|
|
if (!compat) return [];
|
|
|
|
var results = [];
|
|
var allContexts = Object.keys(CONTEXT_ANIMATIONS);
|
|
|
|
for (var i = 0; i < allContexts.length; i++) {
|
|
var context = allContexts[i];
|
|
var level = getThemeContextCompat(theme, context);
|
|
results.push({ context: context, compatibility: level });
|
|
}
|
|
|
|
var order = { excellent: 0, good: 1, neutral: 2, poor: 3 };
|
|
results.sort(function(a, b) {
|
|
return order[a.compatibility] - order[b.compatibility];
|
|
});
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Get compatible palettes for a background theme
|
|
* @param {string} theme - Background theme
|
|
* @returns {Array} - Array of palette names with compatibility
|
|
*/
|
|
function getPalettesForTheme(theme) {
|
|
var defaultPalettes = THEME_DEFAULT_PALETTES[theme] || [];
|
|
var results = [];
|
|
var allPalettes = Object.keys(PALETTE_HARMONY);
|
|
|
|
for (var i = 0; i < allPalettes.length; i++) {
|
|
var palette = allPalettes[i];
|
|
var isDefault = defaultPalettes.indexOf(palette) !== -1;
|
|
|
|
// Check harmony with default palettes
|
|
var harmony = 'neutral';
|
|
if (isDefault) {
|
|
harmony = 'excellent';
|
|
} else {
|
|
for (var j = 0; j < defaultPalettes.length; j++) {
|
|
var h = getPaletteHarmony(palette, defaultPalettes[j]);
|
|
if (h === 'harmonious') {
|
|
harmony = 'good';
|
|
break;
|
|
} else if (h === 'clash') {
|
|
harmony = 'poor';
|
|
}
|
|
}
|
|
}
|
|
|
|
results.push({ palette: palette, compatibility: harmony });
|
|
}
|
|
|
|
var order = { excellent: 0, good: 1, neutral: 2, poor: 3 };
|
|
results.sort(function(a, b) {
|
|
return order[a.compatibility] - order[b.compatibility];
|
|
});
|
|
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Suggest improvements for a configuration
|
|
* @param {Object} config - Current configuration
|
|
* @returns {Array} - Array of suggestion objects
|
|
*/
|
|
function suggestImprovements(config) {
|
|
var suggestions = [];
|
|
var validation = validate(config);
|
|
|
|
if (validation.score >= 90) {
|
|
return suggestions;
|
|
}
|
|
|
|
// Analyze each issue and suggest fixes
|
|
for (var i = 0; i < validation.issues.length; i++) {
|
|
var issue = validation.issues[i];
|
|
|
|
if (issue.category === 'mood-background') {
|
|
var theme = config.background.theme || config.background;
|
|
var betterMoods = getMusicForTheme(theme)
|
|
.filter(function(m) { return m.compatibility === 'excellent' || m.compatibility === 'good'; })
|
|
.slice(0, 3);
|
|
|
|
if (betterMoods.length > 0) {
|
|
suggestions.push({
|
|
type: 'music',
|
|
message: 'Consider using music with mood: ' + betterMoods.map(function(m) { return m.mood; }).join(', '),
|
|
options: betterMoods
|
|
});
|
|
}
|
|
}
|
|
|
|
if (issue.category === 'theme-context') {
|
|
var context = config.avatarContext.context || config.avatarContext;
|
|
// Find better themes for this context
|
|
var betterThemes = [];
|
|
var themes = Object.keys(THEME_CONTEXT_COMPAT);
|
|
|
|
for (var j = 0; j < themes.length; j++) {
|
|
var compat = getThemeContextCompat(themes[j], context);
|
|
if (compat === 'excellent' || compat === 'good') {
|
|
betterThemes.push({ theme: themes[j], compatibility: compat });
|
|
}
|
|
}
|
|
|
|
if (betterThemes.length > 0) {
|
|
suggestions.push({
|
|
type: 'background',
|
|
message: 'Consider using background theme: ' + betterThemes.slice(0, 3).map(function(t) { return t.theme; }).join(', '),
|
|
options: betterThemes.slice(0, 5)
|
|
});
|
|
}
|
|
|
|
// Also suggest better contexts for current theme
|
|
var theme = config.background.theme || config.background;
|
|
var betterContexts = getContextsForTheme(theme)
|
|
.filter(function(c) { return c.compatibility === 'excellent' || c.compatibility === 'good'; })
|
|
.slice(0, 5);
|
|
|
|
if (betterContexts.length > 0) {
|
|
suggestions.push({
|
|
type: 'context',
|
|
message: 'Or consider avatar context: ' + betterContexts.slice(0, 3).map(function(c) { return c.context; }).join(', '),
|
|
options: betterContexts
|
|
});
|
|
}
|
|
}
|
|
|
|
if (issue.category === 'energy') {
|
|
var mood = config.music.mood || config.music;
|
|
var moodEnergy = MOOD_ENERGY[mood];
|
|
|
|
// Find contexts with matching energy
|
|
var matchingContexts = [];
|
|
var contexts = Object.keys(CONTEXT_ENERGY);
|
|
|
|
for (var j = 0; j < contexts.length; j++) {
|
|
if (CONTEXT_ENERGY[contexts[j]] === moodEnergy) {
|
|
matchingContexts.push(contexts[j]);
|
|
}
|
|
}
|
|
|
|
if (matchingContexts.length > 0) {
|
|
suggestions.push({
|
|
type: 'context',
|
|
message: 'For ' + moodEnergy + ' energy music, consider: ' + matchingContexts.slice(0, 4).join(', '),
|
|
options: matchingContexts.slice(0, 6).map(function(c) { return { context: c, energy: moodEnergy }; })
|
|
});
|
|
}
|
|
}
|
|
|
|
if (issue.category === 'animation' && issue.type === 'error') {
|
|
var context = config.avatarContext.context || config.avatarContext;
|
|
var contextAnims = CONTEXT_ANIMATIONS[context];
|
|
|
|
if (contextAnims && contextAnims.required) {
|
|
suggestions.push({
|
|
type: 'animation',
|
|
message: 'Required animations for "' + context + '": ' + contextAnims.required.join(', '),
|
|
options: contextAnims.required
|
|
});
|
|
}
|
|
}
|
|
|
|
if (issue.category === 'palette') {
|
|
var theme = config.background.theme || config.background;
|
|
var betterPalettes = getPalettesForTheme(theme)
|
|
.filter(function(p) { return p.compatibility === 'excellent' || p.compatibility === 'good'; })
|
|
.slice(0, 5);
|
|
|
|
if (betterPalettes.length > 0) {
|
|
suggestions.push({
|
|
type: 'palette',
|
|
message: 'Better palettes for "' + theme + '": ' + betterPalettes.map(function(p) { return p.palette; }).join(', '),
|
|
options: betterPalettes
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return suggestions;
|
|
}
|
|
|
|
// ============================================================================
|
|
// CONVENIENCE FUNCTIONS
|
|
// ============================================================================
|
|
|
|
/**
|
|
* Get backgrounds compatible with a music mood
|
|
* @param {string} mood - Music mood
|
|
* @returns {Array} - Array of theme names (excellent and good only)
|
|
*/
|
|
function getCompatibleBackgrounds(mood) {
|
|
return getBackgroundsForMood(mood)
|
|
.filter(function(b) { return b.compatibility === 'excellent' || b.compatibility === 'good'; })
|
|
.map(function(b) { return b.theme; });
|
|
}
|
|
|
|
/**
|
|
* Get contexts compatible with a background theme
|
|
* @param {string} theme - Background theme
|
|
* @returns {Array} - Array of context names (excellent and good only)
|
|
*/
|
|
function getCompatibleContexts(theme) {
|
|
return getContextsForTheme(theme)
|
|
.filter(function(c) { return c.compatibility === 'excellent' || c.compatibility === 'good'; })
|
|
.map(function(c) { return c.context; });
|
|
}
|
|
|
|
/**
|
|
* Get palettes compatible with a background theme
|
|
* @param {string} theme - Background theme
|
|
* @returns {Array} - Array of palette names (excellent and good only)
|
|
*/
|
|
function getCompatiblePalettes(theme) {
|
|
return getPalettesForTheme(theme)
|
|
.filter(function(p) { return p.compatibility === 'excellent' || p.compatibility === 'good'; })
|
|
.map(function(p) { return p.palette; });
|
|
}
|
|
|
|
/**
|
|
* Get required animations for a context
|
|
* @param {string} context - Avatar context
|
|
* @returns {Array} - Array of required animation names
|
|
*/
|
|
function getRequiredAnimations(context) {
|
|
var anims = CONTEXT_ANIMATIONS[context];
|
|
return anims ? (anims.required || []) : [];
|
|
}
|
|
|
|
/**
|
|
* Get recommended animations for a context
|
|
* @param {string} context - Avatar context
|
|
* @returns {Array} - Array of recommended animation names
|
|
*/
|
|
function getRecommendedAnimations(context) {
|
|
var anims = CONTEXT_ANIMATIONS[context];
|
|
return anims ? (anims.recommended || []) : [];
|
|
}
|
|
|
|
/**
|
|
* Get all valid animations for a context
|
|
* @param {string} context - Avatar context
|
|
* @returns {Object} - { required, recommended, compatible }
|
|
*/
|
|
function getValidAnimations(context) {
|
|
var anims = CONTEXT_ANIMATIONS[context];
|
|
if (!anims) {
|
|
return { required: [], recommended: [], incompatible: [] };
|
|
}
|
|
|
|
return {
|
|
required: anims.required || [],
|
|
recommended: anims.recommended || [],
|
|
incompatible: anims.incompatible || []
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Check if a complete asset set is compatible
|
|
* @param {string} mood - Music mood
|
|
* @param {string} theme - Background theme
|
|
* @param {string} context - Avatar context
|
|
* @returns {Object} - { compatible, score, issues }
|
|
*/
|
|
function checkFullCompatibility(mood, theme, context) {
|
|
return validate({
|
|
music: { mood: mood },
|
|
background: { theme: theme },
|
|
avatarContext: { context: context }
|
|
});
|
|
}
|
|
|
|
// ============================================================================
|
|
// PUBLIC API
|
|
// ============================================================================
|
|
window.AssetCompatibility = {
|
|
// Validation
|
|
validate: validate,
|
|
checkFullCompatibility: checkFullCompatibility,
|
|
|
|
// Compatibility checks
|
|
getMoodBackgroundCompat: getMoodBackgroundCompat,
|
|
getThemeContextCompat: getThemeContextCompat,
|
|
getContextAnimationCompat: getContextAnimationCompat,
|
|
getPaletteHarmony: getPaletteHarmony,
|
|
|
|
// Suggestions
|
|
getMusicForTheme: getMusicForTheme,
|
|
getBackgroundsForMood: getBackgroundsForMood,
|
|
getContextsForTheme: getContextsForTheme,
|
|
getContextsForMechanics: getContextsForMechanics,
|
|
getPalettesForTheme: getPalettesForTheme,
|
|
suggestImprovements: suggestImprovements,
|
|
|
|
// Get compatible options (convenience methods)
|
|
getCompatibleBackgrounds: getCompatibleBackgrounds,
|
|
getCompatibleContexts: getCompatibleContexts,
|
|
getCompatiblePalettes: getCompatiblePalettes,
|
|
|
|
// Animation helpers
|
|
getRequiredAnimations: getRequiredAnimations,
|
|
getRecommendedAnimations: getRecommendedAnimations,
|
|
getValidAnimations: getValidAnimations,
|
|
|
|
// Raw data
|
|
MOOD_BACKGROUND_COMPAT: MOOD_BACKGROUND_COMPAT,
|
|
THEME_CONTEXT_COMPAT: THEME_CONTEXT_COMPAT,
|
|
CONTEXT_ANIMATIONS: CONTEXT_ANIMATIONS,
|
|
PALETTE_HARMONY: PALETTE_HARMONY,
|
|
MOOD_ENERGY: MOOD_ENERGY,
|
|
CONTEXT_ENERGY: CONTEXT_ENERGY,
|
|
THEME_DEFAULT_PALETTES: THEME_DEFAULT_PALETTES,
|
|
MECHANICS_CONTEXTS: MECHANICS_CONTEXTS
|
|
};
|
|
|
|
})();
|