redscript-mc 3.0.0 → 3.0.2

package/dist/types/entity-hierarchy.d.ts

@@ -1,29 +0,0 @@
-/**
- * Entity Type Hierarchy
- *
- * Closed inheritance tree mapping to Minecraft's entity registry.
- * Used for type narrowing (is checks), selector<T> annotations,
- * and W_IMPOSSIBLE_AS warnings.
- */
-export interface EntityTypeNode {
-    name: string;
-    mcId: string | null;
-    abstract: boolean;
-    parent: string | null;
-}
-export declare const ENTITY_TYPES: EntityTypeNode[];
-/** Map from lowercase name → EntityTypeNode */
-export declare const ENTITY_TYPE_MAP: Map<string, EntityTypeNode>;
-/** Map from mcId (without namespace) → EntityTypeNode */
-export declare const ENTITY_TYPE_BY_MCID: Map<string, EntityTypeNode>;
-/** Check if typeA is a subtype of typeB (recursive ancestry) */
-export declare function isSubtype(typeA: string, typeB: string): boolean;
-/** True if one type is a subtype of the other (in either direction) */
-export declare function areCompatibleTypes(outerType: string, innerType: string): boolean;
-/** Get all non-abstract leaf types under a given node */
-export declare function getConcreteSubtypes(typeName: string): EntityTypeNode[];
-/** Parse "type=zombie" from a selector string, return the entity type name or null */
-export declare function getSelectorEntityType(selector: string): string | null;
-/** Determine the base entity type from a selector kind:
- *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
-export declare function getBaseSelectorType(selector: string): string | null;

package/dist/types/entity-hierarchy.js

@@ -1,107 +0,0 @@
-"use strict";
-/**
- * Entity Type Hierarchy
- *
- * Closed inheritance tree mapping to Minecraft's entity registry.
- * Used for type narrowing (is checks), selector<T> annotations,
- * and W_IMPOSSIBLE_AS warnings.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENTITY_TYPE_BY_MCID = exports.ENTITY_TYPE_MAP = exports.ENTITY_TYPES = void 0;
-exports.isSubtype = isSubtype;
-exports.areCompatibleTypes = areCompatibleTypes;
-exports.getConcreteSubtypes = getConcreteSubtypes;
-exports.getSelectorEntityType = getSelectorEntityType;
-exports.getBaseSelectorType = getBaseSelectorType;
-exports.ENTITY_TYPES = [
-    // Root
-    { name: 'Entity', mcId: null, abstract: true, parent: null },
-    // Direct children of Entity
-    { name: 'Player', mcId: 'minecraft:player', abstract: false, parent: 'Entity' },
-    { name: 'ArmorStand', mcId: 'minecraft:armor_stand', abstract: false, parent: 'Entity' },
-    { name: 'Item', mcId: 'minecraft:item', abstract: false, parent: 'Entity' },
-    { name: 'Arrow', mcId: 'minecraft:arrow', abstract: false, parent: 'Entity' },
-    // Mob hierarchy
-    { name: 'Mob', mcId: null, abstract: true, parent: 'Entity' },
-    // Hostile mobs
-    { name: 'HostileMob', mcId: null, abstract: true, parent: 'Mob' },
-    { name: 'Zombie', mcId: 'minecraft:zombie', abstract: false, parent: 'HostileMob' },
-    { name: 'Skeleton', mcId: 'minecraft:skeleton', abstract: false, parent: 'HostileMob' },
-    { name: 'Creeper', mcId: 'minecraft:creeper', abstract: false, parent: 'HostileMob' },
-    { name: 'Spider', mcId: 'minecraft:spider', abstract: false, parent: 'HostileMob' },
-    { name: 'Enderman', mcId: 'minecraft:enderman', abstract: false, parent: 'HostileMob' },
-    { name: 'Blaze', mcId: 'minecraft:blaze', abstract: false, parent: 'HostileMob' },
-    { name: 'Witch', mcId: 'minecraft:witch', abstract: false, parent: 'HostileMob' },
-    { name: 'Slime', mcId: 'minecraft:slime', abstract: false, parent: 'HostileMob' },
-    { name: 'ZombieVillager', mcId: 'minecraft:zombie_villager', abstract: false, parent: 'HostileMob' },
-    { name: 'Husk', mcId: 'minecraft:husk', abstract: false, parent: 'HostileMob' },
-    { name: 'Drowned', mcId: 'minecraft:drowned', abstract: false, parent: 'HostileMob' },
-    { name: 'Stray', mcId: 'minecraft:stray', abstract: false, parent: 'HostileMob' },
-    { name: 'WitherSkeleton', mcId: 'minecraft:wither_skeleton', abstract: false, parent: 'HostileMob' },
-    { name: 'CaveSpider', mcId: 'minecraft:cave_spider', abstract: false, parent: 'HostileMob' },
-    // Passive mobs
-    { name: 'PassiveMob', mcId: null, abstract: true, parent: 'Mob' },
-    { name: 'Pig', mcId: 'minecraft:pig', abstract: false, parent: 'PassiveMob' },
-    { name: 'Cow', mcId: 'minecraft:cow', abstract: false, parent: 'PassiveMob' },
-    { name: 'Sheep', mcId: 'minecraft:sheep', abstract: false, parent: 'PassiveMob' },
-    { name: 'Chicken', mcId: 'minecraft:chicken', abstract: false, parent: 'PassiveMob' },
-    { name: 'Villager', mcId: 'minecraft:villager', abstract: false, parent: 'PassiveMob' },
-    { name: 'WanderingTrader', mcId: 'minecraft:wandering_trader', abstract: false, parent: 'PassiveMob' },
-];
-/** Map from lowercase name → EntityTypeNode */
-exports.ENTITY_TYPE_MAP = new Map(exports.ENTITY_TYPES.map(t => [t.name.toLowerCase(), t]));
-/** Map from mcId (without namespace) → EntityTypeNode */
-exports.ENTITY_TYPE_BY_MCID = new Map(exports.ENTITY_TYPES
-    .filter(t => t.mcId !== null)
-    .map(t => [t.mcId.replace('minecraft:', ''), t]));
-/** Check if typeA is a subtype of typeB (recursive ancestry) */
-function isSubtype(typeA, typeB) {
-    if (typeA === typeB)
-        return true;
-    const node = exports.ENTITY_TYPE_MAP.get(typeA.toLowerCase());
-    if (!node || !node.parent)
-        return false;
-    return isSubtype(node.parent, typeB);
-}
-/** True if one type is a subtype of the other (in either direction) */
-function areCompatibleTypes(outerType, innerType) {
-    return isSubtype(outerType, innerType) || isSubtype(innerType, outerType);
-}
-/** Get all non-abstract leaf types under a given node */
-function getConcreteSubtypes(typeName) {
-    const results = [];
-    for (const node of exports.ENTITY_TYPES) {
-        if (!node.abstract && isSubtype(node.name, typeName)) {
-            results.push(node);
-        }
-    }
-    return results;
-}
-/** Parse "type=zombie" from a selector string, return the entity type name or null */
-function getSelectorEntityType(selector) {
-    const match = selector.match(/type=(?:minecraft:)?([a-z_]+)/);
-    if (!match)
-        return null;
-    const mcId = match[1];
-    const node = exports.ENTITY_TYPE_BY_MCID.get(mcId);
-    return node ? node.name : null;
-}
-/** Determine the base entity type from a selector kind:
- *  @a/@p/@r → "Player", @e → "Entity" or from type filter, @s → null */
-function getBaseSelectorType(selector) {
-    const trimmed = selector.trim();
-    // Check for type filter first (works for any selector)
-    const typeFromFilter = getSelectorEntityType(trimmed);
-    if (trimmed.startsWith('@a') || trimmed.startsWith('@p') || trimmed.startsWith('@r')) {
-        return typeFromFilter ?? 'Player';
-    }
-    if (trimmed.startsWith('@e')) {
-        return typeFromFilter ?? 'Entity';
-    }
-    // @s — context-dependent, we don't know unless there's a type filter
-    if (trimmed.startsWith('@s')) {
-        return typeFromFilter ?? null;
-    }
-    return null;
-}
-//# sourceMappingURL=entity-hierarchy.js.map

