@dcl-regenesislabs/web-editor 0.0.0-stage → 0.1.0

package/prefabs/leaderboard/data.json

@@ -0,0 +1,35 @@
+{
+  "id": "493daede-2afd-4c10-9c0d-6aefb25629a8",
+  "name": "Leaderboard",
+  "description": "Shows one of your game's boards — point it at the game.state key your game writes the rows to. Works with: Game Flow.",
+  "category": "custom",
+  "group": "Multiplayer Server",
+  "tags": [
+    "multiplayer",
+    "server",
+    "leaderboard",
+    "score",
+    "ranking",
+    "board"
+  ],
+  "requiresSdk": "auth-server",
+  "drivenBy": {
+    "rule": "This panel only paints what it reads — the server writes the rows into the synced state key named in Board Key, and every client draws them in order.",
+    "code": "game.setState({ leaderboard: [{ player, score }] })",
+    "next": "Press New script below and write that line inside the isServer() block it comes with, using the same key you set in Board Key above."
+  },
+  "version": "1.1.0",
+  "changelog": [
+    {
+      "version": "1.0.0",
+      "notes": "Initial release: a panel that reads the game.state key you name in boardKey and paints its top rows, so the board a Script keeps is the board every player sees and a late joiner gets it from the snapshot."
+    },
+    {
+      "version": "1.1.0",
+      "notes": "The placed panel's Script card now shows the setState line that writes the rows it paints, under its own settings."
+    }
+  ],
+  "origin": {
+    "source": "builtin"
+  }
+}

package/prefabs/leaderboard/scripts/leaderboard.ts

@@ -0,0 +1,66 @@
+// A board on a panel. It reads one `game.state` key and paints it — nothing
+// here decides a score, and nothing here stores one. The server writes the rows
+// (see ai.md in this folder for the idiom); two boards pointed at two keys are
+// two independent boards in one scene, and two pointed at the same key show the
+// same thing on both walls.
+//
+// The panel is ordinary scene content: swap board-panel.glb for your own model
+// and keep (or restyle) the text child — the script writes only its `text`, so
+// font, size and colour stay exactly as authored.
+import { TextShape, Transform, engine, type Entity } from '@dcl/sdk/ecs'
+import { isServer } from '@dcl/sdk/network'
+import { game } from '~runtime/game'
+import { boardRows, clampRows, renderPanel } from './pure/board'
+
+const EMPTY = 'Nothing to show yet — set the board key the server writes to.'
+
+export class Leaderboard {
+  private panel: Entity | null = null
+  private painted = ''
+
+  constructor(
+    public src: string,
+    public entity: Entity,
+    /** The panel's title. */
+    public title: string = 'Leaderboard',
+    /** The game.state key this board shows. The server writes the rows there. */
+    public boardKey: string = 'leaderboard',
+    /** Which score wins: highest keeps points, lowest keeps best times. */
+    public sort: 'desc' | 'asc' = 'desc',
+    /** How many places the panel lists. */
+    public rows: number = 8
+  ) {}
+
+  start(): void {
+    if (isServer()) { return }
+    this.panel = this.findPanel()
+    game.onStateChange(() => this.repaint())
+    this.repaint()
+  }
+
+  private repaint(): void {
+    this.paint(
+      renderPanel(this.title, boardRows(game.state[this.boardKey], this.sort, clampRows(this.rows)), this.sort, EMPTY)
+    )
+  }
+
+  // The text lives on a child so the model can be replaced without touching it.
+  private findPanel(): Entity {
+    for (const [entity, transform] of engine.getEntitiesWith(Transform)) {
+      if (transform.parent === this.entity && TextShape.getOrNull(entity) !== null) return entity
+    }
+    return this.entity
+  }
+
+  private paint(text: string): void {
+    const panel = this.panel
+    if (panel === null || text === this.painted) return
+    this.painted = text
+    const shape = TextShape.getMutableOrNull(panel)
+    if (shape !== null) {
+      shape.text = text
+      return
+    }
+    TextShape.createOrReplace(panel, { text, fontSize: 0.8 })
+  }
+}

package/prefabs/leaderboard/scripts/pure/board.ts

