spoint 0.1.0 → 0.1.10

package/src/client/InputHandler.js

@@ -6,6 +6,20 @@ export class InputHandler {
     this.mouseDown = false
     this.callbacks = []
     this.enabled = true
+    this.renderer = config.renderer || null
+    this.vrYaw = 0
+    this.vrPitch = 0
+    this.vrPitchDelta = 0
+    this.vrYawDelta = 0
+    this.snapCooldown = false
+    this.snapTurnAngle = config.snapTurnAngle || 30
+    this.smoothTurnSpeed = config.smoothTurnSpeed || 0
+    this.onMenuPressed = config.onMenuPressed || null
+    this.menuCooldown = false
+    this.mobileControls = null
+    this.mobileInput = null
+    this.editModeCooldown = false
+    this.lastEditModeToggle = 0
 
     if (config.enableKeyboard !== false) {
       this.setupKeyboardListeners()
@@ -16,6 +30,14 @@ export class InputHandler {
     }
   }
 
+  setMobileControls(mobileControls) {
+    this.mobileControls = mobileControls
+  }
+
+  setSmoothTurnSpeed(speed) {
+    this.smoothTurnSpeed = speed
+  }
+
   setupKeyboardListeners() {
     if (typeof window === 'undefined') return
 
@@ -54,23 +76,234 @@ export class InputHandler {
         right: false,
         jump: false,
         shoot: this.mouseDown,
+        reload: false,
         mouseX: this.mouseX,
         mouseY: this.mouseY
       }
     }
 
+    if (this.mobileControls && this.mobileControls.hasInteraction && this.mobileControls.hasInteraction()) {
+      const mobileInput = this.mobileControls.getInput()
+      if (mobileInput) {
+        this.vrYawDelta = mobileInput.yaw
+        this.vrPitchDelta = mobileInput.pitch
+        this.vrYaw += mobileInput.yaw
+        this.vrPitch += mobileInput.pitch
+        this.mobileControls.resetLookDelta()
+        const zoomValue = mobileInput.zoom
+        if (mobileInput.resetZoom) mobileInput.resetZoom()
+        return {
+          forward: mobileInput.forward,
+          backward: mobileInput.backward,
+          left: mobileInput.left,
+          right: mobileInput.right,
+          jump: mobileInput.jump,
+          sprint: mobileInput.sprint,
+          crouch: mobileInput.crouch,
+          shoot: mobileInput.shoot,
+          reload: mobileInput.reload,
+          yaw: this.vrYaw,
+          pitch: this.vrPitch,
+          yawDelta: this.vrYawDelta,
+          pitchDelta: this.vrPitchDelta,
+          zoom: zoomValue,
+          mouseX: 0,
+          mouseY: 0,
+          isMobile: true,
+          interact: mobileInput.interact || false,
+          weapon: mobileInput.weapon || false,
+          analogForward: mobileInput.analogForward || 0,
+          analogRight: mobileInput.analogRight || 0
+        }
+      }
+    }
+
+    const xr = this._getXRInput()
+    if (xr) return xr
+
+    const now = Date.now()
+    const pPressed = this.keys.get('p') || false
+    if (pPressed && !this.editModeCooldown && now - this.lastEditModeToggle > 200) {
+      this.editModeCooldown = true
+      this.lastEditModeToggle = now
+    } else if (!pPressed) {
+      this.editModeCooldown = false
+    }
+
     return {
       forward: this.keys.get('w') || this.keys.get('arrowup') || false,
       backward: this.keys.get('s') || this.keys.get('arrowdown') || false,
       left: this.keys.get('a') || this.keys.get('arrowleft') || false,
       right: this.keys.get('d') || this.keys.get('arrowright') || false,
       jump: this.keys.get(' ') || false,
+      sprint: this.keys.get('shift') || false,
+      crouch: this.keys.get('c') || this.keys.get('control') || false,
       shoot: this.mouseDown,
+      reload: this.keys.get('r') || false,
+      editToggle: this.editModeCooldown,
       mouseX: this.mouseX,
       mouseY: this.mouseY
     }
   }
 