package/doc-drafts/redscript-docs/docs/en/stdlib/graph.md

@@ -1,104 +0,0 @@
-# `graph` — Directed and Undirected Weighted Graphs
-
-Import: `import "stdlib/graph.mcrs"`
-
-Fixed-capacity graph utilities for RedScript datapacks. The graph is stored in a single flat `int[]`, supports up to **64 nodes** and **256 directed edges**, and provides traversal plus shortest-path helpers without any dynamic graph object type.
-
-## Data Layout
-
-`graph_new()` allocates a 770-element `int[]` with this layout:
-
-| Index | Meaning |
-|------|------|
-| `g[0]` | Current directed edge count |
-| `g[1]` | Node count |
-| `g[2 + i * 3]` | Edge `i` source |
-| `g[2 + i * 3 + 1]` | Edge `i` destination |
-| `g[2 + i * 3 + 2]` | Edge `i` weight |
-
-Nodes are zero-based integers in `[0, graph_node_count(g))`.
-
-## Quick Example
-
-```rs
-import "stdlib/graph.mcrs";
-
-let g: int[] = graph_new(5);
-g = graph_add_edge(g, 0, 1, 1);
-g = graph_add_edge(g, 0, 2, 4);
-g = graph_add_undirected(g, 2, 3, 2);
-g = graph_add_edge(g, 1, 3, 2);
-g = graph_add_edge(g, 3, 4, 1);
-
-let vis: int[] = [0, 0, 0, 0, 0];
-let bfs_order: int[] = graph_bfs(g, 0, vis);
-
-let dist: int[] = [0, 0, 0, 0, 0];
-let shortest: int = graph_shortest_path(g, 0, 4, dist);
-// shortest = 4 via 0 -> 1 -> 3 -> 4
-```
-
-## Functions
-
-### `graph_new(n: int): int[]`
-
-Allocate a new graph with `n` nodes and no edges. `n` is clamped to `[0, 64]`.
-
-### `graph_add_edge(g: int[], src: int, dst: int, weight: int): int[]`
-
-Append one directed edge `src -> dst`. If `src` or `dst` is invalid, or the graph already holds 256 directed edges, the input graph is returned unchanged.
-
-### `graph_add_undirected(g: int[], a: int, b: int, weight: int): int[]`
-
-Append `a -> b` and `b -> a` with the same weight. This consumes two directed-edge slots.
-
-### `graph_node_count(g: int[]): int`
-
-Return the configured node count.
-
-### `graph_edge_count(g: int[]): int`
-
-Return the current directed edge count.
-
-### `graph_bfs(g: int[], start: int, out_visited: int[]): int[]`
-
-Breadth-first search from `start`.
-
-- Returns node indices in BFS visit order.
-- Writes `1` into `out_visited[i]` for each reachable node.
-- Returns `[]` if `start` is invalid.
-
-`out_visited` must have at least `graph_node_count(g)` slots and should be zero-initialized by the caller.
-
-### `graph_dfs(g: int[], start: int, out_visited: int[]): int[]`
-
-Depth-first search from `start`.
-
-- Returns node indices in DFS visit order.
-- Writes `1` into `out_visited[i]` for each reachable node.
-- Returns `[]` if `start` is invalid.
-
-Like `graph_bfs()`, the caller owns the output array sizing.
-
-### `graph_has_path(g: int[], src: int, dst: int): int`
-
-Return `1` if a directed path exists from `src` to `dst`, otherwise `0`.
-
-- Invalid endpoints also return `0`.
-- The implementation uses BFS over the stored directed edges.
-
-### `graph_shortest_path(g: int[], src: int, dst: int, out_dist: int[]): int`
-
-Run Dijkstra from `src` and fill `out_dist` with shortest distances.
-
-- `out_dist[i]` becomes the shortest distance from `src` to node `i`.
-- Unreachable nodes are written as `-1`.
-- The function returns `out_dist[dst]`.
-- Invalid `src` or `dst` returns `-1`.
-
-## Notes
-
-- Edge weights are plain integers.
-- Negative weights are not supported safely because the algorithm is Dijkstra.
-- `graph_bfs()` and `graph_dfs()` use fixed-size internal arrays sized for 64 nodes.
-- `graph_shortest_path()` uses `999999` as its internal infinity sentinel.

