refactor(events): remove timestamp from event interfaces

Remove timestamp field from GameEvent, InputEvent, and KeyboardInputEvent
interfaces. The tick-based system provides deterministic event ordering
without needing wall-clock timestamps.

Author: hiddentao

packages/core/src/UserInputEventSource.ts

@@ -6,7 +6,6 @@ export class UserInputEventSource implements GameEventSource {
   protected dataQueue: Array<{
     inputType: string
     data: any
-    timestamp: number
   }> = []
 
   /**
@@ -15,7 +14,7 @@ export class UserInputEventSource implements GameEventSource {
    * @param data The input data to queue
    */
   queueInput(inputType: string, data: any): void {
-    this.dataQueue.push({ inputType, data, timestamp: Date.now() })
+    this.dataQueue.push({ inputType, data })
   }
 
   /**
@@ -32,7 +31,6 @@ export class UserInputEventSource implements GameEventSource {
     const events: UserInputEvent[] = this.dataQueue.map((item) => ({
       type: GameEventType.USER_INPUT,
       tick: totalTicks,
-      timestamp: item.timestamp,
       inputType: item.inputType,
       params: item.data,
     }))

packages/core/src/platform/InputLayer.ts

@@ -12,7 +12,6 @@ export interface InputEvent {
   x: number
   y: number
   button?: number
-  timestamp: number
 }
 
 /**
@@ -21,7 +20,6 @@ export interface InputEvent {
 export interface KeyboardInputEvent {
   key: string
   code: string
-  timestamp: number
 }
 
 /**

packages/core/src/types.ts

@@ -16,7 +16,6 @@ export enum GameEventType {
 export interface GameEvent {
   type: GameEventType
   tick: number
-  timestamp: number
 }
 
 export interface UserInputEvent extends GameEvent {

packages/core/tests/events/RecordedEventSource.test.ts

@@ -153,8 +153,8 @@ describe("RecordedEventSource", () => {
       const events = eventSource.getNextEvents(1)
 
       expect(events).toHaveLength(2)
-      expect(events[0].timestamp).toBe(1000) // Earlier timestamp
-      expect(events[1].timestamp).toBe(1001) // Later timestamp
+      expect((events[0] as any).inputType).toBe("keyboard")
+      expect((events[1] as any).objectType).toBe("Player")
     })
 
     it("should track current position correctly", () => {
@@ -233,7 +233,6 @@ describe("RecordedEventSource", () => {
       expect(userInputEvent).toBeDefined()
       expect(userInputEvent.inputType).toBe("keyboard")
       expect(userInputEvent.params).toEqual({ key: "W", pressed: true })
-      expect(userInputEvent.timestamp).toBe(1000)
     })
 
     it("should preserve object update event details", () => {
@@ -247,7 +246,6 @@ describe("RecordedEventSource", () => {
       expect(objectUpdateEvent.objectId).toBe("player1")
       expect(objectUpdateEvent.method).toBe("setPosition")
       expect(objectUpdateEvent.params).toEqual([{ x: 10, y: 20 }])
-      expect(objectUpdateEvent.timestamp).toBe(1001)
     })
 
     it("should handle complex parameter types", () => {

packages/core/tests/events/UserInputEventSource.test.ts

@@ -49,14 +49,12 @@ describe("UserInputEventSource", () => {
       expect(events[0].tick).toBe(currentFrame)
       expect((events[0] as UserInputEvent).inputType).toBe("direction")
       expect(events[0].params).toEqual({ x: 1, y: 0 })
-      expect(typeof events[0].timestamp).toBe("number")
 
       // Check second event
       expect(events[1].type).toBe(GameEventType.USER_INPUT)
       expect(events[1].tick).toBe(currentFrame)
       expect((events[1] as UserInputEvent).inputType).toBe("button")
       expect(events[1].params).toEqual({ action: "jump" })
-      expect(typeof events[1].timestamp).toBe("number")
     })
 
     it("should clear queue after generating events", () => {
@@ -184,44 +182,6 @@ describe("UserInputEventSource", () => {
     })
   })
 
-  describe("Timestamp Handling", () => {
-    it("should assign timestamps to queued inputs", async () => {
-      const startTime = Date.now()
-
-      inputSource.queueInput("test", { value: 1 })
-
-      // Small delay
-      await new Promise((resolve) => setTimeout(resolve, 5))
-
-      inputSource.queueInput("test", { value: 2 })
-
-      const events = inputSource.getNextEvents(10)
-
-      expect(events).toHaveLength(2)
-      expect(events[0].timestamp).toBeGreaterThanOrEqual(startTime)
-      expect(events[1].timestamp).toBeGreaterThan(events[0].timestamp)
-    })
-
-    it("should preserve timestamp order", async () => {
-      const timestamps: number[] = []
-
-      // Queue inputs with small delays
-      for (let i = 0; i < 5; i++) {
-        inputSource.queueInput(`input${i}`, { value: i })
-        await new Promise((resolve) => setTimeout(resolve, 1))
-      }
-
-      const events = inputSource.getNextEvents(10)
-
-      events.forEach((event) => timestamps.push(event.timestamp))
-
-      // Timestamps should be in ascending order
-      for (let i = 1; i < timestamps.length; i++) {
-        expect(timestamps[i]).toBeGreaterThanOrEqual(timestamps[i - 1])
-      }
-    })
-  })
-
   describe("Input Type Handling", () => {
     it("should handle different input types", () => {
       inputSource.queueInput("keyboard", { key: "W", pressed: true })

packages/core/tests/helpers/PlatformMocks.ts

@@ -665,42 +665,42 @@ export class MockInputLayer implements InputLayer {
 
   // Test helpers - simulate events
   simulatePointerDown(x: number, y: number, button = 0): void {
-    const event: InputEvent = { x, y, button, timestamp: Date.now() }
+    const event: InputEvent = { x, y, button }
     for (const callback of this.pointerDownCallbacks) {
       callback(event)
     }
   }
 
   simulatePointerUp(x: number, y: number, button = 0): void {
-    const event: InputEvent = { x, y, button, timestamp: Date.now() }
+    const event: InputEvent = { x, y, button }
     for (const callback of this.pointerUpCallbacks) {
       callback(event)
     }
   }
 
   simulatePointerMove(x: number, y: number): void {
-    const event: InputEvent = { x, y, timestamp: Date.now() }
+    const event: InputEvent = { x, y }
     for (const callback of this.pointerMoveCallbacks) {
       callback(event)
     }
   }
 
   simulateClick(x: number, y: number): void {
-    const event: InputEvent = { x, y, timestamp: Date.now() }
+    const event: InputEvent = { x, y }
     for (const callback of this.clickCallbacks) {
       callback(event)
     }
   }
 
   simulateKeyDown(key: string, code: string): void {
-    const event: KeyboardInputEvent = { key, code, timestamp: Date.now() }
+    const event: KeyboardInputEvent = { key, code }
     for (const callback of this.keyDownCallbacks) {
       callback(event)
     }
   }
 
   simulateKeyUp(key: string, code: string): void {
-    const event: KeyboardInputEvent = { key, code, timestamp: Date.now() }
+    const event: KeyboardInputEvent = { key, code }
     for (const callback of this.keyUpCallbacks) {
       callback(event)
     }

packages/core/tests/helpers/RecordingValidator.ts

@@ -31,9 +31,6 @@ export class RecordingValidator {
         if (typeof event.tick !== "number" || event.tick < 0) {
           errors.push(`Event ${index}: missing or invalid frame number`)
         }
-        if (typeof event.timestamp !== "number") {
-          errors.push(`Event ${index}: missing or invalid timestamp`)
-        }
       })
     }
 
@@ -72,18 +69,6 @@ export class RecordingValidator {
           )
         }
       }
-
-      // Check for potential timestamp ordering issues
-      let lastTimestamp = 0
-      for (let i = 0; i < recording.events.length; i++) {
-        const event = recording.events[i]
-        if (event.timestamp < lastTimestamp) {
-          warnings.push(
-            `Event ${i} has timestamp ${event.timestamp} earlier than previous ${lastTimestamp}`,
-          )
-        }
-        lastTimestamp = event.timestamp
-      }
     }
 
     if (recording.deltaTicks && Array.isArray(recording.deltaTicks)) {

packages/core/tests/helpers/TestScenarioBuilder.ts

@@ -249,7 +249,6 @@ export class TestScenarioBuilder {
     this.inputEvents.push({
       type: GameEventType.USER_INPUT,
       tick,
-      timestamp: Date.now() + tick * 16.67, // Simulate 60 FPS timing
       inputType,
       params,
     })
@@ -431,7 +430,6 @@ export class TestScenarioBuilder {
     const event: ObjectUpdateEvent = {
       type: GameEventType.OBJECT_UPDATE,
       tick,
-      timestamp: Date.now(),
       objectType,
       objectId,
       method,

packages/core/tests/integration/RecordReplayIntegration.test.ts

@@ -676,7 +676,6 @@ describe("Record-Replay Integration Tests", () => {
           recorder.recordEvent({
             type: GameEventType.OBJECT_UPDATE,
             tick: originalEngine.getTotalTicks(),
-            timestamp: Date.now(),
             objectType: "Projectile",
             objectId: "serialize_proj",
             method: "setPosition",

packages/core/tests/platform/MemoryInputLayer.test.ts

@@ -80,7 +80,7 @@ describe("MemoryInputLayer", () => {
         called = true
       })
 
-      input.triggerPointerDown({ x: 100, y: 200, timestamp: Date.now() })
+      input.triggerPointerDown({ x: 100, y: 200 })
       expect(called).toBe(true)
     })
 
@@ -90,7 +90,7 @@ describe("MemoryInputLayer", () => {
         receivedEvent = event
       })
 
-      const testEvent = { x: 100, y: 200, button: 0, timestamp: Date.now() }
+      const testEvent = { x: 100, y: 200, button: 0 }
       input.triggerPointerDown(testEvent)
 
       expect(receivedEvent).toEqual(testEvent)
@@ -102,7 +102,7 @@ describe("MemoryInputLayer", () => {
         called = true
       })
 
-      input.triggerPointerUp({ x: 100, y: 200, timestamp: Date.now() })
+      input.triggerPointerUp({ x: 100, y: 200 })
       expect(called).toBe(true)
     })
 
@@ -112,7 +112,7 @@ describe("MemoryInputLayer", () => {
         called = true
       })
 
-      input.triggerPointerMove({ x: 100, y: 200, timestamp: Date.now() })
+      input.triggerPointerMove({ x: 100, y: 200 })
       expect(called).toBe(true)
     })
 
@@ -122,7 +122,7 @@ describe("MemoryInputLayer", () => {
         called = true
       })
 
-      input.triggerClick({ x: 100, y: 200, timestamp: Date.now() })
+      input.triggerClick({ x: 100, y: 200 })
       expect(called).toBe(true)
     })
 
@@ -132,7 +132,7 @@ describe("MemoryInputLayer", () => {
         called = true
       })
 
-      input.triggerKeyDown({ key: "a", code: "KeyA", timestamp: Date.now() })
+      input.triggerKeyDown({ key: "a", code: "KeyA" })
       expect(called).toBe(true)
     })
 
@@ -142,7 +142,7 @@ describe("MemoryInputLayer", () => {
         called = true
       })
 
-      input.triggerKeyUp({ key: "a", code: "KeyA", timestamp: Date.now() })
+      input.triggerKeyUp({ key: "a", code: "KeyA" })
       expect(called).toBe(true)
     })
 
@@ -153,7 +153,7 @@ describe("MemoryInputLayer", () => {
       })
 
       input.removeAllListeners()
-      input.triggerPointerDown({ x: 0, y: 0, timestamp: Date.now() })
+      input.triggerPointerDown({ x: 0, y: 0 })
 
       expect(called).toBe(false)
     })
@@ -164,7 +164,7 @@ describe("MemoryInputLayer", () => {
       input.onPointerDown(() => count++)
       input.onPointerDown(() => count++)
 
-      input.triggerPointerDown({ x: 0, y: 0, timestamp: Date.now() })
+      input.triggerPointerDown({ x: 0, y: 0 })
       expect(count).toBe(3)
     })
   })