@cyclonium/physics-2d 0.0.100

package/lib/body-collider-link.d.ts

@@ -0,0 +1,32 @@
+import { RigidBody2D } from './rigid-body-2d.js';
+import { Collider2D } from './collider-2d.js';
+export declare class BodyColliderLink {
+    constructor(rigidBody: RigidBody2D);
+    get rigidBody(): RigidBody2D;
+    get colliders(): Collider2D[];
+    disband(): void;
+    linkCollider(collider: Collider2D): void;
+    removeCollider(collider: Collider2D): boolean;
+    enableCollisionEventsFromBody(value: boolean): void;
+    setBodyActiveCollisionTypes(value: number): void;
+    setBodyCollisionGroups(value: number): void;
+    setBodySolverGroups(value: number): void;
+    private _rigidBody;
+    private _colliders;
+    private _isBodyRequiresCollisionEvents;
+    private _bodyActiveCollisionTypes;
+    private _bodyCollisionGroups;
+    private _bodySolverGroups;
+}
+export declare class BodyColliderLinkManager {
+    getLinkedRigidBody(collider: Collider2D): BodyColliderLink | null;
+    joinRigidBody(rigidBody: RigidBody2D): BodyColliderLink;
+    removeRigidBody(rigidBody: RigidBody2D): boolean;
+    joinCollider(collider: Collider2D): void;
+    removeCollider(collider: Collider2D): boolean;
+    private _colliderLinks;
+    private _rigidBodyLinks;
+    private _findRigidBodyToAttach;
+    private _findBelongingColliders;
+}
+//# sourceMappingURL=body-collider-link.d.ts.map

package/lib/body-collider-link.js