package/doc-drafts/redscript-docs/docs/en/stdlib/parabola.md

@@ -1,113 +0,0 @@
-# `parabola` — Projectile Aiming and Trajectory Helpers
-
-Import: `import "stdlib/parabola.mcrs"`
-
-Projectile helpers for Minecraft-style trajectories. This module is aimed at launch planning and simple tick-by-tick simulation. It uses **×10000 fixed-point velocities** and a gravity constant tuned to Minecraft projectile motion.
-
-## Units
-
-- Position offsets: blocks
-- Velocity: blocks/tick ×10000
-- Time: ticks
-- Gravity: `800` means `0.08 blocks/tick^2`
-- Drag: ×10000
-
-Requires `stdlib/math` for `mulfix()` and `isqrt()`.
-
-## Quick Example
-
-```rs
-import "stdlib/parabola.mcrs";
-
-let ticks: int = 20;
-let vx: int = parabola_vx(16, ticks);
-let vy: int = parabola_vy(4, ticks);
-let vz: int = parabola_vz(0, ticks);
-
-let y_at_10: int = parabola_y(vy, 10);
-let flight: int = parabola_flight_time(vy);
-```
-
-## Constants
-
-### `parabola_gravity(): int`
-
-Returns `800`, the per-tick gravity constant in ×10000 scale.
-
-### `parabola_gravity_half(): int`
-
-Returns `400`, used by the displacement formulas.
-
-## Velocity Solvers
-
-### `parabola_vx(dx: int, ticks: int): int`
-
-Initial X velocity needed to travel `dx` blocks in `ticks` ticks. Returns `0` if `ticks <= 0`.
-
-### `parabola_vy(dy: int, ticks: int): int`
-
-Initial Y velocity needed to reach vertical offset `dy` in `ticks` ticks under constant gravity. Returns `0` if `ticks <= 0`.
-
-### `parabola_vz(dz: int, ticks: int): int`
-
-Initial Z velocity needed to travel `dz` blocks in `ticks` ticks. Returns `0` if `ticks <= 0`.
-
-### `parabola_speed_xz(dx: int, dz: int, ticks: int): int`
-
-Horizontal speed magnitude from the solved `vx` and `vz`, returned in ×10000 scale.
-
-## Position at Tick `t`
-
-### `parabola_x(vx0: int, t: int): int`
-
-Horizontal X displacement after `t` ticks.
-
-### `parabola_y(vy0: int, t: int): int`
-
-Vertical displacement after `t` ticks under constant gravity.
-
-### `parabola_z(vz0: int, t: int): int`
-
-Horizontal Z displacement after `t` ticks.
-
-## Flight Estimates
-
-### `parabola_flight_time(vy0: int): int`
-
-Approximate number of ticks until a projectile returns to launch height. Returns `0` if `vy0 <= 0`.
-
-### `parabola_max_height(vy0: int): int`
-
-Approximate maximum height above launch point, in blocks.
-
-## Tick-Step Drag Helpers
-
-These functions are for per-tick simulation, not closed-form aiming.
-
-### `parabola_step_vx(vx: int, drag: int): int`
-
-Apply drag to X velocity.
-
-### `parabola_step_vy(vy: int, drag: int): int`
-
-Apply gravity first, then drag, to Y velocity.
-
-### `parabola_step_vz(vz: int, drag: int): int`
-
-Apply drag to Z velocity.
-
-## Targeting Helpers
-
-### `parabola_ticks_for_range(range: int): int`
-
-Estimate a practical flight time for a horizontal range, using a simple average-speed heuristic. Returns at least `1`.
-
-### `parabola_in_range(dx: int, dz: int, max_range: int): int`
-
-Return `1` if the horizontal target lies within `max_range`, otherwise `0`.
-
-## Notes
-
-- Closed-form position helpers here assume no drag.
-- Drag-aware helpers only advance velocity one tick at a time.
-- `parabola_y()` and `parabola_max_height()` return integer block values, so truncation is expected.

