screeps-connectivity 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.6.0
+
+### Minor Changes
+
+- 71ce50f: Show reservation vs. owner, RCL, and the controller sign in the world-map tooltip.
+- f525f2b: Replace the top-right logout button with a username chip (badge + name) that opens an account dropdown. The dropdown holds Settings, Respawn (with a destructive confirmation dialog), Change/Set password, and Logout. Password management works for email/password and Steam sessions — Steam-only accounts without a password get a "Set password" flow — while pasted API-token and guest sessions hide it. Settings now opens from the dropdown (guests keep the header gear); the panel's existing close button is the only toggle. Trimmed the Settings panel of options already available directly in the room/map views (creep labels, map view options) and removed the "Verbose creep details" toggle — the body-part breakdown is now always shown.
+
+  `screeps-connectivity`: `UserInfo` gains an optional `password?: boolean` field, surfaced from `/api/auth/me`, indicating whether the account has a password set.
+
+### Patch Changes
+
+- 270fabf: Deep-merge room-object diffs so structure stores keep non-energy resources across ticks.
+
+## 0.5.2
+
+### Patch Changes
+
+- 9523f3c: Make highway resources easier to spot on the world map. Power banks are now
+  drawn as larger bright-red dots (radius 1.5 → 2.5) instead of small orange ones,
+  and deposits — previously rendered as tiny muted-red "foreign" dots because
+  their `d` map2 key fell through to the generic user-object path — now show as
+  prominent white dots. The deposit key is documented on `RoomMap2Data`.
+
 ## 0.5.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screeps-connectivity",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "license": "ISC",
   "type": "module",
   "repository": {

package/src/stores/MapStatsStore.ts

@@ -11,6 +11,11 @@ export interface MapStatsRoomData {
   safeMode?: boolean
   badge?: ApiMapStatsBadge
   status?: string
+  /**
+   * Controller sign. `user` is the raw signer id; `username`/`badge` are resolved from the
+   * response's user map and may be absent if the signer isn't included there.
+   */
+  sign?: { user: string; text: string; datetime: number; username?: string; badge?: ApiMapStatsBadge }
 }
 
 export interface MapStatsStoreEvents {
@@ -104,6 +109,7 @@ export class MapStatsStore extends TypedStore<MapStatsStoreEvents> {
       }
     }
     const ownerId = stat.own?.user
+    const signUserId = stat.sign?.user
     return {
       own: stat.own,
       mineral,
@@ -112,6 +118,15 @@ export class MapStatsStore extends TypedStore<MapStatsStoreEvents> {
       safeMode: stat.safeMode,
       badge: ownerId ? userMap[ownerId]?.badge : undefined,
       status: stat.status,
+      sign: stat.sign
+        ? {
+            user: stat.sign.user,
+            text: stat.sign.text,
+            datetime: stat.sign.datetime,
+            username: signUserId ? userMap[signUserId]?.username : undefined,
+            badge: signUserId ? userMap[signUserId]?.badge : undefined,
+          }
+        : undefined,
     }
   }
 }

package/src/stores/RoomStore.ts