@@ -0,0 +1,71 @@
+// The board's reading and rendering, with no SDK and no I/O.
+//
+// A Leaderboard is a pure reader: the server writes rows into a `game.state` key
+// and this turns them into panel text. Creators name those fields themselves —
+// one game writes `{ player, seconds }`, the next `{ p, pts }` — so a row is
+// anything with a player-ish string and a number, and anything else is skipped
+// rather than painted as [object Object].
+
+export type BoardSort = 'desc' | 'asc'
+
+export interface BoardRow {
+  rank: number
+  player: string
+  score: number
+}
+
+const PLAYER_FIELDS = ['player', 'p', 'address', 'wallet', 'name']
+const SCORE_FIELDS = ['score', 'points', 'pts', 'value', 'seconds', 'time', 'best']
+
+export const MAX_ROWS = 25
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/** Wallets are long; a board row reads better with the tail. */
+export function shortName(player: string): string {
+  return player.startsWith('0x') && player.length > 10 ? `${player.slice(0, 6)}…${player.slice(-4)}` : player
+}
+
+/** Whole seconds as m:ss — how an 'asc' board's times want to read. */
+export function formatScore(score: number, sort: BoardSort): string {
+  if (sort === 'desc') return `${Math.round(score)}`
+  const total = Math.max(0, Math.floor(score))
+  const rest = total % 60
+  return `${Math.floor(total / 60)}:${rest < 10 ? '0' : ''}${rest}`
+}
+
+export function clampRows(value: number): number {
+  if (!Number.isFinite(value)) return 8
+  return Math.min(MAX_ROWS, Math.max(1, Math.round(value)))
+}
+
+/**
+ * The visible rows of whatever sits under the board key. Sorting here rather than
+ * trusting the writer's order is what lets one key feed a "highest wins" board and
+ * a "lowest wins" board at once.
+ */
+export function boardRows(value: unknown, sort: BoardSort, limit: number): BoardRow[] {
+  if (!Array.isArray(value)) return []
+  const rows: { player: string; score: number }[] = []
+  for (const item of value) {
+    if (!isRecord(item)) continue
+    const playerKey = PLAYER_FIELDS.find((key) => typeof item[key] === 'string' && item[key] !== '')
+    const scoreKey = SCORE_FIELDS.find((key) => typeof item[key] === 'number' && Number.isFinite(item[key]))
+    if (playerKey === undefined || scoreKey === undefined) continue
+    rows.push({ player: String(item[playerKey]), score: Number(item[scoreKey]) })
+  }
+  rows.sort((a, b) => (sort === 'desc' ? b.score - a.score : a.score - b.score))
+  return rows.slice(0, clampRows(limit)).map((row, index) => ({ rank: index + 1, ...row }))
+}
+
+export function renderPanel(title: string, rows: BoardRow[], sort: BoardSort, placeholder: string): string {
+  const lines = [title.trim().toUpperCase(), '']
+  if (rows.length === 0) {
+    lines.push(placeholder)
+    return lines.join('\n')
+  }
+  for (const row of rows) lines.push(`${row.rank}. ${shortName(row.player)}   ${formatScore(row.score, sort)}`)
+  return lines.join('\n')
+}

package/prefabs/loveseat/composite.json