package/doc-drafts/redscript-docs/docs/en/stdlib/pathfind.md

@@ -1,104 +0,0 @@
-# `pathfind` — 16×16 Grid BFS Pathfinding
-
-Import: `import "stdlib/pathfind.mcrs"`
-
-Breadth-first pathfinding on a fixed **16×16** XZ grid. Obstacles are stored in a 256-element `int[]`, and paths are returned as packed grid coordinates.
-
-## Coordinate Packing
-
-Cells are encoded as:
-
-```text
-packed = x * 16 + z
-```
-
-Helpers:
-
-- `pf_unpack_x(packed) = packed / 16`
-- `pf_unpack_z(packed) = packed % 16`
-
-## Quick Example
-
-```rs
-import "stdlib/pathfind.mcrs";
-
-let map: int[] = pf_new_map();
-pf_set_blocked(map, 3, 5);
-pf_set_blocked(map, 3, 6);
-
-let path: int[] = pathfind_bfs(map, 0, 0, 7, 7);
-let first_x: int = pf_unpack_x(path[0]);
-let first_z: int = pf_unpack_z(path[0]);
-```
-
-## Map Helpers
-
-### `pf_pack(x: int, z: int): int`
-
-Pack a grid coordinate into one integer.
-
-### `pf_unpack_x(packed: int): int`
-
-Recover the X coordinate from a packed cell id.
-
-### `pf_unpack_z(packed: int): int`
-
-Recover the Z coordinate from a packed cell id.
-
-### `pf_new_map(): int[]`
-
-Allocate a 256-element obstacle map with all cells open.
-
-### `pf_set_blocked(map: int[], x: int, z: int)`
-
-Mark `(x, z)` as blocked by writing `1`.
-
-### `pf_set_open(map: int[], x: int, z: int)`
-
-Mark `(x, z)` as open by writing `0`.
-
-### `pf_is_blocked(map: int[], x: int, z: int): int`
-
-Return `1` if the cell is blocked or out of bounds, otherwise `0`.
-
-## Heuristic Helper
-
-### `pf_heuristic(x1: int, z1: int, x2: int, z2: int): int`
-
-Return Manhattan distance in ×10000 fixed-point form.
-
-This function is informational in the current module. `pathfind_bfs()` does not use it, but it is useful if you build A* on top of the same map representation.
-
-## Synchronous Pathfinding
-
-### `pathfind_bfs(map: int[], sx: int, sz: int, gx: int, gz: int): int[]`
-
-Find the shortest 4-direction path from start to goal.
-
-- Returns packed coordinates from start to goal, inclusive.
-- Returns `[]` when no path exists.
-- Expansion order is North, South, West, East.
-
-Because this is BFS on a uniform-cost grid, the returned path is shortest in number of steps.
-
-## Coroutine Pathfinding
-
-### `pathfind_bfs_coro(map: int[], sx: int, sz: int, gx: int, gz: int, out: int[])`
-
-Coroutine version of BFS:
-
-- Decorated with `@coroutine(batch=16, onDone=pf_noop)`.
-- Processes up to 16 BFS iterations per tick.
-- Cannot return a value directly, so it pushes the finished path into `out`.
-
-Use this when a synchronous search would be too expensive in one tick.
-
-### `pf_noop()`
-
-Default empty `onDone` callback for the coroutine variant.
-
-## Notes
-
-- The grid is hard-coded to `0..15` on both axes.
-- Start and goal cells are not validated explicitly before indexing, so callers should pass valid coordinates.
-- `pf_is_blocked()` treats out-of-bounds cells as blocked, which keeps BFS inside the grid.