@@ -8,6 +8,33 @@ import type { SocketClient } from '../socket/SocketClient.js'
 import type { Cache } from '../cache/Cache.js'
 import type { Subscription } from '../subscription/index.js'
 
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null && !Array.isArray(v)
+}
+
+// Apply a room-object diff onto the previous value following Screeps protocol semantics:
+// the first message for an object carries full state, later ticks send only the fields that
+// changed. Nested objects (`store`, `storeCapacityResource`, `effects`, …) are diffed
+// recursively rather than replaced wholesale — a plain shallow spread would clobber the whole
+// `store` with that tick's single changed resource (e.g. `{ energy }`), silently dropping every
+// other resource until it next changes. A `null` leaf means the field was removed; arrays and
+// primitives replace as-is. Returns fresh objects so previously returned snapshots are never
+// mutated.
+function mergeObjectDiff(prev: Record<string, unknown>, diff: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = { ...prev }
+  for (const key in diff) {
+    const next = diff[key]
+    if (next === null) {
+      delete out[key]
+    } else if (isPlainObject(next) && isPlainObject(out[key])) {
+      out[key] = mergeObjectDiff(out[key] as Record<string, unknown>, next)
+    } else {
+      out[key] = next
+    }
+  }
+  return out
+}
+
 export class RoomStore extends TypedStore<RoomStoreEvents> {
   private readonly http: HttpClient
   private readonly socket: SocketClient
@@ -190,7 +217,7 @@ export class RoomStore extends TypedStore<RoomStoreEvents> {
           if (obj === null) {
             delete current[id]
           } else if (current[id]) {
-            current[id] = { ...current[id], ...obj } as RoomObject
+            current[id] = mergeObjectDiff(current[id] as Record<string, unknown>, obj as Record<string, unknown>) as RoomObject
           } else {
             current[id] = obj as RoomObject
           }

package/src/types/api.ts

@@ -121,6 +121,7 @@ export interface ApiMapStatsRoomStat {
   respawnArea: number | null
   openTime: number | null
   own?: { user: string; level: number }
+  sign?: { user: string; text: string; time: number; datetime: number }
   safeMode?: boolean
   [mineral: `minerals${number}`]: { type: string; density: number } | undefined
 }

package/src/types/game.ts

@@ -7,6 +7,7 @@ export interface RoomMap2Data {
     c?: [number, number][] | null    // controllers
     m?: [number, number][] | null    // minerals
     k?: [number, number][] | null    // source keeper lairs
+    d?: [number, number][] | null    // deposits (highway commodity resource)
     [userId: string]: [number, number][] | null | undefined  // structures + creeps for that user
 }
 
@@ -67,6 +68,8 @@ export interface UserInfo {
     gcl: number
     credits: number
     badge: Badge
+    /** True when the account has a password set. Absent for password-less accounts (e.g. Steam-only logins). Only present for the authenticated user's own info. */
+    password?: boolean
 }
 
 export interface CpuStats {

package/tests/stores/MapStatsStore.test.ts

@@ -231,4 +231,100 @@ describe('MapStatsStore', () => {
     const stat = events[0].stat as { safeMode?: boolean }
     expect(stat.safeMode).toBeUndefined()
   })
+
+  it('passes reservations through as own with level 0', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { own: { user: 'u1', level: 0 } },
+      },
+      users: { u1: { _id: 'u1', username: 'Alice' } },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { own: { user: string; level: number }; username: string }
+    expect(stat.own).toEqual({ user: 'u1', level: 0 })
+    expect(stat.username).toBe('Alice')
+  })
+
+  it('resolves the controller sign with the signer username and badge', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: {
+          own: { user: 'u1', level: 5 },
+          sign: { user: 'u1', text: 'Territory of Alice', time: 100, datetime: 1700000000000 },
+        },
+      },
+      users: {
+        u1: { _id: 'u1', username: 'Alice', badge: { type: 7, color1: '#fff', color2: '#000', color3: '#f00', flip: false } },
+      },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { sign: { user: string; text: string; datetime: number; username: string; badge: { type: number } } }
+    expect(stat.sign.user).toBe('u1')
+    expect(stat.sign.text).toBe('Territory of Alice')
+    expect(stat.sign.datetime).toBe(1700000000000)
+    expect(stat.sign.username).toBe('Alice')
+    expect(stat.sign.badge.type).toBe(7)
+  })
+
+  it('keeps the raw signer id but omits username/badge when the signer is not in the user map', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: {
+          own: { user: 'u1', level: 4 },
+          sign: { user: 'ghost', text: 'Was here', time: 5, datetime: 1700000000000 },
+        },
+      },
+      users: { u1: { _id: 'u1', username: 'Alice' } },
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { sign: { user: string; text: string; username?: string; badge?: unknown } }
+    expect(stat.sign.user).toBe('ghost')
+    expect(stat.sign.text).toBe('Was here')
+    expect(stat.sign.username).toBeUndefined()
+    expect(stat.sign.badge).toBeUndefined()
+  })
+
+  it('omits sign when not present in response', async () => {
+    fetchMock.mockResolvedValue(mockResponse({
+      ok: 1,
+      stats: {
+        W1N1: { own: { user: 'u1', level: 1 } },
+      },
+      users: {},
+    }))
+
+    const events: Array<{ room: string; stat: unknown }> = []
+    store.on('mapStats:room', (e) => events.push(e))
+
+    store.request(['W1N1'], 'owner0')
+
+    await new Promise(r => setTimeout(r, 50))
+    expect(events).toHaveLength(1)
+    const stat = events[0].stat as { sign?: unknown }
+    expect(stat.sign).toBeUndefined()
+  })
 })

package/tests/stores/RoomStore.test.ts

