Constellation Core

A reusable movement, path, force-field and impact engine for Minecraft 1.7.10.
Built to give scripts and Java mods smooth mathematical motion, reusable collision behavior and runtime control without rewriting the same movement system for every project.

🌠 What is Constellation Core?

Constellation Core is a Forge library/mod for creators building advanced content on Minecraft 1.7.10.

It can be used from:

• CustomNPC+ JavaScript scripts;
• Forge mods written in Java;
• shared libraries and addon mods;
• scripted RPG systems;
• custom bosses, abilities and cinematic systems.

Instead of moving every object manually or recreating the same physics/path system inside every project, creators can describe a path or physical behavior and allow the Core to execute it.

It provides reusable APIs for:

• mathematical paths;
• smooth item and entity motion;
• virtual block paths;
• runtime retargeting;
• physical force fields;
• gravity wells;
• collision and impact handling;
• bounce, pierce, slide and other impact responses;
• lifecycle events;
• motion state inspection;
• reusable motion/impact presets;
• cleanup and performance budgets.

🧭 Path Engine

The Path Engine lets scripts and mods describe complete trajectories using reusable mathematical primitives.

Supported paths include:

• Hold
• Line
• Cubic Bézier
• Catmull-Rom
• Arc
• Ellipse
• Helix
• Figure Eight
• Orbit

Available easing includes:

• Linear
• Ease In
• Ease Out
• Ease In/Out
• Smoothstep
• Smootherstep
• Exponential In
• Exponential Out
• Back

🌀 Path Modifiers

Paths can be modified without creating a completely new movement system.

Available controls include:

• sine movement;
• sway;
• speed multipliers;
• repeating paths;
• ping-pong playback;
• tangent orientation;
• fixed orientation;
• look-at orientation;
• banking;
• continuous spin;
• physical guidance.

This makes one engine useful for very different motions such as:

• meteors;
• ritual items;
• orbiting relics;
• serpentine projectiles;
• rotating blades;
• cinematic blocks;
• magical objects.

🧱 Virtual Block Path

BlockPathAPI can render and animate block-based objects through the same mathematical path system.

Visual controls include:

• scale;
• independent XYZ scale;
• base rotation;
• real-time rotation;
• path alignment;
• brightness;
• optional glow;
• prewarm;
• impact hold.

This is useful for:

• meteors;
• flying debris;
• magical crystals;
• cinematic blocks;
• block-based projectiles.

💥 Impact Engine

Constellation Core 1.6 adds a reusable Impact Engine.

A path can detect collisions with entities and blocks and react through an ImpactProfile.

Available responses include:

• STOP
• BOUNCE
• SLIDE
• PIERCE
• STICK
• SHATTER
• REFLECT
• TRANSFER
• IGNORE

Impact profiles can configure:

• collision radius;
• mass;
• force;
• energy scale;
• bounce;
• friction;
• hit cooldown;
• maximum hits;
• maximum bounces;
• maximum pierces;
• lifetime;
• delayed chained radial impacts.

🛡 World Safety

Terrain modification is not implicit.

The Impact Engine provides explicit safety modes:

• Visual
• Physical
• World

Real world-block destruction requires an explicit WORLD mode and worldDamage(true).

This allows creators to use cinematic block impacts without accidentally damaging maps.

🕳 Force Fields & Gravity

The Core includes reusable physical fields for living entities.

Examples:

• attraction fields;
• controlled gravity wells;
• gravity capture;
• black-hole style fields.

The system can apply radial pull, orbital motion, capture behavior and speed control without asking every script or mod to manually apply motion to every nearby entity.

🎛 Runtime Motion Control

Active movements can be modified while they are running.

Runtime controls include:

• target;
• speed;
• max speed;
• physical authority;
• spin;
• bank;
• look-at;
• scale;
• force-field center;
• force;
• radius;
• swirl;
• vertical influence.

This is useful for dynamic abilities such as:

• retargeting projectiles;
• moving gravity fields;
• cinematic choreography;
• boss attacks that change during execution.

📡 Motion State & Events

Instead of guessing when a path has finished, scripts and mods can query the engine.

State information includes:

• active state;
• kind;
• phase;
• progress;
• XYZ position;
• speed;
• max speed;
• start tick;
• duration;
• last error;
• finished state.

Lifecycle events include:

• FINISHED
• IMPACTED
• CANCELLED
• EXPIRED

Impact events can expose an ImpactContext containing position, velocity, surface normal, speed, energy, impacted entity/block and hit index.

🧩 Script API

Simple Virtual Block path:

var Path = Java.type("com.dad.constellation.api.PathEngineAPI");
var Block = Java.type("com.dad.constellation.api.BlockPathAPI");

function rightClick(event) {
    var p = event.player;

    var sx = p.getX();
    var sy = p.getY() + 2.0;
    var sz = p.getZ();

    Block.block(
        p,
        "example/block",
        "minecraft:diamond_block",
        0,
        sx,
        sy,
        sz
    )
    .scale(0.65)
    .rotation(90, 160, 40)
    .lineTo(
        sx + 8.0,
        sy + 2.0,
        sz,
        70,
        Path.EASE_IN_OUT
    )
    .play();
}

