@ludra/core 0.4.0 → 0.7.0

package/dist/world.js

@@ -1,5 +1,7 @@
 import { resolveComponent, } from "./components.js";
+import { getScript, ScriptError, } from "./script.js";
 import { FIXED_DT } from "./time.js";
+import { EVENT_TYPES } from "./types.js";
 import { validateScene } from "./validate.js";
 export class SceneValidationError extends Error {
     diagnostics;
@@ -19,6 +21,10 @@ const STOMP_BOUNCE = 0.6;
 const STOMP_TOLERANCE = 8;
 /** A platformer this far below the bottom of the world has fallen out of it. */
 const FALL_MARGIN = 100;
+/** Bodies this close count as touching for `touch` hooks, so solids (doors, walls) can be touched too. */
+const TOUCH_MARGIN = 1;
+/** Impacts slower than this (px/s, after bounce) stop instead of bouncing. */
+const MIN_BOUNCE_SPEED = 40;
 const EPSILON = 1e-4;
 /**
  * The simulation. It advances only through `step`, one fixed frame at a time,
@@ -38,19 +44,31 @@ export class World {
     /** Set when a player reaches a goal. The simulation stops changing after that. */
     won = false;
     previousInput = new Set();
-    constructor(scene) {
+    scripts;
+    seed;
+    spawnCount = 0;
+    handles = new WeakMap();
+    scriptApi;
+    scriptInput = { held: () => false, pressed: () => false };
+    /** The script hook currently running, for error messages and event attribution. */
+    current;
+    /** True while a draw hook runs: the game can't be changed then. */
+    drawing = false;
+    constructor(scene, options = {}) {
         this.width = scene.world?.width ?? 960;
         this.height = scene.world?.height ?? 540;
         this.gravity = scene.world?.gravity ?? DEFAULT_GRAVITY;
         this.background = scene.world?.background ?? "#1d2333";
-        this.entities = scene.entities.map(createEntity);
+        this.seed = scene.world?.seed ?? 1;
+        this.scripts = options.scripts;
+        this.entities = scene.entities.map((def) => this.createEntity(def));
     }
     /** Validates raw scene JSON and builds a world, throwing on errors. */
-    static fromJSON(raw) {
+    static fromJSON(raw, options = {}) {
         const { scene, diagnostics } = validateScene(raw);
         if (!scene)
             throw new SceneValidationError(diagnostics);
-        return new World(scene);
+        return new World(scene, options);
     }
     get time() {
         return this.frame * FIXED_DT;
@@ -66,8 +84,15 @@ export class World {
         if (this.won)
             return;
         this.updatePlatformers(input, pressed);
+        this.updateTopdown(input);
+        this.updateScripts(input, pressed);
+        if (this.won)
+            return;
         this.updatePatrols();
         this.updateBodies();
+        this.updateTouches();
+        if (this.won)
+            return;
         this.updateCollectibles();
         this.updateHazards();
         this.updateGoals();
@@ -82,6 +107,9 @@ export class World {
                 vy: e.body?.vy ?? 0,
                 grounded: e.body?.grounded ?? false,
             };
+            // A JSON copy, so later frames can't change an earlier snapshot.
+            if (Object.keys(e.state).length > 0)
+                entities[e.id].state = JSON.parse(JSON.stringify(e.state));
         }
         return { frame: this.frame, time: this.time, score: this.score, deaths: this.deaths, won: this.won, entities };
     }
@@ -89,15 +117,327 @@ export class World {
         this.events.push({ ...event, frame: this.frame, time: this.time });
     }
     remove(entity) {
-        this.entities.splice(this.entities.indexOf(entity), 1);
+        const index = this.entities.indexOf(entity);
+        if (index >= 0)
+            this.entities.splice(index, 1);
+        entity.removed = true;
+    }
+    // ---------------------------------------------------------------- scripts
+    createEntity(def) {
+        const entity = createEntity(def);
+        const component = def.components.script;
+        if (component) {
+            const resolved = resolveComponent("script", component);
+            const module = getScript(this.scripts, resolved.src);
+            if (!module) {
+                throw new ScriptError({ src: resolved.src, entity: def.id, hook: "load", frame: this.frame }, "this script is not loaded. Hosts pass loaded modules as new World(scene, { scripts }); the CLI and browser runtime do this for you.");
+            }
+            entity.script = { ...resolved, params: { ...resolved.params }, module, started: false, touching: new Set() };
+        }
+        return entity;
+    }
+    updateScripts(held, pressed) {
+        this.scriptInput = { held: (action) => held.has(action), pressed: (action) => pressed.has(action) };
+        // Iterate over a copy: scripts may spawn or destroy entities.
+        for (const e of [...this.entities]) {
+            if (!e.script || e.removed)
+                continue;
+            if (!e.script.started) {
+                e.script.started = true;
+                this.callHook(e, "start");
+            }
+            if (!e.removed && !this.won)
+                this.callHook(e, "update");
+            if (this.won)
+                return;
+        }
+    }
+    /** Calls `touch` on scripted entities that started overlapping or touching another body this frame. */
+    updateTouches() {
+        for (const e of [...this.entities]) {
+            if (!e.script?.module.touch || !e.body || e.removed)
+                continue;
+            const now = new Set();
+            for (const other of this.entities) {
+                if (other !== e && other.body && overlaps(e, other, TOUCH_MARGIN))
+                    now.add(other.id);
+            }
+            for (const id of now) {
+                const other = this.get(id);
+                if (other && !e.script.touching.has(id) && !e.removed && !this.won)
+                    this.callHook(e, "touch", this.handle(other));
+            }
+            e.script.touching = now;
+        }
+    }
+    callHook(entity, hook, other) {
+        const script = entity.script;
+        const fn = script.module[hook];
+        if (!fn)
+            return;
+        const ctx = { self: this.handle(entity), world: this.api(), input: this.scriptInput, params: script.params, dt: FIXED_DT };
+        this.run(entity, hook, () => fn.call(script.module, ctx, other));
+    }
+    /**
+     * Runs an entity's `draw` or `drawUI` hook. Called by the renderer, never by the
+     * simulation. `self` and `world` are read-only for the duration.
+     */
+    callDrawHook(entity, hook, extras) {
+        const script = entity.script;
+        const fn = script?.module[hook];
+        if (!script || !fn || entity.removed)
+            return;
+        const ctx = { ...extras, self: this.handle(entity), world: this.api(), params: script.params };
+        this.drawing = true;
+        try {
+            this.run(entity, hook, () => fn.call(script.module, ctx));
+        }
+        finally {
+            this.drawing = false;
+        }
+    }
+    /** True when any live entity's script has the given hook. */
+    hasHook(hook) {
+        return this.entities.some((e) => !e.removed && typeof e.script?.module[hook] === "function");
+    }
+    run(entity, hook, call) {
+        const script = entity.script;
+        this.current = { entity, hook };
+        try {
+            call();
+        }
+        catch (err) {
+            if (err instanceof ScriptError)
+                throw err;
+            const message = err instanceof Error ? err.message : String(err);
+            throw new ScriptError({ src: script.src, entity: entity.id, hook, frame: this.frame }, message, { cause: err });
+        }
+        finally {
+            this.current = undefined;
+        }
+    }
+    /** Draw hooks only paint, so the browser can't drift from what tests verified. */
+    guard(what) {
+        if (this.drawing) {
+            throw this.misuse(`${what} changes the game, which a draw hook can't do. Change the game in update or touch, and keep visual memory in ctx.local.`);
+        }
     }
+    /** An error caused by how a script used the API, reported against the running script. */
+    misuse(message) {
+        const running = this.current;
+        return new ScriptError({ src: running?.entity.script?.src ?? "?", entity: running?.entity.id ?? "?", hook: running?.hook ?? "?", frame: this.frame }, message);
+    }
+    /** A stable script-facing view of an entity. */
+    handle(e) {
+        let handle = this.handles.get(e);
+        if (handle)
+            return handle;
+        const world = this;
+        handle = {
+            get id() {
+                return e.id;
+            },
+            get x() {
+                return e.transform.x;
+            },
+            set x(value) {
+                world.guard("Setting x");
+                e.transform.x = value;
+            },
+            get y() {
+                return e.transform.y;
+            },
+            set y(value) {
+                world.guard("Setting y");
+                e.transform.y = value;
+            },
+            get vx() {
+                return e.body?.vx ?? 0;
+            },
+            set vx(value) {
+                world.guard("Setting vx");
+                if (e.body)
+                    e.body.vx = value;
+            },
+            get vy() {
+                return e.body?.vy ?? 0;
+            },
+            set vy(value) {
+                world.guard("Setting vy");
+                if (e.body)
+                    e.body.vy = value;
+            },
+            get grounded() {
+                return e.body?.grounded ?? false;
+            },
+            get width() {
+                return e.body?.width ?? e.sprite?.width ?? 0;
+            },
+            get height() {
+                return e.body?.height ?? e.sprite?.height ?? 0;
+            },
+            get exists() {
+                return !e.removed;
+            },
+            get state() {
+                // A frozen copy while drawing, so a draw hook can't write game state by accident.
+                return world.drawing ? Object.freeze({ ...e.state }) : e.state;
+            },
+            has(component) {
+                return component === "transform" || (component in e && e[component] !== undefined);
+            },
+            touches(other) {
+                const target = world.get(typeof other === "string" ? other : other.id);
+                return !!target && target !== e && !e.removed && overlaps(e, target, TOUCH_MARGIN);
+            },
+        };
+        this.handles.set(e, handle);
+        return handle;
+    }
+    resolve(target) {
+        return this.get(typeof target === "string" ? target : target.id);
+    }
+    /** The `world` object scripts receive. */
+    api() {
+        if (this.scriptApi)
+            return this.scriptApi;
+        const world = this;
+        this.scriptApi = {
+            get time() {
+                return world.time;
+            },
+            get frame() {
+                return world.frame;
+            },
+            get width() {
+                return world.width;
+            },
+            get height() {
+                return world.height;
+            },
+            get score() {
+                return world.score;
+            },
+            get deaths() {
+                return world.deaths;
+            },
+            get won() {
+                return world.won;
+            },
+            set score(value) {
+                world.guard("Setting score");
+                world.score = value;
+            },
+            get: (id) => {
+                const e = world.get(id);
+                return e ? world.handle(e) : undefined;
+            },
+            all: (component) => world.entities.filter((e) => !component || world.handle(e).has(component)).map((e) => world.handle(e)),
+            player: () => {
+                const e = world.entities.find(isPlayer);
+                return e ? world.handle(e) : undefined;
+            },
+            spawn: (def) => {
+                world.guard("world.spawn");
+                return world.spawn(def);
+            },
+            destroy: (target) => {
+                world.guard("world.destroy");
+                const e = world.resolve(target);
+                if (e)
+                    world.remove(e);
+            },
+            kill: (target) => {
+                world.guard("world.kill");
+                const e = world.resolve(target);
+                if (!e)
+                    return;
+                if (isPlayer(e))
+                    world.kill(e, world.current?.entity.id ?? "script");
+                else
+                    world.remove(e);
+            },
+            win: () => {
+                world.guard("world.win");
+                if (world.won)
+                    return;
+                const by = world.current?.entity;
+                world.won = true;
+                world.emit({ type: "win", entity: by?.id ?? "script", goal: by?.id ?? "script", x: by?.transform.x ?? 0, y: by?.transform.y ?? 0 });
+            },
+            emit: (name, data) => {
+                world.guard("world.emit");
+                if (typeof name !== "string" || name === "")
+                    throw world.misuse("world.emit needs a non-empty event name.");
+                if (EVENT_TYPES.includes(name)) {
+                    throw world.misuse(`"${name}" is a built-in event and can't be emitted by scripts. Pick another name, e.g. "${name}-custom".`);
+                }
+                const by = world.current?.entity;
+                world.emit({ type: "custom", name, entity: by?.id ?? "script", data, x: by?.transform.x ?? 0, y: by?.transform.y ?? 0 });
+            },
+            random: () => {
+                world.guard("world.random (it advances the game's seed; use ctx.random in draw hooks)");
+                return world.random();
+            },
+        };
+        return this.scriptApi;
+    }
+    spawn(def) {
+        if (typeof def !== "object" || def === null || typeof def.components !== "object") {
+            throw this.misuse('world.spawn needs { components: { ... } }, e.g. { components: { transform: { x: 0, y: 0 } } }.');
+        }
+        const id = def.id ?? `${this.current?.entity.id ?? "spawned"}-${++this.spawnCount}`;
+        if (this.get(id))
+            throw this.misuse(`world.spawn: an entity with id "${id}" already exists. Leave id out to get a unique one.`);
+        const { diagnostics } = validateScene({ entities: [{ id, components: def.components }] });
+        const errors = diagnostics.filter((d) => d.severity === "error" && d.code !== "E_GOAL_UNREACHABLE");
+        if (errors.length > 0) {
+            const details = errors.map((d) => `${d.path.replace("entities[0]", id)}: ${d.message}${d.fix ? ` Fix: ${d.fix}` : ""}`);
+            throw this.misuse(`world.spawn got an invalid entity. ${details.join(" ")}`);
+        }
+        const entity = this.createEntity({ id, components: def.components });
+        this.entities.push(entity);
+        return this.handle(entity);
+    }
+    /** mulberry32, seeded by world.seed. */
+    random() {
+        this.seed = (this.seed + 0x6d2b79f5) | 0;
+        let t = this.seed;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    // ------------------------------------------------------------ built-ins
+    /** Entities the player controls: platformers and topdown movers. */
     players() {
-        return this.entities.filter((e) => e.platformer && e.body);
+        return this.entities.filter(isPlayer);
+    }
+    updateTopdown(held) {
+        for (const e of this.entities) {
+            const t = e.topdown;
+            const b = e.body;
+            if (!t || !b)
+                continue;
+            let dx = (held.has("right") ? 1 : 0) - (held.has("left") ? 1 : 0);
+            let dy = (held.has("down") ? 1 : 0) - (held.has("up") ? 1 : 0);
+            if (t.directions === "x")
+                dy = 0;
+            if (t.directions === "y")
+                dx = 0;
+            if (t.directions === "4" && dx !== 0)
+                dy = 0;
+            // Diagonals move at the same speed as straight lines.
+            const length = Math.hypot(dx, dy) || 1;
+            b.vx = (dx / length) * t.speed;
+            b.vy = (dy / length) * t.speed;
+        }
     }
     updatePlatformers(held, pressed) {
-        for (const e of this.players()) {
+        for (const e of this.entities) {
             const p = e.platformer;
             const b = e.body;
+            if (!p || !b)
+                continue;
             const direction = (held.has("right") ? 1 : 0) - (held.has("left") ? 1 : 0);
             b.vx = direction * p.speed;
             // Timers get a tiny extra margin so a value of 0 still allows a jump on the exact frame.
@@ -111,11 +451,15 @@ export class World {
                 b.standingOn = undefined;
                 p.bufferTimer = 0;
                 p.coyoteTimer = 0;
+                p.jumping = true;
                 this.emit({ type: "jump", entity: e.id, ...feet(e) });
             }
-            else if (p.variableJump && !held.has("jump") && b.vy < -p.jumpSpeed * JUMP_CUT) {
+            else if (p.jumping && p.variableJump && !held.has("jump") && b.vy < -p.jumpSpeed * JUMP_CUT) {
+                // Only the player's own jumps are cut short; launches from pads, stomps or scripts are not.
                 b.vy = -p.jumpSpeed * JUMP_CUT;
             }
+            if (b.vy >= 0)
+                p.jumping = false;
             p.coyoteTimer = Math.max(0, p.coyoteTimer - FIXED_DT);
             p.bufferTimer = Math.max(0, p.bufferTimer - FIXED_DT);
         }
@@ -142,15 +486,27 @@ export class World {
     updateBodies() {
         // Kinematic bodies move first, so anything standing on them can follow.
         const moved = new Map();
+        const walls = this.entities.filter((e) => e.body?.type === "static" && !e.body.sensor);
         for (const e of this.entities) {
             const b = e.body;
             if (!b || b.type !== "kinematic")
                 continue;
             const { x, y } = e.transform;
             e.transform.x += b.vx * FIXED_DT;
+            // A player-steered kinematic body (a paddle) stops at walls; scripted movers pass through.
+            if (e.topdown)
+                for (const wall of walls)
+                    if (overlaps(e, wall))
+                        e.transform.x = wall.transform.x + (Math.sign(e.transform.x - wall.transform.x) * (wall.body.width + b.width)) / 2;
             e.transform.y += b.vy * FIXED_DT;
+            if (e.topdown)
+                for (const wall of walls)
+                    if (overlaps(e, wall))
+                        e.transform.y = wall.transform.y + (Math.sign(e.transform.y - wall.transform.y) * (wall.body.height + b.height)) / 2;
             if (e.patrol)
                 clampToPatrol(e, e.patrol);
+            if (e.topdown?.clampToWorld)
+                this.clampToWorld(e);
             moved.set(e, { dx: e.transform.x - x, dy: e.transform.y - y });
         }
         const solids = this.entities.filter((e) => e.body && !e.body.sensor && e.body.type !== "dynamic");
@@ -163,7 +519,9 @@ export class World {
                 e.transform.x += carried.dx;
                 e.transform.y += carried.dy;
             }
-            b.vy = Math.min(b.vy + this.gravity * b.gravityScale * FIXED_DT, MAX_FALL_SPEED);
+            // Top-down movers ignore gravity; everything else falls.
+            if (!e.topdown)
+                b.vy = Math.min(b.vy + this.gravity * b.gravityScale * FIXED_DT, MAX_FALL_SPEED);
             const wasGrounded = b.grounded;
             b.grounded = false;
             b.standingOn = undefined;
@@ -177,27 +535,48 @@ export class World {
                     e.transform.x = solid.transform.x - half;
                 else if (b.vx < 0)
                     e.transform.x = solid.transform.x + half;
-                b.vx = 0;
+                b.vx = this.rebound(e, solid, b.vx);
             }
             e.transform.y += b.vy * FIXED_DT;
             for (const solid of solids) {
                 if (!overlaps(e, solid))
                     continue;
                 const half = (solid.body.height + b.height) / 2;
-                if (b.vy > 0) {
+                const falling = b.vy > 0;
+                if (b.vy > 0)
                     e.transform.y = solid.transform.y - half;
+                else if (b.vy < 0)
+                    e.transform.y = solid.transform.y + half;
+                b.vy = this.rebound(e, solid, b.vy);
+                // A body that stopped on top of something is standing on it; one that bounced off is airborne.
+                if (falling && b.vy === 0) {
                     b.grounded = true;
                     b.standingOn = solid;
                 }
-                else if (b.vy < 0) {
-                    e.transform.y = solid.transform.y + half;
-                }
-                b.vy = 0;
             }
+            if (e.topdown?.clampToWorld)
+                this.clampToWorld(e);
             if (b.grounded && !wasGrounded)
                 this.emit({ type: "land", entity: e.id, ...feet(e) });
         }
     }
+    /**
+     * The velocity along one axis after hitting `solid`: 0, or reversed and scaled by `bounce`.
+     * Slow impacts stop instead, so resting bodies don't jitter.
+     */
+    rebound(e, solid, velocity) {
+        const bounce = e.body.bounce;
+        if (bounce <= 0 || Math.abs(velocity) * bounce < MIN_BOUNCE_SPEED)
+            return 0;
+        this.emit({ type: "bounce", entity: e.id, other: solid.id, ...e.transform });
+        return -velocity * bounce;
+    }
+    clampToWorld(e) {
+        const halfWidth = (e.body?.width ?? 0) / 2;
+        const halfHeight = (e.body?.height ?? 0) / 2;
+        e.transform.x = Math.min(this.width - halfWidth, Math.max(halfWidth, e.transform.x));
+        e.transform.y = Math.min(this.height - halfHeight, Math.max(halfHeight, e.transform.y));
+    }
     updateCollectibles() {
         const players = this.players();
         for (const item of this.entities.filter((e) => e.collectible && e.body)) {
@@ -219,7 +598,7 @@ export class World {
             for (const hazard of this.entities.filter((e) => e.hazard && e.body)) {
                 if (!overlaps(player, hazard))
                     continue;
-                if (hazard.hazard.stompable && isStomp(player, hazard)) {
+                if (hazard.hazard.stompable && player.platformer && isStomp(player, hazard)) {
                     this.remove(hazard);
                     b.vy = -player.platformer.jumpSpeed * STOMP_BOUNCE;
                     this.score += hazard.hazard.score;
@@ -246,23 +625,26 @@ export class World {
     /** Sends a player back to where it started. Collected items stay collected. */
     kill(player, cause) {
         const b = player.body;
-        const p = player.platformer;
         this.deaths++;
         this.emit({ type: "die", entity: player.id, cause, ...player.transform });
-        player.transform.x = p.spawnX;
-        player.transform.y = p.spawnY;
+        player.transform.x = player.spawn?.x ?? player.transform.x;
+        player.transform.y = player.spawn?.y ?? player.transform.y;
         b.vx = 0;
         b.vy = 0;
         b.grounded = false;
         b.standingOn = undefined;
-        p.coyoteTimer = 0;
-        p.bufferTimer = 0;
+        const p = player.platformer;
+        if (p) {
+            p.coyoteTimer = 0;
+            p.bufferTimer = 0;
+            p.jumping = false;
+        }
     }
 }
 function createEntity(def) {
     const c = def.components;
     const transform = c.transform ? resolveComponent("transform", c.transform) : { x: 0, y: 0 };
-    const entity = { id: def.id, transform };
+    const entity = { id: def.id, state: {}, transform };
     if (c.body)
         entity.body = { ...resolveComponent("body", c.body), grounded: false };
     if (c.sprite)
@@ -272,10 +654,13 @@ function createEntity(def) {
             ...resolveComponent("platformer", c.platformer),
             coyoteTimer: 0,
             bufferTimer: 0,
-            spawnX: transform.x,
-            spawnY: transform.y,
+            jumping: false,
         };
     }
+    if (c.topdown)
+        entity.topdown = resolveComponent("topdown", c.topdown);
+    if (entity.platformer || entity.topdown)
+        entity.spawn = { x: transform.x, y: transform.y };
     if (c.collectible)
         entity.collectible = resolveComponent("collectible", c.collectible);
     if (c.patrol)
@@ -290,6 +675,9 @@ function createEntity(def) {
         entity.camera = resolveComponent("camera", c.camera);
     return entity;
 }
+function isPlayer(e) {
+    return !!(e.platformer || e.topdown) && !!e.body;
+}
 function feet(e) {
     return { x: e.transform.x, y: e.transform.y + (e.body?.height ?? 0) / 2 };
 }
@@ -308,10 +696,13 @@ function isStomp(player, enemy) {
     const enemyTop = enemy.transform.y - enemy.body.height / 2;
     return previousBottom <= enemyTop + STOMP_TOLERANCE;
 }
-/** Strict overlap: bodies that merely touch (e.g. standing on the ground) do not overlap. */
-export function overlaps(a, b) {
+/**
+ * Strict overlap: bodies that merely touch (e.g. standing on the ground) do not overlap.
+ * A positive `margin` grows both boxes, so touching counts too.
+ */
+export function overlaps(a, b, margin = 0) {
     if (!a.body || !b.body)
         return false;
-    return (Math.abs(a.transform.x - b.transform.x) < (a.body.width + b.body.width) / 2 - EPSILON &&
-        Math.abs(a.transform.y - b.transform.y) < (a.body.height + b.body.height) / 2 - EPSILON);
+    return (Math.abs(a.transform.x - b.transform.x) < (a.body.width + b.body.width) / 2 + margin - EPSILON &&
+        Math.abs(a.transform.y - b.transform.y) < (a.body.height + b.body.height) / 2 + margin - EPSILON);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ludra/core",
-  "version": "0.4.0",
+  "version": "0.7.0",
   "description": "Ludra engine runtime: scene format, validation, deterministic simulation and rendering.",
   "license": "MIT",
   "repository": {

package/src/ascii.ts

@@ -48,8 +48,8 @@ export function renderAscii(world: World, options: AsciiOptions = {}): string {
     ["G", (e) => !!e.goal],
     ["^", (e) => !!e.hazard && e.body!.type !== "kinematic"],
     ["E", (e) => !!e.hazard && e.body!.type === "kinematic"],
-    ["D", (e) => e.body!.type === "dynamic" && !e.platformer],
-    ["@", (e) => !!e.platformer],
+    ["D", (e) => e.body!.type === "dynamic" && !e.platformer && !e.topdown],
+    ["@", (e) => !!(e.platformer || e.topdown)],
   ];
   for (const [char, test] of passes) {
     for (const e of withBody.filter(test)) paint(e, char);