@@ -91,6 +91,103 @@ describe('RoomStore', () => {
     expect(store.objects('W7N7', 'shard0')?.['id1']).toMatchObject({ x: 11, y: 11, type: 'creep' })
   })
 
+  it('deep-merges nested store diffs instead of clobbering the whole store', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+
+    // Full state: a storage holding several resources.
+    messageHandler({
+      objects: { s1: { _id: 's1', type: 'storage', room: 'W7N7', x: 28, y: 26, store: { energy: 239076, power: 2000, H: 5000, L: 5000 } } },
+      gameTime: 1000,
+    })
+
+    // Diff tick: only energy changed within the store.
+    messageHandler({ objects: { s1: { store: { energy: 223706 } } }, gameTime: 1001 })
+
+    // Other resources must survive — a shallow merge would have dropped them.
+    expect((store.objects('W7N7', 'shard0')?.['s1'] as { store: Record<string, number> }).store)
+      .toEqual({ energy: 223706, power: 2000, H: 5000, L: 5000 })
+  })
+
+  it('removes a store resource when the diff sends a null leaf', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    messageHandler({ objects: { s1: { _id: 's1', type: 'storage', room: 'W7N7', store: { energy: 100, H: 5000 } } }, gameTime: 1000 })
+    messageHandler({ objects: { s1: { store: { H: null } } }, gameTime: 1001 })
+
+    expect((store.objects('W7N7', 'shard0')?.['s1'] as { store: Record<string, number> }).store).toEqual({ energy: 100 })
+  })
+
+  it('replaces array fields wholesale rather than merging them', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    messageHandler({ objects: { c1: { _id: 'c1', type: 'creep', room: 'W7N7', body: [{ type: 'work' }, { type: 'move' }] } }, gameTime: 1000 })
+    messageHandler({ objects: { c1: { body: [{ type: 'carry' }] } }, gameTime: 1001 })
+
+    expect((store.objects('W7N7', 'shard0')?.['c1'] as { body: unknown[] }).body).toEqual([{ type: 'carry' }])
+  })
+
+  it('does not mutate a previously returned snapshot when applying a diff', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    messageHandler({ objects: { s1: { _id: 's1', type: 'storage', room: 'W7N7', store: { energy: 100, H: 5000 } } }, gameTime: 1000 })
+    const before = store.objects('W7N7', 'shard0')?.['s1'] as { store: Record<string, number> }
+
+    messageHandler({ objects: { s1: { store: { energy: 200 } } }, gameTime: 1001 })
+
+    // The snapshot captured before the diff must be unchanged.
+    expect(before.store).toEqual({ energy: 100, H: 5000 })
+  })
+
+  // actionLog is a transient per-tick field the client reads from merged state to drive
+  // action beams. The engine emits explicit `null` when an action stops, so deep-merge must
+  // (a) keep an unchanged action across ticks where the diff omits it (continuous beam) and
+  // (b) drop it on a null leaf (beam stops) — never accumulate a stale action.
+  it('keeps a continuing actionLog entry but clears it on an explicit null', async () => {
+    const { store, socket } = makeStore()
+    let messageHandler: (data: unknown) => void = () => {}
+    ;(socket.on as ReturnType<typeof vi.fn>).mockImplementation((_ch: string, cb: (data: unknown) => void) => {
+      messageHandler = cb
+      return { dispose: vi.fn() }
+    })
+
+    store.subscribe('W7N7', 'shard0')
+    // Harvest begins.
+    messageHandler({ objects: { c1: { _id: 'c1', type: 'creep', room: 'W7N7', actionLog: { harvest: { x: 5, y: 6 } } } }, gameTime: 1000 })
+    // Next tick the source is unchanged, so the diff omits actionLog entirely — the beam must persist.
+    messageHandler({ objects: { c1: { fatigue: 0 } }, gameTime: 1001 })
+    expect((store.objects('W7N7', 'shard0')?.['c1'] as { actionLog: Record<string, unknown> }).actionLog)
+      .toEqual({ harvest: { x: 5, y: 6 } })
+    // Creep stops harvesting: the engine sends a null leaf — the entry (and beam) must clear.
+    messageHandler({ objects: { c1: { actionLog: { harvest: null } } }, gameTime: 1002 })
+    expect((store.objects('W7N7', 'shard0')?.['c1'] as { actionLog: Record<string, unknown> }).actionLog)
+      .toEqual({})
+  })
+
   it('emits room:update event on WS message', async () => {
     const { store, socket } = makeStore()
     let messageHandler: (data: unknown) => void = () => {}