@@ -0,0 +1,164 @@
+import { Scene } from 'cc';
+import { RigidBody2D } from './rigid-body-2d.js';
+import { Collider2D } from './collider-2d.js';
+import { logger } from '@cyclonium/core/log';
+export class BodyColliderLink {
+    constructor(rigidBody) {
+        this._rigidBody = rigidBody;
+    }
+    get rigidBody() {
+        return this._rigidBody;
+    }
+    get colliders() {
+        return this._colliders;
+    }
+    disband() {
+        for (const collider of this._colliders) {
+            collider._enableCollisionEventsSinceBody(false);
+            collider._responseToBodyCollisionGroups(0);
+            collider._responseToBodySolverGroups(0);
+            collider._responseToBodyActiveCollisionTypes(0);
+        }
+        this._colliders.length = 0;
+    }
+    linkCollider(collider) {
+        if (this._colliders.indexOf(collider) >= 0) {
+            throw new Error(`Collider ${collider.name} already joined to body ${this._rigidBody?.name}.`);
+        }
+        this._colliders.push(collider);
+        if (this._isBodyRequiresCollisionEvents) {
+            collider._enableCollisionEventsSinceBody(true);
+        }
+        collider._responseToBodyCollisionGroups(this._bodyCollisionGroups);
+        collider._responseToBodySolverGroups(this._bodySolverGroups);
+        collider._responseToBodyActiveCollisionTypes(this._bodyActiveCollisionTypes);
+    }
+    removeCollider(collider) {
+        const index = this._colliders.indexOf(collider);
+        if (index >= 0) {
+            this._colliders.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    enableCollisionEventsFromBody(value) {
+        this._isBodyRequiresCollisionEvents = value;
+        for (const collider of this._colliders) {
+            collider._enableCollisionEventsSinceBody(value);
+        }
+    }
+    setBodyActiveCollisionTypes(value) {
+        this._bodyActiveCollisionTypes = value;
+        for (const collider of this._colliders) {
+            collider._responseToBodyActiveCollisionTypes(value);
+        }
+    }
+    setBodyCollisionGroups(value) {
+        this._bodyCollisionGroups = value;
+        for (const collider of this._colliders) {
+            collider._responseToBodyCollisionGroups(value);
+        }
+    }
+    setBodySolverGroups(value) {
+        this._bodySolverGroups = value;
+        for (const collider of this._colliders) {
+            collider._responseToBodySolverGroups(value);
+        }
+    }
+    _rigidBody;
+    _colliders = [];
+    _isBodyRequiresCollisionEvents = false;
+    _bodyActiveCollisionTypes = 0;
+    _bodyCollisionGroups = 0;
+    _bodySolverGroups = 0;
+}
+export class BodyColliderLinkManager {
+    getLinkedRigidBody(collider) {
+        return this._colliderLinks.get(collider) ?? null;
+    }
+    joinRigidBody(rigidBody) {
+        if (rigidBody.node.getComponents(RigidBody2D).length > 1) {
+            throw new Error(`RigidBody is not unique in node ${rigidBody.node.name}.`);
+        }
+        if (this._rigidBodyLinks.has(rigidBody)) {
+            throw new Error(`RigidBody ${rigidBody.name} already joined.`);
+        }
+        const link = new BodyColliderLink(rigidBody);
+        this._rigidBodyLinks.set(rigidBody, link);
+        for (const collider of this._findBelongingColliders(rigidBody)) {
+            const oldLink = this._colliderLinks.get(collider);
+            if (oldLink === undefined) {
+                // Never joined.
+                continue;
+            }
+            if (oldLink) {
+                logger.warn(`Note: relinking collider ${collider.name} to body ${rigidBody.name}(previous: ${oldLink.rigidBody.name}).`);
+                oldLink.removeCollider(collider);
+            }
+            link.linkCollider(collider);
+            this._colliderLinks.set(collider, link);
+        }
+        return link;
+    }
+    removeRigidBody(rigidBody) {
+        const link = this._rigidBodyLinks.get(rigidBody);
+        if (!link) {
+            return false;
+        }
+        // TODO: should relink colliders to another body?
+        for (const collider of link.colliders) {
+            this._colliderLinks.set(collider, null);
+        }
+        link.disband();
+        this._rigidBodyLinks.delete(rigidBody);
+        return true;
+    }
+    joinCollider(collider) {
+        const attachedRigidBody = this._findRigidBodyToAttach(collider);
+        const bodyLink = attachedRigidBody
+            ? this._rigidBodyLinks.get(attachedRigidBody) ?? null
+            : null;
+        if (bodyLink) {
+            bodyLink.linkCollider(collider);
+        }
+        this._colliderLinks.set(collider, bodyLink);
+    }
+    removeCollider(collider) {
+        const bodyLink = this._colliderLinks.get(collider);
+        if (bodyLink === undefined) {
+            // Never joined.
+            return false;
+        }
+        if (!bodyLink) {
+            // Joined, but not linked to a rigid body.
+            return true;
+        }
+        const success = bodyLink.removeCollider(collider);
+        return success;
+    }
+    _colliderLinks = new Map();
+    _rigidBodyLinks = new Map();
+    _findRigidBodyToAttach(collider) {
+        for (let current = collider.node; current && !(current instanceof Scene); current = current.parent) {
+            const rigidBody = RigidBody2D.ofOrNull(current);
+            if (rigidBody) {
+                return rigidBody;
+            }
+        }
+        return null;
+    }
+    *_findBelongingColliders(rigidBody) {
+        yield* lsNode(rigidBody.node);
+        function* lsNode(node) {
+            const colliders = node.getComponents(Collider2D);
+            yield* colliders;
+            for (const child of node.children) {
+                if (RigidBody2D.ofOrNull(child)) {
+                    continue;
+                }
+                yield* lsNode(child);
+            }
+        }
+    }
+}
+//# sourceMappingURL=body-collider-link.js.map

package/lib/character-controller-2d.d.ts

@@ -0,0 +1,69 @@
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { px2Impl } from './px2-impl.js';
+import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
+import type { PhysicsWorld2D } from './physics-world-2d.js';
+import { Collider2D } from './collider-2d.js';
+export declare class KinematicCharacterController2D extends PhysicsComponent2DBase {
+    get skinWidth(): number;
+    set skinWidth(value: number);
+    get up(): Vec2;
+    set up(value: Vec2);
+    get slideEnabled(): boolean;
+    set slideEnabled(value: boolean);
+    get minSlopeSlideAngle(): number;
+    set minSlopeSlideAngle(value: number);
+    get maxSlopeClimbAngle(): number;
+    set maxSlopeClimbAngle(value: number);
+    get autoStepEnabled(): boolean;
+    set autoStepEnabled(value: boolean);
+    get autoStepMaxHeight(): number;
+    set autoStepMaxHeight(value: number);
+    get autoStepMinWidth(): number;
+    set autoStepMinWidth(value: number);
+    get autoStepIncludeDynamicBodies(): boolean;
+    set autoStepIncludeDynamicBodies(value: boolean);
+    get snapToGroundEnabled(): boolean;
+    set snapToGroundEnabled(value: boolean);
+    get snapToGroundDistance(): number;
+    set snapToGroundDistance(value: number);
+    get applyImpulsesToDynamicBodies(): boolean;
+    set applyImpulsesToDynamicBodies(value: boolean);
+    get lastMovement(): Vec2;
+    get grounded(): boolean;
+    get listenersOnCollisionBegin(): import("@cyclonium/event").EventListenerRegistry<[CharacterCollision]>;
+    get listenersOnCollisionStay(): import("@cyclonium/event").EventListenerRegistry<[CharacterCollision]>;
+    get listenersOnCollisionEnd(): import("@cyclonium/event").EventListenerRegistry<[CharacterCollision]>;
+    get impl(): px2Impl.KinematicCharacterController | undefined;
+    move(desiredMovement: Vec2, deltaTime: number): void;
+    protected onDestroy(): void;
+    protected onAttachToWorld(world: PhysicsWorld2D): void;
+    protected onDetachFromWorld(world: PhysicsWorld2D): void;
+    protected onAfterPhysicsStep(): void;
+    private _impl;
+    private _skinWidth;
+    private _up;
+    private _slideEnabled;
+    private _minSlopeSlideAngle;
+    private _maxSlopeClimbAngle;
+    private _autoStepEnabled;
+    private _autoStepMaxHeight;
+    private _autoStepMinWidth;
+    private _autoStepIncludeDynamicBodies;
+    private _snapToGroundEnabled;
+    private _snapToGroundDistance;
+    private _applyImpulsesToDynamicBodies;
+    private _lastMovement;
+    private _collisionRecords;
+    private _emitterOnCollisionBegin;
+    private _emitterOnCollisionStay;
+    private _emitterOnCollisionEnd;
+    private _updateSlideEnabled;
+    private _updateAutoStepParams;
+    private _updateSnapToGroundParams;
+    private _destroyImpl;
+    private _emitCharacterCollisionEvents;
+}
+export interface CharacterCollision {
+    collider: Collider2D;
+}
+//# sourceMappingURL=character-controller-2d.d.ts.map

package/lib/character-controller-2d.js

@@ -0,0 +1,399 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { editable, idem, idemBy, serializable } from '@cyclonium/core/legacy-decorator';
+import { Vec2 } from '@cyclonium/core/math/vec2';
+import { fromPx2ImplVec2, toPx2ImplVec2 } from './exchange.js';
+import { px2Impl } from './px2-impl.js';
+import { PhysicsComponent2DBase } from './physics-component-2d-base.js';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { assert } from '@cyclonium/core/utils';
+import { Collider2D } from './collider-2d.js';
+import { RigidBody2DType } from './rigid-body-2d.js';
+import { Transform2DComponent } from '@cyclonium/core/2d';
+import { toRadians } from '@cyclonium/core/math/trigonometry';
+import { ManagedEventEmitter } from '@cyclonium/event';
+import { logger } from '@cyclonium/core/log';
+import { prune } from '@cyclonium/algorithm/prune';
+var PropertyGroup;
+(function (PropertyGroup) {
+    PropertyGroup["common"] = "Common";
+    PropertyGroup["slope"] = "Slope";
+    PropertyGroup["autoStep"] = "Auto Step";
+    PropertyGroup["snapToGround"] = "Snap To Ground";
+})(PropertyGroup || (PropertyGroup = {}));
+let KinematicCharacterController2D = class KinematicCharacterController2D extends PhysicsComponent2DBase {
+    get skinWidth() {
+        return this._skinWidth;
+    }
+    set skinWidth(value) {
+        this._skinWidth = value;
+        this._impl?.setOffset(value);
+    }
+    get up() {
+        return this._up;
+    }
+    set up(value) {
+        Vec2.assign(this._up, value);
+        this._impl?.setUp(toPx2ImplVec2(value));
+    }
+    get slideEnabled() {
+        return this._slideEnabled;
+    }
+    set slideEnabled(value) {
+        this._slideEnabled = value;
+        this._updateSlideEnabled();
+    }
+    get minSlopeSlideAngle() {
+        return this._minSlopeSlideAngle;
+    }
+    set minSlopeSlideAngle(value) {
+        this._minSlopeSlideAngle = value;
+        this._impl?.setMinSlopeSlideAngle(value);
+    }
+    get maxSlopeClimbAngle() {
+        return this._maxSlopeClimbAngle;
+    }
+    set maxSlopeClimbAngle(value) {
+        this._maxSlopeClimbAngle = value;
+        this._impl?.setMaxSlopeClimbAngle(value);
+    }
+    get autoStepEnabled() {
+        return this._autoStepEnabled;
+    }
+    set autoStepEnabled(value) {
+        this._autoStepEnabled = value;
+        this._updateAutoStepParams();
+    }
+    get autoStepMaxHeight() {
+        return this._autoStepMaxHeight;
+    }
+    set autoStepMaxHeight(value) {
+        this._autoStepMaxHeight = value;
+        this._updateAutoStepParams();
+    }
+    get autoStepMinWidth() {
+        return this._autoStepMinWidth;
+    }
+    set autoStepMinWidth(value) {
+        this._autoStepMinWidth = value;
+        this._updateAutoStepParams();
+    }
+    get autoStepIncludeDynamicBodies() {
+        return this._autoStepIncludeDynamicBodies;
+    }
+    set autoStepIncludeDynamicBodies(value) {
+        this._autoStepIncludeDynamicBodies = value;
+        this._updateAutoStepParams();
+    }
+    get snapToGroundEnabled() {
+        return this._snapToGroundEnabled;
+    }
+    set snapToGroundEnabled(value) {
+        this._snapToGroundEnabled = value;
+        this._updateSnapToGroundParams();
+    }
+    get snapToGroundDistance() {
+        return this._snapToGroundDistance;
+    }
+    set snapToGroundDistance(value) {
+        this._snapToGroundDistance = value;
+        this._updateSnapToGroundParams();
+    }
+    get applyImpulsesToDynamicBodies() {
+        return this._applyImpulsesToDynamicBodies;
+    }
+    set applyImpulsesToDynamicBodies(value) {
+        this._applyImpulsesToDynamicBodies = value;
+        this._impl?.setApplyImpulsesToDynamicBodies(value);
+    }
+    get lastMovement() {
+        return this._lastMovement;
+    }
+    get grounded() {
+        return this._impl?.computedGrounded() ?? false;
+    }
+    get listenersOnCollisionBegin() {
+        return this._emitterOnCollisionBegin.registry;
+    }
+    get listenersOnCollisionStay() {
+        return this._emitterOnCollisionStay.registry;
+    }
+    get listenersOnCollisionEnd() {
+        return this._emitterOnCollisionEnd.registry;
+    }
+    get impl() {
+        return this._impl;
+    }
+    move(desiredMovement, deltaTime) {
+        const impl = this._impl;
+        if (!impl) {
+            return;
+        }
+        const collider = Collider2D.ofOrNull(this);
+        if (!collider || !collider.impl_internal) {
+            return;
+        }
+        const world = this.world;
+        if (!world) {
+            return;
+        }
+        impl.computeColliderMovement(collider.impl_internal, toPx2ImplVec2(desiredMovement), undefined, collider.impl_internal.collisionGroups());
+        const movement = fromPx2ImplVec2(impl.computedMovement());
+        Vec2.assign(this._lastMovement, movement);
+        const rigidBody = collider.attachedRigidBody;
+        if (!rigidBody || !rigidBody.impl) {
+            const newPosition = fromPx2ImplVec2(collider.impl_internal.translation()).add(movement);
+            Transform2DComponent.of(collider).position = newPosition;
+            collider.impl_internal.setTranslation(toPx2ImplVec2(newPosition));
+        }
+        else if (rigidBody.type === RigidBody2DType.kinematicVelocityBased) {
+            rigidBody.linearVelocity = movement.mulScalar(1 / deltaTime);
+        }
+        else {
+            const currentPosition = fromPx2ImplVec2(rigidBody.impl.nextTranslation());
+            const newPosition = fromPx2ImplVec2(currentPosition).add(movement);
+            Transform2DComponent.of(collider).position = newPosition;
+            rigidBody.impl.setNextKinematicTranslation(toPx2ImplVec2(newPosition));
+        }
+        this._emitCharacterCollisionEvents(impl, world);
+    }
+    onDestroy() {
+        super.onDestroy();
+        this._destroyImpl();
+    }
+    onAttachToWorld(world) {
+        assert(!this._impl);
+        const impl = this._impl = world.impl.createCharacterController(this._skinWidth);
+        impl.setOffset(this._skinWidth);
+        impl.setMinSlopeSlideAngle(this._minSlopeSlideAngle);
+        impl.setMaxSlopeClimbAngle(this._maxSlopeClimbAngle);
+        impl.setUp(toPx2ImplVec2(this._up));
+        this._updateSlideEnabled();
+        this._updateAutoStepParams();
+        this._updateSnapToGroundParams();
+        impl.setApplyImpulsesToDynamicBodies(this._applyImpulsesToDynamicBodies);
+    }
+    onDetachFromWorld(world) {
+        void world;
+        this._destroyImpl();
+    }
+    onAfterPhysicsStep() {
+        void 0;
+    }
+    _impl;
+    _skinWidth = 0.01;
+    _up = Vec2.UNIT_Y.clone();
+    _slideEnabled = true;
+    _minSlopeSlideAngle = toRadians(30);
+    _maxSlopeClimbAngle = toRadians(45);
+    _autoStepEnabled = true;
+    _autoStepMaxHeight = 0.1;
+    _autoStepMinWidth = 0.1;
+    _autoStepIncludeDynamicBodies = false;
+    _snapToGroundEnabled = true;
+    _snapToGroundDistance = 0.1;
+    _applyImpulsesToDynamicBodies = false;
+    _lastMovement = Vec2.ZERO.clone();
+    _collisionRecords = [];
+    _emitterOnCollisionBegin = new ManagedEventEmitter();
+    _emitterOnCollisionStay = new ManagedEventEmitter();
+    _emitterOnCollisionEnd = new ManagedEventEmitter();
+    _updateSlideEnabled() {
+        this._impl?.setSlideEnabled(this._slideEnabled);
+    }
+    _updateAutoStepParams() {
+        if (this._autoStepEnabled) {
+            this._impl?.enableAutostep(this._autoStepMaxHeight, this._autoStepMinWidth, this._autoStepIncludeDynamicBodies);
+        }
+        else {
+            this._impl?.disableAutostep();
+        }
+    }
+    _updateSnapToGroundParams() {
+        if (this._snapToGroundEnabled) {
+            this._impl?.enableSnapToGround(this._snapToGroundDistance);
+        }
+        else {
+            this._impl?.disableSnapToGround();
+        }
+    }
+    _destroyImpl() {
+        if (!this._impl) {
+            return;
+        }
+        const world = this.world;
+        world?.impl.removeCharacterController(this._impl);
+        this._impl = undefined;
+    }
+    _emitCharacterCollisionEvents(impl, world) {
+        const nComputedCollisions = impl.numComputedCollisions();
+        for (let i = 0; i < nComputedCollisions; i++) {
+            const collision = impl.computedCollision(i);
+            assert(collision);
+            if (!collision.collider) {
+                logger.warn('a computed collision with null collider.');
+                continue;
+            }
+            const collider = world._getCollider(collision.collider);
+            if (!collider) {
+                logger.warn('a computed collision with a collider that is not(or has been destroyed) in our physics world.');
+                continue;
+            }
+            const iExistingRecord = this._collisionRecords.findIndex((record) => record.collider === collider);
+            if (iExistingRecord < 0) {
+                // new collision
+                this._collisionRecords.push({
+                    collider,
+                    colliderName_debug: collider.node.getPathInHierarchy(),
+                    state: CollisionRecordState.begin,
+                });
+            }
+            else {
+                const record = this._collisionRecords[iExistingRecord];
+                if (record.state === CollisionRecordState.stayStale) {
+                    record.state = CollisionRecordState.stay;
+                }
+                else {
+                    // That indeed happens.
+                    // logger.warn(`Received more than once collision with collider ${collider.node.getPathInHierarchy()}?`);
+                }
+            }
+        }
+        for (const record of this._collisionRecords) {
+            const collision = {
+                collider: record.collider,
+            };
+            switch (record.state) {
+                case CollisionRecordState.begin:
+                    record.state = CollisionRecordState.stayStale;
+                    this._emitterOnCollisionBegin.emit(collision);
+                    break;
+                case CollisionRecordState.stay:
+                    record.state = CollisionRecordState.stayStale;
+                    this._emitterOnCollisionStay.emit(collision);
+                    break;
+                case CollisionRecordState.stayStale:
+                    record.state = CollisionRecordState.end;
+                    if (!record.collider.isValid) {
+                        logger.verbose(`[NOTICE] a previous-colliding collider ${record.colliderName_debug ?? '<the name was not recorded>'} is no longer valid, no collision end event will be emitted.`);
+                        continue;
+                    }
+                    this._emitterOnCollisionEnd.emit(collision);
+                    break;
+            }
+        }
+        prune(this._collisionRecords, (record) => record.state !== CollisionRecordState.end);
+    }
+};
+__decorate([
+    editable,
+    idem
+], KinematicCharacterController2D.prototype, "skinWidth", null);
+__decorate([
+    editable,
+    idemBy(Vec2.strictEquals)
+], KinematicCharacterController2D.prototype, "up", null);
+__decorate([
+    editable,
+    idem
+], KinematicCharacterController2D.prototype, "slideEnabled", null);
+__decorate([
+    editable({ group: PropertyGroup.slope, radian: true }),
+    idem
+], KinematicCharacterController2D.prototype, "minSlopeSlideAngle", null);
+__decorate([
+    editable({ group: PropertyGroup.slope, radian: true }),
+    idem
+], KinematicCharacterController2D.prototype, "maxSlopeClimbAngle", null);
+__decorate([
+    editable({ group: PropertyGroup.autoStep }),
+    idem
+], KinematicCharacterController2D.prototype, "autoStepEnabled", null);
+__decorate([
+    editable({ group: PropertyGroup.autoStep }),
+    idem
+], KinematicCharacterController2D.prototype, "autoStepMaxHeight", null);
+__decorate([
+    editable({ group: PropertyGroup.autoStep }),
+    idem
+], KinematicCharacterController2D.prototype, "autoStepMinWidth", null);
+__decorate([
+    editable({ group: PropertyGroup.autoStep }),
+    idem
+], KinematicCharacterController2D.prototype, "autoStepIncludeDynamicBodies", null);
+__decorate([
+    editable({ group: PropertyGroup.snapToGround }),
+    idem
+], KinematicCharacterController2D.prototype, "snapToGroundEnabled", null);
+__decorate([
+    editable({ group: PropertyGroup.snapToGround }),
+    idem
+], KinematicCharacterController2D.prototype, "snapToGroundDistance", null);
+__decorate([
+    editable,
+    idem
+], KinematicCharacterController2D.prototype, "applyImpulsesToDynamicBodies", null);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_skinWidth", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_up", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_slideEnabled", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_minSlopeSlideAngle", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_maxSlopeClimbAngle", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_autoStepEnabled", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_autoStepMaxHeight", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_autoStepMinWidth", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_autoStepIncludeDynamicBodies", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_snapToGroundEnabled", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_snapToGroundDistance", void 0);
+__decorate([
+    serializable
+], KinematicCharacterController2D.prototype, "_applyImpulsesToDynamicBodies", void 0);
+KinematicCharacterController2D = __decorate([
+    cycloBuiltinClass('KinematicCharacterController2D')
+], KinematicCharacterController2D);
+export { KinematicCharacterController2D };
+var CollisionRecordState;
+(function (CollisionRecordState) {
+    /**
+     * The character controller has just started colliding with the collider in this computation.
+     */
+    CollisionRecordState[CollisionRecordState["begin"] = 0] = "begin";
+    /**
+     * The character controller was colliding with the collider after last computation.
+     */
+    CollisionRecordState[CollisionRecordState["stayStale"] = 1] = "stayStale";
+    /**
+     * The character controller is colliding with the collider in this computation.
+     */
+    CollisionRecordState[CollisionRecordState["stay"] = 2] = "stay";
+    /**
+     * The character controller was not colliding with the collider in this computation.
+     */
+    CollisionRecordState[CollisionRecordState["end"] = 3] = "end";
+})(CollisionRecordState || (CollisionRecordState = {}));
+//# sourceMappingURL=character-controller-2d.js.map