AspectsLib

• Fixed Corruption affecting biomes globally, now it's localized by chunks (Pull Request #10 by Leclowndu93150)

I'm excited to announce a complete ground-up rewrite of AspectsLib's core systems! This update represents the most significant changes since the mod's inception, with entirely new implementations of the Aether, Corruption, and Aspects systems.

Aspects System

What's New

The aspects system has been completely redesigned with a more flexible and performant architecture:

Universal Aspect Assignment:

• Single Data Pack Format for items, blocks, entities, and biomes
• Tag Support for all assignment types
• Dynamic Registry with proper dependency management
• NBT Persistence across saves

New Data Pack Structure:

// data/yourmod/aspect_assignments/your_aspects.json
[
  {
    "item": "minecraft:diamond",
    "aspects": {
      "aspectslib:terra": 10,
      "aspectslib:vitreus": 5
    }
  },
  {
    "item_tag": "#minecraft:logs",
    "aspects": {
      "aspectslib:arbor": 3
    }
  },
  {
    "biome": "minecraft:forest",
    "aspects": {
      "aspectslib:arbor": 8,
      "aspectslib:herba": 6
    }
  }
]

API Usage Examples:

// Get aspects from any object
AspectData itemAspects = AspectsAPI.getAspectData(itemStack);
AspectData blockAspects = AspectsAPI.getBlockAspectData(blockId);
AspectData entityAspects = AspectsAPI.getEntityAspectData(entityId);
AspectData biomeAspects = AspectsAPI.getBiomeAspectData(biomeId);

// Register aspects programmatically
AspectsAPI.registerItemAspect(Items.DIAMOND, AspectsLib.identifier("terra"), 10);
AspectsAPI.registerBiomeAspect(Biomes.FOREST, AspectsLib.identifier("arbor"), 8);

// Create custom aspect data
AspectData.Builder builder = AspectsAPI.createAspectDataBuilder();
builder.add(AspectsLib.identifier("ignis"), 5);
builder.add(AspectsLib.identifier("aqua"), 3);
AspectData customData = builder.build();

Resonance System:

• Aspect Interactions: Define amplifying or opposing relationships
• Dynamic Calculations: Automatic RU (Resonance Unit) calculations
• Data Pack Configurable: Easy to extend with custom interactions

// data/yourmod/resonance/fire_water.json
{
  "aspect1": "aspectslib:ignis",
  "aspect2": "aspectslib:aqua", 
  "type": "opposing",
  "factor": 2.0
}

Aether System

What is the Aether?

The Aether is a dimensional resource system that represents the ambient "mana" in chunks. It's automatically generated from biome aspects and can be harvested.

Key Features

Dimension-Based Configuration:

// data/yourmod/aether_config/overworld.json
{
  "recoveryRate": 1.5,
  "permanentDeadZoneThreshold": 15000,
  "temporaryDeadZoneRecoveryThreshold": 0.2,
  "chunkVolume": 65536
}

Automatic Aether Generation:

• Aether is generated from biome aspects in each chunk
• Dead Zones can form when Aether is over-harvested
• Automatic Recovery happens over time
• Permanent vs Temporary dead zones with different behaviors

API Usage Examples:

// Check if a spell can be cast
AspectData spellCost = new AspectData.Builder()
    .set(AspectsLib.identifier("ignis"), 5)
    .set(AspectsLib.identifier("vitreus"), 3)
    .build();

if (AetherAPI.canCastSpell(world, player.getBlockPos(), spellCost)) {
    // Cast the spell
    boolean success = AetherAPI.castSpell(world, player.getBlockPos(), spellCost);
}

// Monitor Aether levels
int currentAether = AetherAPI.getAetherLevel(world, pos, AspectsLib.identifier("ignis"));
int capacity = AetherAPI.getAetherCapacity(world, pos, AspectsLib.identifier("ignis"));
double percentage = AetherAPI.getAetherPercentage(world, pos, AspectsLib.identifier("ignis"));

// Manage dead zones
if (AetherAPI.isDeadZone(world, pos)) {
    if (AetherAPI.isPermanentDeadZone(world, pos)) {
        // Permanent wasteland
    } else {
        // Temporary dead zone that can recover
        AetherAPI.forceRecovery(world, pos); // Admin command to force recovery
    }
}

Corruption System

The corruption system now provides meaningful world progression with tangible effects:

Corruption States:

• Pure (0): No Vitium present
• Tainted (1): Vitium present but not dominant
• Corrupted (2): Vitium dominates other aspects
• Regenerating: Recovering from corruption

Progressive Effects:

1. Aspect Consumption: Vitium consumes other aspects over time
2. Sculk Spreading: Automatic sculk growth in corrupted areas
3. Aether Depletion: Corruption can drain Aether
4. Dead Zone Creation: Extreme corruption creates Dead Zones

API Usage Examples:

// Check corruption state
int corruptionState = CorruptionAPI.getBiomeCorruptionState(biomeId);
boolean isCorrupted = CorruptionAPI.isBiomeCorrupted(biomeId);
boolean isTainted = CorruptionAPI.isBiomeTainted(biomeId);
boolean isPure = CorruptionAPI.isBiomePure(biomeId);

// Get Vitium levels
int vitiumAmount = CorruptionAPI.getVitiumAmount(biomeId);

// Manipulate corruption
CorruptionAPI.forceCorruption(biomeId, 50); // Add 50 Vitium
CorruptionAPI.purifyBiome(biomeId); // Remove all Vitium

// Access corruption tracking data
CorruptionChunkData chunkData = CorruptionAPI.getChunkData(serverWorld, chunkPos);
Collection<CorruptionChunkData> allTracked = CorruptionAPI.getTrackedChunks(serverWorld);