+  pulse(handedness, intensity, durationMs) {
+    if (!this.renderer?.xr?.isPresenting) return
+    const session = this.renderer.xr.getSession()
+    if (!session) return
+    for (const source of session.inputSources) {
+      if (source.handedness === handedness) {
+        const gp = source.gamepad
+        if (gp?.hapticActuators?.length > 0) {
+          gp.hapticActuators[0].pulse(intensity, durationMs)
+        }
+      }
+    }
+  }
+
+  _detectHandGesture(hand) {
+    const joints = hand.joints
+    if (!joints) return { pinch: false, grab: false, point: false }
+
+    const thumbTip = joints['thumb-tip']
+    const indexTip = joints['index-finger-tip']
+    const middleTip = joints['middle-finger-tip']
+    const ringTip = joints['ring-finger-tip']
+    const pinkyTip = joints['pinky-finger-tip']
+    const wrist = joints['wrist']
+
+    if (!thumbTip || !indexTip || !wrist) return { pinch: false, grab: false, point: false }
+
+    const pinchDist = Math.sqrt(
+      Math.pow(thumbTip.position.x - indexTip.position.x, 2) +
+      Math.pow(thumbTip.position.y - indexTip.position.y, 2) +
+      Math.pow(thumbTip.position.z - indexTip.position.z, 2)
+    )
+    const pinch = pinchDist < 0.02
+
+    let grab = false
+    if (middleTip && ringTip && pinkyTip) {
+      const palmDist = Math.sqrt(
+        Math.pow(wrist.position.x - middleTip.position.x, 2) +
+        Math.pow(wrist.position.y - middleTip.position.y, 2) +
+        Math.pow(wrist.position.z - middleTip.position.z, 2)
+      )
+      grab = [middleTip, ringTip, pinkyTip].every(tip => {
+        const d = Math.sqrt(
+          Math.pow(wrist.position.x - tip.position.x, 2) +
+          Math.pow(wrist.position.y - tip.position.y, 2) +
+          Math.pow(wrist.position.z - tip.position.z, 2)
+        )
+        return d < palmDist * 0.7
+      })
+    }
+
+    return { pinch, grab, pinchDist }
+  }
+
+  setSnapTurnAngle(angle) {
+    this.snapTurnAngle = angle
+  }
+
+  _getXRInput() {
+    if (!this.renderer?.xr?.isPresenting) return null
+    const session = this.renderer.xr.getSession()
+    if (!session) return null
+    let forward = false, backward = false, left = false, right = false
+    let analogForward = 0, analogRight = 0
+    let jump = false, shoot = false, sprint = false, reload = false
+    let menu = false
+    const DEAD = 0.15, THRESH = 0.5
+    let snapTurned = false
+    let hasHands = false
+    const snapAngleRad = (this.snapTurnAngle * Math.PI) / 180
+
+    for (const source of session.inputSources) {
+      if (source.hand) {
+        hasHands = true
+        const gestures = this._detectHandGesture(source.hand)
+        if (source.handedness === 'left') {
+          forward = gestures.grab
+        }
+        if (source.handedness === 'right') {
+          shoot = gestures.pinch
+        }
+        continue
+      }
+
+      const gp = source.gamepad
+      if (!gp) continue
+
+      if (window.__VR_DEBUG__) {
+        console.log(`[VR] ${source.handedness} axes:`, gp.axes.map((a, i) => `${i}:${a?.toFixed(2)}`).join(', '))
+        console.log(`[VR] ${source.handedness} btns:`, gp.buttons.map((b, i) => `${i}:${b?.pressed ? '1' : '0'}`).join(', '))
+      }
+
+      const axes = gp.axes
+      const btns = gp.buttons
+
+      const primaryX = axes[0] ?? 0
+      const primaryY = axes[1] ?? 0
+      const secondaryX = axes.length > 2 ? (axes[2] ?? 0) : 0
+      const secondaryY = axes.length > 3 ? (axes[3] ?? 0) : 0
+
+      if (source.handedness === 'left') {
+        if (Math.abs(primaryX) > DEAD) {
+          analogRight = primaryX
+          if (primaryX > THRESH) right = true
+          if (primaryX < -THRESH) left = true
+        }
+        if (Math.abs(primaryY) > DEAD) {
+          analogForward = -primaryY
+          if (primaryY < -THRESH) forward = true
+          if (primaryY > THRESH) backward = true
+        }
+
+        if (btns[0]?.pressed) jump = true
+        if (btns[1]?.pressed || btns[2]?.pressed) sprint = true
+        if (btns[2]?.pressed || btns[3]?.pressed || btns[4]?.pressed) reload = true
+
+        if (btns[4]?.pressed || btns[5]?.pressed || btns[3]?.pressed) {
+          if (!this.menuCooldown) {
+            menu = true
+            this.menuCooldown = true
+            if (this.onMenuPressed) this.onMenuPressed()
+          }
+        } else {
+          this.menuCooldown = false
+        }
+      }
+
+      if (source.handedness === 'right') {
+        const turnX = axes.length > 2 ? secondaryX : primaryX
+        const turnY = axes.length > 3 ? secondaryY : 0
+
+        if (this.smoothTurnSpeed > 0 && Math.abs(turnX) > DEAD) {
+          this.vrYaw -= turnX * this.smoothTurnSpeed * 0.016
+          snapTurned = true
+        } else if (Math.abs(turnX) > DEAD) {
+          if (!this.snapCooldown && Math.abs(turnX) > THRESH) {
+            this.vrYaw += turnX > 0 ? -snapAngleRad : snapAngleRad
+            this.snapCooldown = true
+            snapTurned = true
+          }
+        } else {
+          this.snapCooldown = false
+        }
+
+        if (btns[0]?.pressed) shoot = true
+        if (btns[2]?.pressed || btns[3]?.pressed || btns[4]?.pressed || btns[5]?.pressed) reload = true
+      }
+    }
+    if (snapTurned) this.pulse('right', 0.3, 50)
+    return { 
+      forward, backward, left, right, 
+      analogForward, analogRight,
+      jump, sprint, shoot, reload, menu, 
+      yaw: this.vrYaw, pitch: this.vrPitch, 
+      mouseX: 0, mouseY: 0, hasHands 
+    }
+  }
+
   onInput(callback) {
     this.callbacks.push(callback)
   }