@@ -0,0 +1,100 @@
+{
+  "version": 1,
+  "components": [
+    {
+      "name": "core::GltfContainer",
+      "data": {
+        "0": {
+          "json": {
+            "src": "{assetPath}/Couch_01.glb",
+            "visibleMeshesCollisionMask": 0,
+            "invisibleMeshesCollisionMask": 3
+          }
+        }
+      }
+    },
+    {
+      "name": "core-schema::Name",
+      "data": {
+        "0": {
+          "json": {
+            "value": "Loveseat"
+          }
+        },
+        "513": {
+          "json": {
+            "value": "Sit Spot 1"
+          }
+        },
+        "514": {
+          "json": {
+            "value": "Sit Spot 2"
+          }
+        }
+      }
+    },
+    {
+      "name": "core::Transform",
+      "data": {
+        "513": {
+          "json": {
+            "position": {
+              "x": -0.79,
+              "y": 0.08,
+              "z": 0.56
+            },
+            "rotation": {
+              "x": 0,
+              "y": -0.7071067690849304,
+              "z": 0,
+              "w": 0.7071067690849304
+            },
+            "scale": {
+              "x": 1,
+              "y": 1,
+              "z": 1
+            },
+            "parent": 0
+          }
+        },
+        "514": {
+          "json": {
+            "position": {
+              "x": -0.79,
+              "y": 0.08,
+              "z": -0.4
+            },
+            "rotation": {
+              "x": 0,
+              "y": -0.7071067690849304,
+              "z": 0,
+              "w": 0.7071067690849304
+            },
+            "scale": {
+              "x": 1,
+              "y": 1,
+              "z": 1
+            },
+            "parent": 0
+          }
+        }
+      }
+    },
+    {
+      "name": "asset-packs::Script",
+      "data": {
+        "0": {
+          "json": {
+            "value": [
+              {
+                "path": "{assetPath}/scripts/seat.ts",
+                "priority": 0,
+                "layout": "{\"params\":{},\"actions\":[]}"
+              }
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/prefabs/loveseat/data.json

@@ -0,0 +1,34 @@
+{
+  "id": "78050d8f-ee51-4db7-b060-14e7a0b48939",
+  "name": "Loveseat",
+  "description": "A two-seat sofa. Players can sit at either end.",
+  "category": "custom",
+  "tags": [
+    "seat",
+    "furniture",
+    "sit"
+  ],
+  "version": "1.1.0",
+  "changelog": [
+    {
+      "version": "1.1.0",
+      "notes": "The seat no longer runs on the Multiplayer Server, where it was walking every sit spot's transform chain each frame for nobody to see."
+    },
+    {
+      "version": "1.0.1",
+      "notes": "Ships the model's texture, which was missing from the folder — without it the model rendered blank white in-world."
+    },
+    {
+      "version": "1.0.0",
+      "notes": "Initial release"
+    }
+  ],
+  "origin": {
+    "source": "builtin"
+  },
+  "requiredPermissions": [
+    "ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE",
+    "ALLOW_TO_TRIGGER_AVATAR_EMOTE"
+  ],
+  "group": "Seats"
+}

package/prefabs/loveseat/scripts/seat.ts

@@ -0,0 +1,191 @@
+// Sit on this seat: click a sit spot -> the avatar is placed on it facing forward
+// and a looping sitting emote plays; moving cancels the emote engine-side (the
+// same mechanism the Creator Hub's seat smart items and Genesis Plaza use — no
+// avatar attach). Spots are child entities named "Sit Spot…" carrying only a
+// Transform; this script gives them their collider and pointer event at runtime.
+// With no such children (the standalone Sit Spot prefab), the entity itself is
+// the spot.
+import {
+  ColliderLayer,
+  InputAction,
+  Material,
+  MeshCollider,
+  MeshRenderer,
+  Schemas,
+  Transform,
+  VisibilityComponent,
+  engine,
+  pointerEventsSystem,
+  type Entity,
+  type LastWriteWinElementSetComponentDefinition
+} from '@dcl/sdk/ecs'
+import { Quaternion, Vector3 } from '@dcl/sdk/math'
+import { isServer } from '@dcl/sdk/network'
+import { movePlayerTo, triggerEmote, triggerSceneEmote } from '~system/RestrictedActions'
+
+const SPOT_NAME_PREFIX = 'sit spot'
+const HOVER_TEXT = 'Sit Here'
+const MAX_DISTANCE = 6
+const EMOTE_DELAY_S = 0.25
+const SITTING_EMOTES = ['sittingChair1', 'sittingChair2']
+// emote .glb files bundled in this prefab's folder (Genesis Plaza-style custom
+// poses, played via triggerSceneEmote); empty = the predefined chair emotes
+const SCENE_EMOTES: string[] = []
+
+// the Plaza-style "you can sit here" hint: a small glowing dot floating over
+// each free spot, pulsing gently, shown only to nearby players
+const DOT_VISIBLE_DIST = 10
+const DOT_OCCUPIED_DIST = 0.9
+const DOT_HEIGHT = 0.55
+const DOT_SIZE = 0.09
+const DOT_PULSE = 0.25
+
+type NameValue = { value: string }
+type NameComponent = LastWriteWinElementSetComponentDefinition<NameValue>
+
+// Every placed seat prefab bundles its own copy of this script (prefab folders are
+// self-contained), so the component may already be defined by a sibling copy.
+function nameComponent(): NameComponent {
+  const existing = engine.getComponentOrNull('core-schema::Name')
+  if (existing !== null) return existing as NameComponent
+  return engine.defineComponent('core-schema::Name', { value: Schemas.String })
+}
+
+function isSpotName(name: unknown): boolean {
+  return typeof name === 'string' && name.toLowerCase().startsWith(SPOT_NAME_PREFIX)
+}
+
+function sceneRelativeTransform(entity: Entity): { position: Vector3; rotation: Quaternion } {
+  const chain: Entity[] = []
+  let cursor = entity
+  while (cursor !== engine.RootEntity && chain.length < 32) {
+    chain.push(cursor)
+    const t = Transform.getOrNull(cursor)
+    if (t === null) break
+    cursor = t.parent ?? engine.RootEntity
+  }
+  let position = Vector3.Zero()
+  let rotation = Quaternion.Identity()
+  let scale = Vector3.One()
+  for (const link of chain.reverse()) {
+    const t = Transform.getOrNull(link)
+    if (t === null) continue
+    const local = Vector3.create(
+      t.position.x * scale.x,
+      t.position.y * scale.y,
+      t.position.z * scale.z
+    )
+    position = Vector3.add(position, Vector3.rotate(local, rotation))
+    rotation = Quaternion.multiply(rotation, t.rotation)
+    scale = Vector3.create(scale.x * t.scale.x, scale.y * t.scale.y, scale.z * t.scale.z)
+  }
+  return { position, rotation }
+}
+
+export class Seat {
+  private emoteIn = 0
+  private time = 0
+  private dots: Array<{ spot: Entity; dot: Entity; visible: boolean }> = []
+
+  constructor(
+    public src: string,
+    public entity: Entity
+  ) {}
+
+  start(): void {
+    if (isServer()) { return }
+    const Name = nameComponent()
+    const spots: Entity[] = []
+    for (const [child, transform] of engine.getEntitiesWith(Transform)) {
+      if (transform.parent !== this.entity) continue
+      const name = Name.getOrNull(child)
+      if (name !== null && isSpotName(name.value)) spots.push(child)
+    }
+    if (spots.length === 0) spots.push(this.entity)
+
+    for (const spot of spots) {
+      MeshCollider.setBox(spot, ColliderLayer.CL_POINTER)
+      pointerEventsSystem.onPointerDown(
+        {
+          entity: spot,
+          opts: { button: InputAction.IA_POINTER, hoverText: HOVER_TEXT, maxDistance: MAX_DISTANCE }
+        },
+        () => this.sit(spot)
+      )
+      // no collider on the dot: clicks pass through to the spot beneath it
+      const dot = engine.addEntity()
+      Transform.create(dot, {
+        parent: spot,
+        position: Vector3.create(0, DOT_HEIGHT, 0),
+        scale: Vector3.create(DOT_SIZE, DOT_SIZE, DOT_SIZE)
+      })
+      MeshRenderer.setSphere(dot)
+      Material.setPbrMaterial(dot, {
+        albedoColor: { r: 1, g: 1, b: 1, a: 0.85 },
+        emissiveColor: { r: 1, g: 1, b: 1 },
+        emissiveIntensity: 2,
+        roughness: 1
+      })
+      VisibilityComponent.create(dot, { visible: false })
+      this.dots.push({ spot, dot, visible: false })
+    }
+  }
+
+  update(dt: number): void {
+    // The hint walks a transform chain per spot per frame, and a seat is placed
+    // by the dozen: without this the Multiplayer Server pays for every one.
+    if (isServer()) { return }
+    this.time += dt
+    this.updateDots()
+    if (this.emoteIn <= 0) return
+    this.emoteIn -= dt
+    if (this.emoteIn > 0) return
+    if (SCENE_EMOTES.length > 0) {
+      // src is the script's directory (custom/<slug>/scripts) — the emotes live
+      // one level up, in the placed prefab's own folder
+      const root = this.src.replace(/\/scripts\/?$/, '')
+      const emote = SCENE_EMOTES[Math.floor(Math.random() * SCENE_EMOTES.length)]
+      void triggerSceneEmote({ src: `${root}/${emote}`, loop: true })
+      return
+    }
+    const emote = SITTING_EMOTES[Math.floor(Math.random() * SITTING_EMOTES.length)]
+    void triggerEmote({ predefinedEmote: emote })
+  }
+
+  private updateDots(): void {
+    const player = Transform.getOrNull(engine.PlayerEntity)?.position
+    const pulse = 1 + DOT_PULSE * Math.sin(this.time * 3)
+    for (const entry of this.dots) {
+      let visible = false
+      if (player !== undefined) {
+        const world = sceneRelativeTransform(entry.spot).position
+        const dist = Vector3.distance(player, world)
+        // hidden while someone (you) is on the spot — a glow over a seated
+        // avatar's head reads as a bug, not a hint
+        visible = dist < DOT_VISIBLE_DIST && dist > DOT_OCCUPIED_DIST
+      }
+      if (entry.visible !== visible) {
+        entry.visible = visible
+        VisibilityComponent.getMutable(entry.dot).visible = visible
+      }
+      if (visible) {
+        Transform.getMutable(entry.dot).scale = Vector3.create(
+          DOT_SIZE * pulse,
+          DOT_SIZE * pulse,
+          DOT_SIZE * pulse
+        )
+      }
+    }
+  }
+
+  private sit(spot: Entity): void {
+    const world = sceneRelativeTransform(spot)
+    const forward = Vector3.rotate(Vector3.Forward(), world.rotation)
+    void movePlayerTo({
+      newRelativePosition: world.position,
+      avatarTarget: Vector3.add(world.position, forward)
+    })
+    // let the teleport settle before the emote starts, or the walk cancels it
+    this.emoteIn = EMOTE_DELAY_S
+  }
+}

package/prefabs/modern-sofa/composite.json

@@ -0,0 +1,100 @@
+{
+  "version": 1,
+  "components": [
+    {
+      "name": "core::GltfContainer",
+      "data": {
+        "0": {
+          "json": {
+            "src": "{assetPath}/ModernSofa.glb",
+            "visibleMeshesCollisionMask": 0,
+            "invisibleMeshesCollisionMask": 3
+          }
+        }
+      }
+    },
+    {
+      "name": "core-schema::Name",
+      "data": {
+        "0": {
+          "json": {
+            "value": "Modern Sofa"
+          }
+        },
+        "513": {
+          "json": {
+            "value": "Sit Spot 1"
+          }
+        },
+        "514": {
+          "json": {
+            "value": "Sit Spot 2"
+          }
+        }
+      }
+    },
+    {
+      "name": "core::Transform",
+      "data": {
+        "513": {
+          "json": {
+            "position": {
+              "x": -1.0235,
+              "y": 0.1354,
+              "z": 0.0251
+            },
+            "rotation": {
+              "x": 0,
+              "y": 0.07845906168222427,
+              "z": 0,
+              "w": 0.9969173669815063
+            },
+            "scale": {
+              "x": 1,
+              "y": 1,
+              "z": 1
+            },
+            "parent": 0
+          }
+        },
+        "514": {
+          "json": {
+            "position": {
+              "x": -2.7763,
+              "y": 0.1354,
+              "z": 0.0293
+            },
+            "rotation": {
+              "x": 0,
+              "y": 0.07845907658338547,
+              "z": 0,
+              "w": 0.9969173669815063
+            },
+            "scale": {
+              "x": 1,
+              "y": 1,
+              "z": 1
+            },
+            "parent": 0
+          }
+        }
+      }
+    },
+    {
+      "name": "asset-packs::Script",
+      "data": {
+        "0": {
+          "json": {
+            "value": [
+              {
+                "path": "{assetPath}/scripts/seat.ts",
+                "priority": 0,
+                "layout": "{\"params\":{},\"actions\":[]}"
+              }
+            ]
+          }
+        }
+      }
+    }
+  ]
+}

package/prefabs/modern-sofa/data.json

@@ -0,0 +1,30 @@
+{
+  "id": "14706421-460b-4161-b06c-8ce7db73ad11",
+  "name": "Modern Sofa",
+  "description": "A low modern sofa, seating three. Players can sit along it.",
+  "category": "custom",
+  "tags": [
+    "seat",
+    "furniture",
+    "sit"
+  ],
+  "version": "1.1.0",
+  "changelog": [
+    {
+      "version": "1.1.0",
+      "notes": "The seat no longer runs on the Multiplayer Server, where it was walking every sit spot's transform chain each frame for nobody to see."
+    },
+    {
+      "version": "1.0.0",
+      "notes": "Initial release"
+    }
+  ],
+  "origin": {
+    "source": "builtin"
+  },
+  "requiredPermissions": [
+    "ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE",
+    "ALLOW_TO_TRIGGER_AVATAR_EMOTE"
+  ],
+  "group": "Seats"
+}