Recipe Aspect Calculation

The new recipe system automatically calculates aspects for crafted items based on their ingredients.

Configuration:

// config/aspectslib/recipe_aspects.json
{
  "enabled": true,
  "craftingLoss": 0.8,
  "smeltingLoss": 0.9,
  "smithingLoss": 0.95,
  "stonecuttingLoss": 1.0,
  "maxDepth": 20,
  "parallelThreads": 4
}

Commands:

• /aspectslib recipe recalculate - Force recalculation
• /aspectslib recipe enable [true|false] - Toggle system

Developer APIs & Integration

Aspect Management:

// Full aspect lifecycle management
Optional<Aspect> aspect = AspectsAPI.getAspect(new Identifier("aspectslib:terra"));
Map<Identifier, Aspect> allAspects = AspectsAPI.getAllAspects();

// Dynamic aspect manipulation
AspectsAPI.addAspect(itemStack, AspectsLib.identifier("ignis"), 5);
AspectsAPI.setAspectData(itemStack, customAspectData);

Tooltip System:

// Custom tooltip visibility conditions
AspectsTooltipConfig.addVisibilityCondition((stack, player) -> {
    return player != null && player.isSneaking();
});

// Aura node visibility
AspectsAPI.addAuraNodeVisibilityCondition((player, hasAspects) -> {
    return player.hasPermissionLevel(2) || hasAspects;
});

Breaking Changes & Migration

Migration Guide:

• Update data packs to use new aspect_assignments format
• Update API calls to use new AspectsAPI class
• Convert aspect definitions to new JSON format
• Update dimension configs to use aether_config format

• Added proper rendering to the Aura Node entity (Pull Request #3 by Favouriteless
• Gave Aura Nodes conditional transparency based on a condition similar to how aspects are shown on tooltips. I modifed the rendering code to make it transparent by default and only show fully when a condition is met. The Aura Node visibility should be completely configurable by other mods using the API now, with no default condition.

Usage Example for Other Mods

Other mods using your library would need to add their own visibility conditions:

// In another mod's client initialization
AspectsAPI.addAuraNodeVisibilityCondition((player, hasAspects) -> {
    // Example: Show nodes when player has a specific item
    return player.getMainHandStack().isOf(Items.NETHER_STAR);
});

// Or example: Show nodes when player is in creative mode
AspectsAPI.addAuraNodeVisibilityCondition((player, hasAspects) -> {
    return player.isCreative();
});

// Or example: Show nodes when player has a specific effect
AspectsAPI.addAuraNodeVisibilityCondition((player, hasAspects) -> {
    return player.hasStatusEffect(StatusEffects.NIGHT_VISION);
});

Default Behavior Now

• By default: Aura nodes are semi-transparent (20% opacity) because no conditions are met
• When conditions are added via API: Nodes become fully visible (100% opacity) when any condition returns true
• Completely pluggable: No built-in logic - entirely driven by API consumers

This makes the library modular and allows each mod that uses it to define its own conditions for when Aura Nodes should be visible.

• Fixed critical entrypoint stage main crash upon initializing game
• Removed Vitium hard coding in Corruption Manager
• Added new aspectslib:aether_density report command with 3 sub-commands report, list, corrupt

• Fixed Aether Densities not loading properly from data packs. (Pull Request #2 by Leclowndu93150)
• Updated Sculk spread when Vitium is the dominant aspect

Fixed issue with the corruption calculation. The problem was that the CorruptionManager is only checking the dynamic modifications and not considering the base biome densities.

I added the calculation of base biome density using BiomeAetherDensityManager.DENSITY_MAP and combined base density and dynamic modifications to calculate the total amounts.

I've also added a proper check to make sure corruption only starts when Vitium is truly dominant. The condition now is: totalVitium > totalOtherAspects where:

• totalVitium = base vitium + dynamic vitium modifications
• totalOtherAspects = sum of all other aspects (base + modifications)

• Created a registry for all Aspect Shard items organized by hierarchy and implemented a custom AspectShardItem class that automatically adds aspect data to the item stack

• Created an ItemGroup that contains all aspect shards in order and properly sets the aspect data for each shard using the AspectsLib system.

• Implemented Corruption logic

Made changes to hide aspects in tooltips by default while allowing developers to customize when they're shown.

Key Changes:

1. Hidden by default: Aspects won't show in tooltips unless explicitly enabled
2. Flexible conditions: Developers can add multiple visibility conditions
3. Player context: Conditions have access to player state and inventory
4. Easy to use: Simple API for adding custom conditions
5. Non-intrusive: Doesn't require changes to existing item/entity code

Usage Examples:

1. Always show aspects:

AspectsTooltipConfig.setAlwaysShow(true);

1. Show only when holding a specific item:

AspectsTooltipConfig.addVisibilityCondition((stack, player) -> {
    if (player == null) return false;
    return player.getMainHandStack().isOf(Items.GOLD_INGOT);
});

1. Show only in creative mode:

AspectsTooltipConfig.addVisibilityCondition((stack, player) -> {
    return player != null && player.isCreative();
});

1. Show only when sneaking:

AspectsTooltipConfig.addVisibilityCondition((stack, player) -> {
    return player != null && player.isSneaking();
});

1. Complex condition (show when holding compass and in overworld):

AspectsTooltipConfig.addVisibilityCondition((stack, player) -> {
    if (player == null) return false;
    return player.getMainHandStack().isOf(Items.COMPASS) && 
           player.getWorld().getRegistryKey() == World.OVERWORLD;
});

• Added Aether Density

Upload to Modrinth