package/src/client/JitterBuffer.js

@@ -0,0 +1,207 @@
+export class JitterBuffer {
+  constructor(config = {}) {
+    this.maxSize = config.maxSize || 32
+    this.maxAge = config.maxAge || 200
+    this.minBufferSize = config.minBufferSize || 2
+    this.targetDelay = config.targetDelay || 50
+    
+    this.buffer = []
+    this.lastProcessTime = 0
+    this.lastServerTime = 0
+    this.lastTick = 0
+    this.rtt = config.initialRtt || 50
+    this.rttVariance = 0
+    this.clockDelta = 0
+    this.clockDeltaVariance = 0
+    this.lastClientTime = 0
+  }
+  
+  addSnapshot(snapshot) {
+    const now = Date.now()
+    const clientTime = now
+    const serverTime = snapshot.timestamp || now
+    
+    if (this.lastServerTime > 0) {
+      const serverDelta = serverTime - this.lastServerTime
+      const clientDelta = clientTime - this.lastClientTime
+      
+      if (serverDelta > 0 && clientDelta > 0) {
+        const instantClockDelta = clientDelta - serverDelta
+        this.clockDeltaVariance = this.clockDeltaVariance * 0.9 + Math.abs(instantClockDelta - this.clockDelta) * 0.1
+        this.clockDelta = this.clockDelta * 0.9 + instantClockDelta * 0.1
+      }
+    }
+    
+    this.lastServerTime = serverTime
+    this.lastClientTime = clientTime
+    
+    this.buffer.push({
+      snapshot,
+      clientTime,
+      serverTime,
+      tick: snapshot.tick || 0
+    })
+    
+    this.buffer.sort((a, b) => a.tick - b.tick)
+    
+    while (this.buffer.length > this.maxSize) {
+      this.buffer.shift()
+    }
+    
+    this._pruneOld(now)
+  }
+  
+  _pruneOld(now) {
+    const cutoff = now - this.maxAge
+    while (this.buffer.length > 0 && this.buffer[0].clientTime < cutoff) {
+      this.buffer.shift()
+    }
+  }
+  
+  getSnapshotToRender(now = Date.now()) {
+    if (this.buffer.length < this.minBufferSize) {
+      if (this.buffer.length === 0) return null
+      return this.buffer[this.buffer.length - 1].snapshot
+    }
+    
+    const renderTime = now - this.targetDelay
+    
+    let newest = this.buffer[this.buffer.length - 1]
+    let oldest = this.buffer[0]
+    
+    if (renderTime >= newest.clientTime) {
+      return newest.snapshot
+    }
+    
+    if (renderTime <= oldest.clientTime) {
+      return oldest.snapshot
+    }
+    
+    for (let i = 0; i < this.buffer.length - 1; i++) {
+      const curr = this.buffer[i]
+      const next = this.buffer[i + 1]
+      
+      if (renderTime >= curr.clientTime && renderTime <= next.clientTime) {
+        const range = next.clientTime - curr.clientTime
+        if (range === 0) return curr.snapshot
+        
+        const alpha = (renderTime - curr.clientTime) / range
+        return this._interpolateSnapshots(curr.snapshot, next.snapshot, alpha)
+      }
+    }
+    
+    return newest.snapshot
+  }
+  
+  _interpolateSnapshots(older, newer, alpha) {
+    const interpolated = {
+      tick: Math.round(older.tick + (newer.tick - older.tick) * alpha),
+      timestamp: older.timestamp + (newer.timestamp - older.timestamp) * alpha,
+      players: [],
+      entities: []
+    }
+    
+    const olderPlayers = new Map()
+    for (const p of older.players || []) {
+      olderPlayers.set(p.id, p)
+    }
+    
+    for (const np of newer.players || []) {
+      const op = olderPlayers.get(np.id)
+      if (op) {
+        interpolated.players.push(this._interpolatePlayer(op, np, alpha))
+      } else {
+        interpolated.players.push({ ...np })
+      }
+    }
+    
+    const olderEntities = new Map()
+    for (const e of older.entities || []) {
+      olderEntities.set(e.id, e)
+    }
+    
+    for (const ne of newer.entities || []) {
+      const oe = olderEntities.get(ne.id)
+      if (oe) {
+        interpolated.entities.push(this._interpolateEntity(oe, ne, alpha))
+      } else {
+        interpolated.entities.push({ ...ne })
+      }
+    }
+    
+    return interpolated
+  }
+  
+  _interpolatePlayer(older, newer, alpha) {
+    return {
+      id: newer.id,
+      position: [
+        this._lerp(older.position[0], newer.position[0], alpha),
+        this._lerp(older.position[1], newer.position[1], alpha),
+        this._lerp(older.position[2], newer.position[2], alpha)
+      ],
+      rotation: newer.rotation,
+      velocity: [
+        this._lerp(older.velocity?.[0] || 0, newer.velocity?.[0] || 0, alpha),
+        this._lerp(older.velocity?.[1] || 0, newer.velocity?.[1] || 0, alpha),
+        this._lerp(older.velocity?.[2] || 0, newer.velocity?.[2] || 0, alpha)
+      ],
+      onGround: newer.onGround,
+      health: this._lerp(older.health || 100, newer.health || 100, alpha),
+      inputSequence: newer.inputSequence,
+      crouch: newer.crouch,
+      lookPitch: this._lerp(older.lookPitch || 0, newer.lookPitch || 0, alpha),
+      lookYaw: this._lerp(older.lookYaw || 0, newer.lookYaw || 0, alpha)
+    }
+  }
+  
+  _interpolateEntity(older, newer, alpha) {
+    return {
+      id: newer.id,
+      model: newer.model,
+      position: [
+        this._lerp(older.position[0], newer.position[0], alpha),
+        this._lerp(older.position[1], newer.position[1], alpha),
+        this._lerp(older.position[2], newer.position[2], alpha)
+      ],
+      rotation: [
+        this._lerp(older.rotation[0], newer.rotation[0], alpha),
+        this._lerp(older.rotation[1], newer.rotation[1], alpha),
+        this._lerp(older.rotation[2], newer.rotation[2], alpha),
+        this._lerp(older.rotation[3], newer.rotation[3], alpha)
+      ],
+      bodyType: newer.bodyType,
+      custom: newer.custom
+    }
+  }
+  
+  _lerp(a, b, t) {
+    return a + (b - a) * t
+  }
+  
+  updateRTT(pingTime, pongTime) {
+    const instantRtt = pongTime - pingTime
+    this.rttVariance = this.rttVariance * 0.75 + Math.abs(instantRtt - this.rtt) * 0.25
+    this.rtt = this.rtt * 0.875 + instantRtt * 0.125
+    
+    this.targetDelay = Math.min(100, Math.max(20, this.rtt / 2 + this.rttVariance))
+  }
+  
+  getBufferHealth() {
+    return this.buffer.length
+  }
+  
+  getRTT() {
+    return this.rtt
+  }
+  
+  getClockDelta() {
+    return this.clockDelta
+  }
+  
+  clear() {
+    this.buffer = []
+    this.lastServerTime = 0
+    this.lastClientTime = 0
+  }
+}

