chore: rename Event to KEvent (#179)

CHANGELOG.md

@@ -103,6 +103,8 @@ add([
 - deprecated `kaboom()` in favor of `kaplay()` (you can still use `kaboom*`)
 - deprecated `SpriteComp.curAnim()` in favor of `SpriteComp.getCurAnim().name`
 - deprecated `fadeIn` component in favor of `OpacityComp.fadeIn()`
+- deprecated `Event`, `EventHandler` and `EventController` in favor of `KEvent`,
+  `KEventHandler` and `KEventController`
 
 ### v3000.1.17
 

src/app.ts

@@ -15,9 +15,9 @@ import type {
 import { map, Vec2 } from "./math";
 
 import {
-    EventController,
-    EventHandler,
     isEqOrIncludes,
+    KEventController,
+    KEventHandler,
     overload2,
     setHasOrIncludes,
 } from "./utils";
@@ -109,7 +109,7 @@ export default (opt: {
         isMouseMoved: false,
         lastWidth: opt.canvas.offsetWidth,
         lastHeight: opt.canvas.offsetHeight,
-        events: new EventHandler<{
+        events: new KEventHandler<{
             mouseMove: [];
             mouseDown: [MouseButton];
             mousePress: [MouseButton];
@@ -432,7 +432,7 @@ export default (opt: {
         }
     }
 
-    function onResize(action: () => void): EventController {
+    function onResize(action: () => void): KEventController {
         return state.events.on("resize", action);
     }
 
@@ -507,38 +507,38 @@ export default (opt: {
         return state.events.on("mouseRelease", (m) => m === mouse && action(m));
     });
 
-    function onMouseMove(f: (pos: Vec2, dpos: Vec2) => void): EventController {
+    function onMouseMove(f: (pos: Vec2, dpos: Vec2) => void): KEventController {
         return state.events.on(
             "mouseMove",
             () => f(mousePos(), mouseDeltaPos()),
         );
     }
 
-    function onCharInput(action: (ch: string) => void): EventController {
+    function onCharInput(action: (ch: string) => void): KEventController {
         return state.events.on("charInput", action);
     }
 
-    function onTouchStart(f: (pos: Vec2, t: Touch) => void): EventController {
+    function onTouchStart(f: (pos: Vec2, t: Touch) => void): KEventController {
         return state.events.on("touchStart", f);
     }
 
-    function onTouchMove(f: (pos: Vec2, t: Touch) => void): EventController {
+    function onTouchMove(f: (pos: Vec2, t: Touch) => void): KEventController {
         return state.events.on("touchMove", f);
     }
 
-    function onTouchEnd(f: (pos: Vec2, t: Touch) => void): EventController {
+    function onTouchEnd(f: (pos: Vec2, t: Touch) => void): KEventController {
         return state.events.on("touchEnd", f);
     }
 
-    function onScroll(action: (delta: Vec2) => void): EventController {
+    function onScroll(action: (delta: Vec2) => void): KEventController {
         return state.events.on("scroll", action);
     }
 
-    function onHide(action: () => void): EventController {
+    function onHide(action: () => void): KEventController {
         return state.events.on("hide", action);
     }
 
-    function onShow(action: () => void): EventController {
+    function onShow(action: () => void): KEventController {
         return state.events.on("show", action);
     }
 
@@ -590,7 +590,7 @@ export default (opt: {
     function onGamepadStick(
         stick: GamepadStick,
         action: (value: Vec2) => void,
-    ): EventController {
+    ): KEventController {
         return state.events.on(
             "gamepadStick",
             (a: string, v: Vec2) => a === stick && action(v),

src/assets.ts

@@ -1,4 +1,4 @@
-import { Event } from "./utils";
+import { KEvent } from "./utils";
 
 /**
  * An asset is a resource that is loaded asynchronously.
@@ -7,9 +7,9 @@ export class Asset<D> {
     loaded: boolean = false;
     data: D | null = null;
     error: Error | null = null;
-    private onLoadEvents: Event<[D]> = new Event();
-    private onErrorEvents: Event<[Error]> = new Event();
-    private onFinishEvents: Event<[]> = new Event();
+    private onLoadEvents: KEvent<[D]> = new KEvent();
+    private onErrorEvents: KEvent<[Error]> = new KEvent();
+    private onFinishEvents: KEvent<[]> = new KEvent();
     constructor(loader: Promise<D>) {
         loader.then((data) => {
             this.loaded = true;

src/components/draw/particles.ts

@@ -2,7 +2,7 @@ import type { Texture } from "../../gfx";
 import { getKaboomContext } from "../../kaboom";
 import { Color, lerp, map, Quad, Vec2, vec2 } from "../../math";
 import type { Comp, ShapeType } from "../../types";
-import { Event } from "../../utils";
+import { KEvent } from "../../utils";
 
 class Particle {
     pos: Vec2;
@@ -64,7 +64,7 @@ export function particles(popt: ParticlesOpt, eopt: EmitterOpt): ParticlesComp {
     let count = 0;
     let time = 0;
 
-    const onEndEvents = new Event();
+    const onEndEvents = new KEvent();
 
     return {
         id: "particles",

src/components/draw/sprite.ts

@@ -11,7 +11,7 @@ import type {
     SpriteCurAnim,
     SpriteData,
 } from "../../types";
-import { Event, EventController } from "../../utils";
+import { KEvent, KEventController } from "../../utils";
 
 /**
  * The {@link sprite `sprite()`} component.
@@ -79,11 +79,11 @@ export interface SpriteComp extends Comp {
     /**
      * Register an event that runs when an animation is played.
      */
-    onAnimStart(action: (anim: string) => void): EventController;
+    onAnimStart(action: (anim: string) => void): KEventController;
     /**
      * Register an event that runs when an animation is ended.
      */
-    onAnimEnd(action: (anim: string) => void): EventController;
+    onAnimEnd(action: (anim: string) => void): KEventController;
     /**
      * @since v3000.0
      */
@@ -151,7 +151,7 @@ export function sprite(
     // 1  - from small index to large index
     // -1 - reverse
     let curAnimDir: -1 | 1 | null = null;
-    const spriteLoadedEvent = new Event<[SpriteData]>();
+    const spriteLoadedEvent = new KEvent<[SpriteData]>();
 
     if (!src) {
         throw new Error(
@@ -437,14 +437,14 @@ export function sprite(
         onAnimEnd(
             this: GameObj<SpriteComp>,
             action: (name: string) => void,
-        ): EventController {
+        ): KEventController {
             return this.on("animEnd", action);
         },
 
         onAnimStart(
             this: GameObj<SpriteComp>,
             action: (name: string) => void,
-        ): EventController {
+        ): KEventController {
             return this.on("animStart", action);
         },
 

src/components/level/agent.ts

@@ -1,6 +1,6 @@
 import type { Vec2 } from "../../math";
 import type { Comp, GameObj, PosComp } from "../../types";
-import type { EventController } from "../../utils";
+import type { KEventController } from "../../utils";
 import type { TileComp } from "./tile";
 
 /**
@@ -19,10 +19,10 @@ export interface AgentComp extends Comp {
     isTargetReachable(): boolean;
     isTargetReached(): boolean;
     setTarget(target: Vec2): void;
-    onNavigationStarted(cb: () => void): EventController;
-    onNavigationNext(cb: () => void): EventController;
-    onNavigationEnded(cb: () => void): EventController;
-    onTargetReached(cb: () => void): EventController;
+    onNavigationStarted(cb: () => void): KEventController;
+    onNavigationNext(cb: () => void): KEventController;
+    onNavigationEnded(cb: () => void): KEventController;
+    onTargetReached(cb: () => void): KEventController;
 }
 
 /**
@@ -39,7 +39,7 @@ export function agent(opts: AgentCompOpt = {}): AgentComp {
     let target: Vec2 | null = null;
     let path: Vec2[] | null = null;
     let index: number | null = null;
-    let navMapChangedEvent: EventController | null = null;
+    let navMapChangedEvent: KEventController | null = null;
     return {
         id: "agent",
         require: ["pos", "tile"],

src/components/level/patrol.ts

@@ -1,5 +1,5 @@
 import { Vec2 } from "../../math";
-import type { Comp, GameObj, PosComp, QueryOpt } from "../../types";
+import type { Comp, GameObj, PosComp } from "../../types";
 
 export interface PatrolComp extends Comp {
     patrolSpeed: number;

src/components/level/sentry.ts

@@ -1,7 +1,7 @@
 import { getKaboomContext } from "../../kaboom";
 import { Vec2 } from "../../math";
 import type { Comp, GameObj, PosComp, QueryOpt } from "../../types";
-import type { EventController } from "../../utils";
+import type { KEventController } from "../../utils";
 import { raycast } from "../draw/raycast";
 
 /**
@@ -29,7 +29,7 @@ export interface SentryComp extends Comp {
     /*
      * Binds the event fired when objects of interest are spotted.
      */
-    onObjectsSpotted(cb: (objects: GameObj[]) => void): EventController;
+    onObjectsSpotted(cb: (objects: GameObj[]) => void): KEventController;
 }
 
 /**

src/components/misc/health.ts

@@ -1,5 +1,5 @@
 import type { Comp, GameObj } from "../../types";
-import type { EventController } from "../../utils";
+import type { KEventController } from "../../utils";
 
 /**
  * The {@link health `health()`} component.
@@ -36,19 +36,19 @@ export interface HealthComp extends Comp {
      *
      * @since v2000.1
      */
-    onHurt(action: (amount?: number) => void): EventController;
+    onHurt(action: (amount?: number) => void): KEventController;
     /**
      * Register an event that runs when heal() is called upon the object.
      *
      * @since v2000.1
      */
-    onHeal(action: (amount?: number) => void): EventController;
+    onHeal(action: (amount?: number) => void): KEventController;
     /**
      * Register an event that runs when object's HP is equal or below 0.
      *
      * @since v2000.1
      */
-    onDeath(action: () => void): EventController;
+    onDeath(action: () => void): KEventController;
 }
 
 export function health(
@@ -88,16 +88,16 @@ export function health(
         onHurt(
             this: GameObj,
             action: (amount?: number) => void,
-        ): EventController {
+        ): KEventController {
             return this.on("hurt", action);
         },
         onHeal(
             this: GameObj,
             action: (amount?: number) => void,
-        ): EventController {
+        ): KEventController {
             return this.on("heal", action);
         },
-        onDeath(this: GameObj, action: () => void): EventController {
+        onDeath(this: GameObj, action: () => void): KEventController {
             return this.on("death", action);
         },
         inspect() {

src/components/misc/state.ts

@@ -1,5 +1,5 @@
 import type { Comp } from "../../types";
-import { Event, EventController } from "../../utils";
+import { KEvent, KEventController } from "../../utils";
 
 /**
  * The {@link state `state()`} component.
@@ -24,26 +24,26 @@ export interface StateComp extends Comp {
         from: string,
         to: string,
         action: () => void,
-    ): EventController;
+    ): KEventController;
     /**
      * Register event that runs once when enters a specific state. Accepts arguments passed from `enterState(name, ...args)`.
      */
     onStateEnter: (
         state: string,
         action: (...args: any) => void,
-    ) => EventController;
+    ) => KEventController;
     /**
      * Register an event that runs once when leaves a specific state.
      */
-    onStateEnd: (state: string, action: () => void) => EventController;
+    onStateEnd: (state: string, action: () => void) => KEventController;
     /**
      * Register an event that runs every frame when in a specific state.
      */
-    onStateUpdate: (state: string, action: () => void) => EventController;
+    onStateUpdate: (state: string, action: () => void) => KEventController;
     /**
      * Register an event that runs every frame when in a specific state.
      */
-    onStateDraw: (state: string, action: () => void) => EventController;
+    onStateDraw: (state: string, action: () => void) => KEventController;
 }
 
 export function state(
@@ -60,10 +60,10 @@ export function state(
     function initStateEvents(state: string) {
         if (!events[state]) {
             events[state] = {
-                enter: new Event(),
-                end: new Event(),
-                update: new Event(),
-                draw: new Event(),
+                enter: new KEvent(),
+                end: new KEvent(),
+                update: new KEvent(),
+                draw: new KEvent(),
             };
         }
     }
@@ -122,23 +122,23 @@ export function state(
             from: string,
             to: string,
             action: () => void,
-        ): EventController {
+        ): KEventController {
             return on("enter", `${from} -> ${to}`, action);
         },
 
-        onStateEnter(state: string, action: () => void): EventController {
+        onStateEnter(state: string, action: () => void): KEventController {
             return on("enter", state, action);
         },
 
-        onStateUpdate(state: string, action: () => void): EventController {
+        onStateUpdate(state: string, action: () => void): KEventController {
             return on("update", state, action);
         },
 
-        onStateDraw(state: string, action: () => void): EventController {
+        onStateDraw(state: string, action: () => void): KEventController {
             return on("draw", state, action);
         },
 
-        onStateEnd(state: string, action: () => void): EventController {
+        onStateEnd(state: string, action: () => void): KEventController {
             return on("end", state, action);
         },
 

src/components/misc/timer.ts

@@ -3,8 +3,8 @@ import { getKaboomContext } from "../../kaboom";
 import { lerp } from "../../math";
 import type {
     Comp,
-    EventController,
     GameObj,
+    KEventController,
     LerpValue,
     TimerController,
     TweenController,
@@ -25,7 +25,7 @@ export interface TimerComp extends Comp {
      *
      * @since v3000.0
      */
-    loop(time: number, action: () => void): EventController;
+    loop(time: number, action: () => void): KEventController;
     /**
      * Tweeeeen! Note that this doesn't specifically mean tweening on this object's property, this just registers the timer on this object, so the tween will cancel with the object gets destroyed, or paused when obj.paused is true.
      *
@@ -76,7 +76,7 @@ export function timer(): TimerComp {
                 },
             };
         },
-        loop(t: number, action: () => void): EventController {
+        loop(t: number, action: () => void): KEventController {
             let curTimer: null | TimerController = null;
             const newAction = () => {
                 // TODO: should f be execute right away as loop() is called?