package/doc-drafts/redscript-docs/docs/en/stdlib/physics.md

@@ -1,134 +0,0 @@
-# `physics` — Simple Fixed-Point Physics Helpers
-
-Import: `import "stdlib/physics.mcrs"`
-
-Simple physics simulation helpers for Minecraft datapacks. This module uses per-axis integer math and a fixed-point scale of **×100**, where `100` means `1.0 block` or `1.0 block/tick` depending on context.
-
-## Units
-
-- Position: blocks ×100
-- Velocity: blocks/tick ×100
-- Time: ticks
-- Gravity: `8` means `0.08 blocks/tick^2`
-- Drag and restitution: ×10000
-
-## Quick Example
-
-```rs
-import "stdlib/physics.mcrs";
-
-let y0: int = 6400;    // 64.00 blocks
-let vy0: int = 120;    // 1.20 blocks/tick
-let t: int = 10;
-
-let y: int = projectile_y(y0, vy0, t);
-let vy: int = projectile_vy(vy0, t);
-
-let bounced: int = bounce_v(vy, 7000);   // 70% bounce
-```
-
-## Constants
-
-### `gravity_fx(): int`
-
-Returns `8`, representing Minecraft-like gravity in ×100 units.
-
-### `air_drag_fx(): int`
-
-Returns `9800`, meaning a drag factor of `0.98` per tick.
-
-### `water_drag_fx(): int`
-
-Returns `8000`, meaning a drag factor of `0.80` per tick.
-
-## Projectile Motion
-
-### `projectile_y(p0: int, v0: int, t: int): int`
-
-Vertical position after `t` ticks with constant gravity and no drag.
-
-### `projectile_x(p0: int, v0: int, t: int): int`
-
-Horizontal position after `t` ticks with no drag.
-
-### `projectile_vy(v0: int, t: int): int`
-
-Vertical velocity after `t` ticks of gravity.
-
-### `projectile_land_t(v0y: int): int`
-
-Approximate tick when vertical position returns to launch height. Returns `0` if `v0y <= 0`.
-
-### `projectile_max_height(v0y: int): int`
-
-Maximum height above the launch point in ×100 units.
-
-## Drag and Integration
-
-### `apply_drag(v_fx: int, drag_fx: int): int`
-
-Apply one multiplicative drag step: `v * drag / 10000`.
-
-### `apply_gravity(vy_fx: int): int`
-
-Apply one gravity tick to a vertical velocity.
-
-### `update_pos(p_fx: int, v_fx: int): int`
-
-Advance one tick by adding velocity directly to position.
-
-## Collision and Clamping
-
-### `bounce_v(v_fx: int, restitution_fx: int): int`
-
-Reflect velocity and apply a restitution factor.
-
-- `10000` = perfectly elastic
-- `5000` = half-speed rebound
-- `0` = no rebound
-
-### `clamp_velocity(v_fx: int, max_fx: int): int`
-
-Clamp velocity into `[-max_fx, max_fx]`.
-
-## Spring Helpers
-
-### `spring_force(pos_fx: int, target_fx: int, k_fx: int): int`
-
-Hooke-style spring force toward `target_fx`, with `k_fx` scaled by ×10000.
-
-### `spring_update_v(v_fx: int, pos_fx: int, target_fx: int, k_fx: int, damping_fx: int): int`
-
-Apply spring force and damping to produce the next velocity estimate.
-
-## Circular Motion
-
-This section depends on trig helpers from `stdlib/math`.
-
-### `circular_x(cx: int, r: int, angle_deg: int): int`
-
-X coordinate on a circle around center `cx`.
-
-### `circular_z(cz: int, r: int, angle_deg: int): int`
-
-Z coordinate on a circle around center `cz`.
-
-## Friction and Impact
-
-### `friction_decel(v_fx: int, friction_fx: int): int`
-
-Reduce velocity toward zero by a fixed per-tick amount.
-
-### `is_grounded(y_fx: int, ground_y_fx: int): int`
-
-Return `1` if `y_fx <= ground_y_fx`, otherwise `0`.
-
-### `impact_velocity(h_fx: int): int`
-
-Approximate impact speed from a fall height in ×100 units. Returns `0` for non-positive heights.
-
-## Notes
-
-- This module is intentionally simple and axis-separated.
-- No vector type is used; callers combine `x`, `y`, and `z` themselves.
-- `circular_x()`, `circular_z()`, and `impact_velocity()` rely on math helpers such as `sin_fixed`, `cos_fixed`, and `isqrt`.