Impact example:

var Impact = Java.type("com.dad.constellation.api.ImpactAPI");

var profile = Impact.profile("PROJECTILE")
    .entityCollision(true)
    .blockCollision(true)
    .radius(0.35)
    .onEntity(Impact.PIERCE)
    .onBlock(Impact.STOP)
    .maxPierces(3)
    .maxHits(4)
    .worldMode(Impact.PHYSICAL)
    .worldDamage(false)
    .build();

☕ Java / Forge Mod API

Constellation Core is not limited to CustomNPC+ scripts.

It can also be used directly as a Java library dependency inside another Forge mod.

For example, another mod can import the public API classes:

import com.dad.constellation.api.PathEngineAPI;
import com.dad.constellation.api.BlockPathAPI;
import com.dad.constellation.api.ImpactAPI;
import com.dad.constellation.api.MotionAPI;
import com.dad.constellation.api.ForceFieldAPI;

And create paths directly from Java:

BlockPathAPI.block(
    player,
    "examplemod/meteor",
    "minecraft:obsidian",
    0,
    startX,
    startY,
    startZ
)
.scale(0.75)
.rotation(120.0, 180.0, 60.0)
.lineTo(
    targetX,
    targetY,
    targetZ,
    50,
    PathEngineAPI.EASE_IN
)
.play();

A mod can also create reusable impact profiles:

ImpactProfile impact = ImpactAPI.profile("EXAMPLE_PROJECTILE")
    .entityCollision(true)
    .blockCollision(true)
    .radius(0.35)
    .onEntity(ImpactAPI.PIERCE)
    .onBlock(ImpactAPI.STOP)
    .maxPierces(3)
    .worldMode(ImpactAPI.PHYSICAL)
    .worldDamage(false)
    .build();

Using Constellation Core as a dependency

During development, the Core JAR can be added to a ForgeGradle project's libs/ directory:

libs/
└── ConstellationCore-1.6.0.jar

Example Gradle dependency:

dependencies {
    compile files("libs/ConstellationCore-1.6.0.jar")
}

At runtime, Constellation Core remains installed as a normal Forge mod:

mods/
├── ConstellationCore-1.6.0.jar
└── YourMod.jar

This means multiple mods can share the same Core installation instead of embedding separate copies of the movement engine.

🧱 Built as a Reusable Modding Foundation

Constellation Core can be used as the movement/physics foundation for other mods.

For example:

Your Mod
   │
   ├── Items
   ├── Abilities
   ├── Entities
   ├── Bosses
   └── Constellation Core
        ├── Path Engine
        ├── Block Path
        ├── Impact Engine
        ├── Force Fields
        ├── Motion API
        └── State / Events

Or multiple mods can depend on one shared Core:

Mod A ─┐
Mod B ─┼──> Constellation Core
Mod C ─┘

This makes Constellation Core useful not only for scripted content, but also as a general-purpose movement and impact library for Forge 1.7.10 mod development.

📚 Full Documentation

The GitHub-ready documentation includes:

• complete public API reference;
• Path Engine;
• all path primitives;
• easing;
• orientation;
• path modifiers;
• BlockPath API;
• Path Engine v4 compatibility API;
• Impact Engine;
• Impact Profiles;
• Impact Context;
• State API;
• Motion API;
• runtime editing;
• motion lifecycle events;
• Force Field API;
• Floating Item API;
• Cinematic Item API;
• presets;
• performance configuration;
• lifecycle cleanup;
• Java/Forge mod integration;
• exact public Java signatures;
• copy-ready Scripted Item example.

📦 Requirements

• Minecraft 1.7.10
• Minecraft Forge for 1.7.10

Constellation Core can be used by:

• CustomNPC+ scripted projects;
• Forge Java mods;
• addon/library mods;
• custom RPG systems;
• standalone scripted systems.

CustomNPC+ is not required for Java mods using the Core API directly.

⚙️ Performance & Safety

Constellation Core has configurable limits for:

• active paths;
• active force fields;
• active impact bodies;
• impact checks per tick;
• collision sweep steps;
• event queues;
• search radius;
• network range.

These limits are intended to protect large scripts and mods from accidentally creating unlimited persistent work.

🌌 Built for Advanced Scripted Content & Mod Development

Constellation Core is useful for:

• RPG abilities;
• magic systems;
• boss attacks;
• cinematic rituals;
• moving relics;
• meteor systems;
• gravity abilities;
• custom projectiles;
• scripted encounters;
• adventure maps;
• Forge mod abilities;
• custom entities;
• reusable movement libraries;
• addon APIs.

If your project needs an object to move, collide or physically influence the world, Constellation Core is designed to be a reusable foundation for both scripts and full Forge mods.