package/src/client/KalmanFilter.js

@@ -0,0 +1,125 @@
+export class KalmanFilter3D {
+  constructor(config = {}) {
+    this.processNoise = config.processNoise || 0.1
+    this.measurementNoise = config.measurementNoise || 0.5
+    this.uncertainty = config.uncertainty || 1.0
+    
+    this.x = [0, 0, 0]
+    this.v = [0, 0, 0]
+    
+    this.P = [
+      [this.uncertainty, 0, 0],
+      [0, this.uncertainty, 0],
+      [0, 0, this.uncertainty]
+    ]
+    
+    this.initialized = false
+  }
+  
+  init(position, velocity = [0, 0, 0]) {
+    this.x = [...position]
+    this.v = [...velocity]
+    this.initialized = true
+  }
+  
+  predict(dt) {
+    if (!this.initialized) return { position: this.x, velocity: this.v }
+    
+    for (let i = 0; i < 3; i++) {
+      this.x[i] += this.v[i] * dt
+    }
+    
+    const q = this.processNoise * dt * dt
+    for (let i = 0; i < 3; i++) {
+      this.P[i][i] += q
+    }
+    
+    return { position: [...this.x], velocity: [...this.v] }
+  }
+  
+  update(measuredPosition, measuredVelocity = null) {
+    if (!this.initialized) {
+      this.init(measuredPosition, measuredVelocity || [0, 0, 0])
+      return { position: [...this.x], velocity: [...this.v] }
+    }
+    
+    const R = this.measurementNoise
+    
+    for (let i = 0; i < 3; i++) {
+      const P = this.P[i][i]
+      const K = P / (P + R)
+      
+      this.x[i] += K * (measuredPosition[i] - this.x[i])
+      
+      if (measuredVelocity) {
+        this.v[i] = measuredVelocity[i]
+      }
+      
+      this.P[i][i] = (1 - K) * P
+    }
+    
+    return { position: [...this.x], velocity: [...this.v] }
+  }
+  
+  getState() {
+    return {
+      position: [...this.x],
+      velocity: [...this.v]
+    }
+  }
+  
+  setPosition(pos) {
+    this.x = [...pos]
+  }
+  
+  setVelocity(vel) {
+    this.v = [...vel]
+  }
+  
+  reset(position = [0, 0, 0]) {
+    this.x = [...position]
+    this.v = [0, 0, 0]
+    this.P = [
+      [this.uncertainty, 0, 0],
+      [0, this.uncertainty, 0],
+      [0, 0, this.uncertainty]
+    ]
+    this.initialized = false
+  }
+}
+
+export class SmoothStateTracker {
+  constructor(config = {}) {
+    this.filters = new Map()
+    this.maxAge = config.maxAge || 5000
+    this.defaultConfig = config.filterConfig || {}
+  }
+  
+  getFilter(id) {
+    let filter = this.filters.get(id)
+    if (!filter) {
+      filter = new KalmanFilter3D(this.defaultConfig)
+      this.filters.set(id, filter)
+    }
+    return filter
+  }
+  
+  update(id, position, velocity, dt) {
+    const filter = this.getFilter(id)
+    filter.predict(dt)
+    return filter.update(position, velocity)
+  }
+  
+  predict(id, dt) {
+    const filter = this.getFilter(id)
+    return filter.predict(dt)
+  }
+  
+  remove(id) {
+    this.filters.delete(id)
+  }
+  
+  clear() {
+    this.filters.clear()
+  }
+}

package/src/client/MessageHandler.js

@@ -0,0 +1,101 @@
+import { PredictionEngine } from './PredictionEngine.js'
+import { SmoothInterpolation } from './SmoothInterpolation.js'
+import { MSG } from '../protocol/MessageTypes.js'
+
+export class MessageHandler {
+  constructor(config = {}) {
+    this._config = config
+    this._predEngine = null
+    this._smoothInterp = null
+    this._playerId = null
+    this._currentTick = 0
+    this._callbacks = config.callbacks || {}
+  }
+
+  handleMessage(type, payload, snapProc) {
+    if (type === MSG.HANDSHAKE_ACK) {
+      return this._handleHandshake(payload)
+    } else if (type === MSG.RECONNECT_ACK) {
+      return this._handleReconnect(payload, snapProc)
+    } else if (type === MSG.STATE_RECOVERY) {
+      return payload.snapshot
+    } else if (type === MSG.DISCONNECT_REASON) {
+      if (payload.code === 4) return { invalidate: true }
+    } else if (type === MSG.SNAPSHOT || type === MSG.STATE_CORRECTION) {
+      return payload
+    } else if (type === MSG.PLAYER_LEAVE) {
+      snapProc?.removePlayer(payload.playerId)
+      this._callbacks.onPlayerLeft?.(payload.playerId)
+    } else if (type === MSG.WORLD_DEF) {
+      if (payload.movement && this._predEngine) this._predEngine.setMovement(payload.movement)
+      if (payload.gravity && this._predEngine) this._predEngine.setGravity(payload.gravity)
+      this._callbacks.onWorldDef?.(payload)
+    } else if (type === MSG.APP_EVENT) {
+      this._callbacks.onAppEvent?.(payload)
+    } else if (type === MSG.HOT_RELOAD || type === MSG.APP_MODULE || type === MSG.ASSET_UPDATE) {
+      const cb = { [MSG.HOT_RELOAD]: 'onHotReload', [MSG.APP_MODULE]: 'onAppModule', [MSG.ASSET_UPDATE]: 'onAssetUpdate' }[type]
+      this._callbacks[cb]?.(payload)
+    } else if (type === MSG.HEARTBEAT_ACK) {
+      this._handleHeartbeat(payload)
+    }
+  }
+
+  _handleHandshake(payload) {
+    this._playerId = payload.playerId
+    this._currentTick = payload.tick
+    this._predEngine = new PredictionEngine(this._config.tickRate || 128)
+    this._predEngine.init(this._playerId)
+    if (this._config.smoothInterpolation !== false) {
+      this._smoothInterp = new SmoothInterpolation({ predictionEnabled: this._config.predictionEnabled !== false })
+      this._smoothInterp.setLocalPlayer(this._playerId)
+    }
+    return { sessionToken: payload.sessionToken }
+  }
+
+  _handleReconnect(payload, snapProc) {
+    const oldPlayerId = this._playerId
+    this._playerId = payload.playerId
+    this._currentTick = payload.tick
+    if (oldPlayerId && oldPlayerId !== this._playerId) {
+      snapProc?.removePlayer(oldPlayerId)
+      if (this._smoothInterp) this._smoothInterp.removePlayer(oldPlayerId)
+      this._callbacks.onPlayerLeft?.(oldPlayerId)
+    }
+    if (!this._predEngine) {
+      this._predEngine = new PredictionEngine(this._config.tickRate || 128)
+      this._predEngine.init(this._playerId)
+    }
+    if (this._config.smoothInterpolation !== false && !this._smoothInterp) {
+      this._smoothInterp = new SmoothInterpolation({ predictionEnabled: this._config.predictionEnabled !== false })
+      this._smoothInterp.setLocalPlayer(this._playerId)
+    }
+    return { sessionToken: payload.sessionToken }
+  }
+
+  _handleHeartbeat(payload) {
+    if (this._smoothInterp) {
+      this._smoothInterp.updateRTT(payload.pingTime || 0, Date.now())
+    }
+  }
+
+  getPlayerId() { return this._playerId }
+  getCurrentTick() { return this._currentTick }
+  setCurrentTick(tick) { this._currentTick = tick }
+  getPredEngine() { return this._predEngine }
+  getSmoothInterp() { return this._smoothInterp }
+
+  getDisplayState(tick) {
+    if (this._smoothInterp) {
+      return this._smoothInterp.getDisplayState()
+    }
+    return { players: [], entities: [] }
+  }
+
+  getRTT() {
+    return this._smoothInterp?.getRTT() || 0
+  }
+
+  getBufferHealth() {
+    return this._smoothInterp?.getBufferHealth() || 0
+  }
+}