@shipload/sdk 2.0.0-rc1 → 2.0.0-rc11

package/src/scheduling/projection.ts

@@ -1,15 +1,18 @@
-import {UInt16, UInt32, UInt64} from '@wharfkit/antelope'
+import {Name, UInt16, UInt32, UInt64} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import {Coordinates, PRECISION, TaskType} from '../types'
+import {
+    capsHasLoaders,
+    capsHasMovement,
+    capsHasStorage,
+    EntityCapabilities,
+    EntityState,
+} from '../types/capabilities'
 import {distanceBetweenCoordinates, lerp} from '../travel/travel'
-import {getGood} from '../market/goods'
+import {calcCargoItemMass, calcCargoMass} from '../capabilities/storage'
 import * as schedule from './schedule'
 import {ScheduleData} from './schedule'
 
-/**
- * Projected state of an entity after scheduled tasks complete.
- * Mirrors contract's projected_entity struct.
- */
 export interface ProjectedEntity {
     location: Coordinates
     energy: UInt16
@@ -19,41 +22,55 @@ export interface ProjectedEntity {
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
     generator?: ServerContract.Types.energy_stats
+    hauler?: ServerContract.Types.hauler_stats
     readonly totalMass: UInt64
+
+    hasMovement(): boolean
+    hasStorage(): boolean
+    hasLoaders(): boolean
+
+    capabilities(): EntityCapabilities
+    state(): EntityState
 }
 
-/**
- * Interface for entities that can be projected.
- * Ships and Warehouses both implement this.
- */
 export interface Projectable extends ScheduleData {
-    location: Coordinates
-    energy: UInt16
-    mass: UInt32
+    coordinates: Coordinates | ServerContract.Types.coordinates
+    energy?: UInt16
+    hullmass?: UInt32
     generator?: ServerContract.Types.energy_stats
     engines?: ServerContract.Types.movement_stats
     loaders?: ServerContract.Types.loader_stats
-    capacity?: UInt64
-    calcCargoMass(): UInt64
+    hauler?: ServerContract.Types.hauler_stats
+    capacity?: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+    cargomass: UInt32
+    owner?: Name
+}
+
+function getHullMass(entity: Projectable): UInt32 {
+    return UInt32.from(entity.hullmass ?? 0)
 }
 
-/**
- * Create initial projected entity state from a projectable entity.
- */
 export function createProjectedEntity(entity: Projectable): ProjectedEntity {
-    const cargoMass = entity.calcCargoMass()
-    const shipMass = UInt32.from(entity.mass)
+    const cargoMass = calcCargoMass(entity)
+    const shipMass = getHullMass(entity)
     const loaders = entity.loaders
+    const engines = entity.engines
+    const generator = entity.generator
+    const hauler = entity.hauler
+    const capacity = entity.capacity
 
-    return {
-        location: Coordinates.from(entity.location),
-        energy: UInt16.from(entity.energy),
+    const projected: ProjectedEntity = {
+        location: Coordinates.from(entity.coordinates),
+        energy: UInt16.from(entity.energy ?? 0),
         cargoMass,
         shipMass,
-        capacity: entity.capacity,
-        engines: entity.engines,
-        generator: entity.generator,
+        capacity: capacity ? UInt64.from(capacity) : undefined,
+        engines,
+        generator,
+        hauler,
         loaders,
+
         get totalMass() {
             let mass = UInt64.from(this.shipMass).adding(this.cargoMass)
             if (this.loaders) {
@@ -61,12 +78,43 @@ export function createProjectedEntity(entity: Projectable): ProjectedEntity {
             }
             return mass
         },
+
+        hasMovement() {
+            return capsHasMovement(this.capabilities())
+        },
+
+        hasStorage() {
+            return capsHasStorage(this.capabilities())
+        },
+
+        hasLoaders() {
+            return capsHasLoaders(this.capabilities())
+        },
+
+        capabilities(): EntityCapabilities {
+            return {
+                hullmass: this.shipMass,
+                capacity: this.capacity ? UInt32.from(this.capacity) : undefined,
+                engines: this.engines,
+                generator: this.generator,
+                loaders: this.loaders,
+            }
+        },
+
+        state(): EntityState {
+            return {
+                owner: entity.owner ?? Name.from(''),
+                location: ServerContract.Types.coordinates.from(this.location),
+                energy: this.energy,
+                cargomass: UInt32.from(this.cargoMass),
+                cargo: entity.cargo,
+            }
+        },
     }
+
+    return projected
 }
 
-/**
- * Apply a recharge task to projected state.
- */
 function applyRechargeTask(
     projected: ProjectedEntity,
     _task: ServerContract.Types.task,
@@ -84,19 +132,16 @@ function applyRechargeTask(
     }
 }
 
-/**
- * Apply a flight task to projected state.
- */
 function applyFlightTask(
     projected: ProjectedEntity,
     task: ServerContract.Types.task,
     options: {complete: boolean; progress?: number}
 ): void {
-    if (!task.location || !projected.engines) return
+    if (!task.coordinates || !projected.engines) return
 
     const origin = projected.location
-    const destination = Coordinates.from(task.location)
-    const distance = distanceBetweenCoordinates(origin, task.location)
+    const destination = Coordinates.from(task.coordinates)
+    const distance = distanceBetweenCoordinates(origin, task.coordinates)
     const energyUsage = distance.dividing(PRECISION).multiplying(projected.engines.drain)
 
     if (options.complete) {
@@ -117,33 +162,69 @@ function applyFlightTask(
     }
 }
 
-/**
- * Apply a load task to projected state.
- */
 function applyLoadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good = getGood(item.good_id)
-        projected.cargoMass = projected.cargoMass.adding(good.mass.multiplying(item.quantity))
+        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item))
     }
 }
 
-/**
- * Apply an unload task to projected state.
- */
 function applyUnloadTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
     for (const item of task.cargo) {
-        const good = getGood(item.good_id)
-        const cargoMass = good.mass.multiplying(item.quantity)
+        const cargoMass = calcCargoItemMass(item)
         projected.cargoMass = projected.cargoMass.gt(cargoMass)
             ? projected.cargoMass.subtracting(cargoMass)
             : UInt64.from(0)
     }
 }
 
-/**
- * Project entity state after all scheduled tasks complete.
- * Mirrors contract's project_ship/project_warehouse methods.
- */
+function applyEnergyCost(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    if (!task.energy_cost) return
+    const energyCost = UInt16.from(task.energy_cost)
+    projected.energy = projected.energy.gt(energyCost)
+        ? UInt16.from(projected.energy.subtracting(energyCost))
+        : UInt16.from(0)
+}
+
+function applyGatherTask(
+    projected: ProjectedEntity,
+    task: ServerContract.Types.task,
+    options: {complete: boolean}
+): void {
+    if (!options.complete) return
+
+    applyEnergyCost(projected, task)
+
+    for (const item of task.cargo) {
+        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(item))
+    }
+}
+
+function applyCraftTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+
+    if (task.cargo.length > 0) {
+        for (let i = 0; i < task.cargo.length - 1; i++) {
+            const inputMass = calcCargoItemMass(task.cargo[i])
+            projected.cargoMass = projected.cargoMass.gt(inputMass)
+                ? projected.cargoMass.subtracting(inputMass)
+                : UInt64.from(0)
+        }
+        const output = task.cargo[task.cargo.length - 1]
+        projected.cargoMass = projected.cargoMass.adding(calcCargoItemMass(output))
+    }
+}
+
+function applyDeployTask(projected: ProjectedEntity, task: ServerContract.Types.task): void {
+    applyEnergyCost(projected, task)
+
+    if (task.cargo.length > 0) {
+        const mass = calcCargoItemMass(task.cargo[0])
+        projected.cargoMass = projected.cargoMass.gt(mass)
+            ? projected.cargoMass.subtracting(mass)
+            : UInt64.from(0)
+    }
+}
+
 export function projectEntity(entity: Projectable): ProjectedEntity {
     const projected = createProjectedEntity(entity)
 
@@ -156,7 +237,7 @@ export function projectEntity(entity: Projectable): ProjectedEntity {
             case TaskType.RECHARGE:
                 applyRechargeTask(projected, task, {complete: true})
                 break
-            case TaskType.FLIGHT:
+            case TaskType.TRAVEL:
                 applyFlightTask(projected, task, {complete: true})
                 break
             case TaskType.LOAD:
@@ -165,15 +246,22 @@ export function projectEntity(entity: Projectable): ProjectedEntity {
             case TaskType.UNLOAD:
                 applyUnloadTask(projected, task)
                 break
+            case TaskType.GATHER:
+                applyGatherTask(projected, task, {complete: true})
+                break
+            case TaskType.CRAFT:
+                applyCraftTask(projected, task)
+                break
+            case TaskType.DEPLOY:
+            case TaskType.DEPLOY_SHIP:
+                applyDeployTask(projected, task)
+                break
         }
     }
 
     return projected
 }
 
-/**
- * Project entity state at a specific time (partial task execution).
- */
 export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity {
     const projected = createProjectedEntity(entity)
 
@@ -198,7 +286,7 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.RECHARGE:
                 applyRechargeTask(projected, task, {complete: taskComplete, progress})
                 break
-            case TaskType.FLIGHT:
+            case TaskType.TRAVEL:
                 applyFlightTask(projected, task, {complete: taskComplete, progress})
                 break
             case TaskType.LOAD:
@@ -211,6 +299,22 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
                     applyUnloadTask(projected, task)
                 }
                 break
+            case TaskType.GATHER:
+                if (taskComplete) {
+                    applyGatherTask(projected, task, {complete: true})
+                }
+                break
+            case TaskType.CRAFT:
+                if (taskComplete) {
+                    applyCraftTask(projected, task)
+                }
+                break
+            case TaskType.DEPLOY:
+            case TaskType.DEPLOY_SHIP:
+                if (taskComplete) {
+                    applyDeployTask(projected, task)
+                }
+                break
         }
     }
 

package/src/scheduling/schedule.ts

@@ -153,3 +153,27 @@ export function scheduleProgress(entity: ScheduleData, now: Date): number {
     const elapsed = scheduleElapsed(entity, now)
     return Math.min(1, elapsed / duration)
 }
+
+export function isTaskType(entity: ScheduleData, taskType: TaskType, now: Date): boolean {
+    return currentTaskType(entity, now) === taskType
+}
+
+export function isInFlight(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.TRAVEL, now)
+}
+
+export function isRecharging(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.RECHARGE, now)
+}
+
+export function isLoading(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.LOAD, now)
+}
+
+export function isUnloading(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.UNLOAD, now)
+}
+
+export function isGathering(entity: ScheduleData, now: Date): boolean {
+    return isTaskType(entity, TaskType.GATHER, now)
+}

package/src/shipload.ts

@@ -7,7 +7,6 @@ import {GameContext} from './managers/context'
 import {EntitiesManager} from './managers/entities'
 import {PlayersManager} from './managers/players'
 import {LocationsManager} from './managers/locations'
-import {TradesManager} from './managers/trades'
 import {EpochsManager} from './managers/epochs'
 import {ActionsManager} from './managers/actions'
 import {GameState} from './entities/gamestate'
@@ -94,10 +93,6 @@ export class Shipload {
         return this._context.locations
     }
 
-    get trades(): TradesManager {
-        return this._context.trades
-    }
-
     get epochs(): EpochsManager {
         return this._context.epochs
     }

package/src/travel/travel.ts

@@ -14,6 +14,7 @@ import {
     Checksum256,
     Int64,
     Int64Type,
+    UInt16,
     UInt32,
     UInt32Type,
     UInt64,
@@ -22,23 +23,24 @@ import {
 
 import {ServerContract} from '../contracts'
 import {
+    BASE_ORBITAL_MASS,
     CargoMassInfo,
     Distance,
-    INITIAL_SHIP_MASS,
     MAX_ORBITAL_ALTITUDE,
     MIN_ORBITAL_ALTITUDE,
     PRECISION,
     ShipLike,
+    TaskType,
 } from '../types'
-import {getGood} from '../market/goods'
+import {getItem} from '../market/items'
 import {hasSystem} from '../utils/system'
 
 export function calc_orbital_altitude(mass: number): number {
-    if (mass <= INITIAL_SHIP_MASS) {
+    if (mass <= BASE_ORBITAL_MASS) {
         return MIN_ORBITAL_ALTITUDE
     }
 
-    const ratio = mass / INITIAL_SHIP_MASS
+    const ratio = mass / BASE_ORBITAL_MASS
     const capRatio = 10.0
     let scale = Math.log(ratio) / Math.log(capRatio)
     scale = Math.min(scale, 1.0)
@@ -125,7 +127,12 @@ export function calc_rechargetime(
 }
 
 export function calc_ship_rechargetime(ship: ShipLike): UInt32 {
-    return calc_rechargetime(ship.generator.capacity, ship.energy, ship.generator.recharge)
+    if (!ship.generator) return UInt32.from(0)
+    return calc_rechargetime(
+        ship.generator.capacity,
+        ship.energy ?? UInt16.from(0),
+        ship.generator.recharge
+    )
 }
 
 export function calc_flighttime(distance: UInt64Type, acceleration: number): UInt32 {
@@ -133,12 +140,14 @@ export function calc_flighttime(distance: UInt64Type, acceleration: number): UIn
 }
 
 export function calc_loader_flighttime(ship: ShipLike, mass: UInt64, altitude?: number): UInt32 {
-    const z = altitude ?? ship.location.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
+    const z = altitude ?? ship.coordinates.z?.toNumber() ?? calc_orbital_altitude(Number(mass))
     return calc_flighttime(z, calc_loader_acceleration(ship, mass))
 }
 
 export function calc_loader_acceleration(ship: ShipLike, mass: UInt64): number {
-    return calc_acceleration(Number(ship.loaders.thrust), Number(mass) + Number(ship.loaders.mass))
+    const thrust = ship.loaders ? Number(ship.loaders.thrust) : 0
+    const loaderMass = ship.loaders ? Number(ship.loaders.mass) : 0
+    return calc_acceleration(thrust, Number(mass) + loaderMass)
 }
 
 export function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UInt64): UInt32 {
@@ -147,7 +156,8 @@ export function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UIn
 }
 
 export function calc_ship_acceleration(ship: ShipLike, mass: UInt64): number {
-    return calc_acceleration(Number(ship.engines.thrust), Number(mass))
+    const thrust = ship.engines ? Number(ship.engines.thrust) : 0
+    return calc_acceleration(thrust, Number(mass))
 }
 
 export function calc_acceleration(thrust: number, mass: number): number {
@@ -157,14 +167,14 @@ export function calc_acceleration(thrust: number, mass: number): number {
 export function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64 {
     const mass = UInt64.from(0)
 
-    mass.add(ship.mass)
+    mass.add(ship.hullmass)
 
-    if (ship.loaders.quantity.gt(UInt32.zero)) {
+    if (ship.loaders && ship.loaders.quantity.gt(UInt32.zero)) {
         mass.add(ship.loaders.mass.multiplying(ship.loaders.quantity))
     }
 
     for (const cargo of cargos) {
-        mass.add(getGood(cargo.good_id).mass.multiplying(cargo.quantity))
+        mass.add(getItem(cargo.item_id).mass.multiplying(cargo.quantity))
     }
 
     return mass
@@ -182,9 +192,9 @@ export function calculateTransferTime(
     let mass = UInt64.from(0)
 
     for (const cargo of cargos) {
-        const qty = quantities?.get(Number(cargo.good_id)) ?? 0
+        const qty = quantities?.get(Number(cargo.item_id)) ?? 0
         if (qty > 0) {
-            const good_mass = getGood(cargo.good_id).mass
+            const good_mass = getItem(cargo.item_id).mass
             const cargo_mass = good_mass.multiplying(qty)
             mass = UInt64.from(mass).adding(cargo_mass)
         }
@@ -194,6 +204,7 @@ export function calculateTransferTime(
         return UInt32.from(0)
     }
 
+    if (!ship.loaders) return UInt32.from(0)
     mass = UInt64.from(mass).adding(ship.loaders.mass)
     const transfer_time = calc_loader_flighttime(ship, mass)
     return transfer_time.dividing(ship.loaders.quantity)
@@ -230,12 +241,12 @@ export function calculateLoadTimeBreakdown(
     let mass_load = UInt64.from(0)
 
     for (const cargo of cargos) {
-        const goodId = Number(cargo.good_id)
+        const goodId = Number(cargo.item_id)
         const loadQty = loadQuantities?.get(goodId) ?? 0
         const unloadQty = unloadQuantities?.get(goodId) ?? 0
 
         if (loadQty > 0 || unloadQty > 0) {
-            const good = getGood(cargo.good_id)
+            const good = getItem(cargo.item_id)
 
             if (loadQty > 0) {
                 const cargo_mass = good.mass.multiplying(loadQty)
@@ -251,17 +262,17 @@ export function calculateLoadTimeBreakdown(
     let unloadTime = 0
     let loadTime = 0
 
-    if (mass_unload.gt(UInt64.zero)) {
+    if (mass_unload.gt(UInt64.zero) && ship.loaders) {
         const totalMass = UInt64.from(mass_unload).adding(ship.loaders.mass)
         unloadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    if (mass_load.gt(UInt64.zero)) {
+    if (mass_load.gt(UInt64.zero) && ship.loaders) {
         const totalMass = UInt64.from(mass_load).adding(ship.loaders.mass)
         loadTime = Number(calc_loader_flighttime(ship, totalMass))
     }
 
-    const numLoaders = Number(ship.loaders.quantity)
+    const numLoaders = ship.loaders ? Number(ship.loaders.quantity) : 0
     const totalTime = numLoaders > 0 ? (unloadTime + loadTime) / numLoaders : 0
     const unloadTimePerLoader = numLoaders > 0 ? unloadTime / numLoaders : 0
     const loadTimePerLoader = numLoaders > 0 ? loadTime / numLoaders : 0
@@ -306,6 +317,7 @@ export function estimateTravelTime(
     if (
         loadMass &&
         UInt32.from(loadMass).gt(UInt32.zero) &&
+        ship.loaders &&
         ship.loaders.quantity.gt(UInt32.zero)
     ) {
         const totalMass = UInt64.from(loadMass).adding(ship.loaders.mass)
@@ -315,6 +327,7 @@ export function estimateTravelTime(
     if (
         unloadMass &&
         UInt32.from(unloadMass).gt(UInt32.zero) &&
+        ship.loaders &&
         ship.loaders.quantity.gt(UInt32.zero)
     ) {
         const totalMass = UInt64.from(unloadMass).adding(ship.loaders.mass)
@@ -345,8 +358,9 @@ export function estimateDealTravelTime(
 }
 
 export function hasEnergyForDistance(ship: ShipLike, distance: UInt64Type): boolean {
+    if (!ship.engines) return false
     const energyNeeded = UInt64.from(distance).dividing(PRECISION).multiplying(ship.engines.drain)
-    return UInt64.from(ship.energy).gte(energyNeeded)
+    return UInt64.from(ship.energy ?? 0).gte(energyNeeded)
 }
 
 export interface TransferEntity {
@@ -358,6 +372,66 @@ export interface TransferEntity {
     }
 }
 
+export interface HasScheduleAndLocation {
+    coordinates: ServerContract.ActionParams.Type.coordinates
+    schedule?: ServerContract.Types.schedule
+}
+
+export function getFlightOrigin(
+    entity: HasScheduleAndLocation,
+    flightTaskIndex: number
+): ServerContract.ActionParams.Type.coordinates {
+    if (!entity.schedule) return entity.coordinates
+
+    let origin = entity.coordinates
+    for (let i = 0; i < flightTaskIndex && i < entity.schedule.tasks.length; i++) {
+        const task = entity.schedule.tasks[i]
+        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+            origin = task.coordinates
+        }
+    }
+    return origin
+}
+
+export function getDestinationLocation(
+    entity: HasScheduleAndLocation
+): ServerContract.ActionParams.Type.coordinates | undefined {
+    if (!entity.schedule) return undefined
+
+    for (let i = entity.schedule.tasks.length - 1; i >= 0; i--) {
+        const task = entity.schedule.tasks[i]
+        if (task.type.equals(TaskType.TRAVEL) && task.coordinates) {
+            return task.coordinates
+        }
+    }
+    return undefined
+}
+
+export function getPositionAt(
+    entity: HasScheduleAndLocation,
+    taskIndex: number,
+    taskProgress: number
+): ServerContract.ActionParams.Type.coordinates {
+    if (!entity.schedule || entity.schedule.tasks.length === 0 || taskIndex < 0) {
+        return entity.coordinates
+    }
+
+    const task = entity.schedule.tasks[taskIndex]
+
+    if (!task.type.equals(TaskType.TRAVEL) || !task.coordinates) {
+        return getFlightOrigin(entity, taskIndex)
+    }
+
+    const origin = getFlightOrigin(entity, taskIndex)
+    const destination = task.coordinates
+
+    const interpolated = lerp(origin, destination, taskProgress)
+    return {
+        x: Math.round(interpolated.x),
+        y: Math.round(interpolated.y),
+    }
+}
+
 export function calc_transfer_duration(
     source: TransferEntity,
     dest: TransferEntity,

package/src/types/capabilities.ts

@@ -0,0 +1,71 @@
+import {Name, UInt16, UInt32} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+
+export interface MovementCapability {
+    engines: ServerContract.Types.movement_stats
+    generator: ServerContract.Types.energy_stats
+}
+
+export interface EnergyCapability {
+    energy: UInt16
+}
+
+export interface StorageCapability {
+    capacity: UInt32
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export interface LoaderCapability {
+    loaders: ServerContract.Types.loader_stats
+}
+
+export interface GathererCapability {
+    gatherer: ServerContract.Types.gatherer_stats
+}
+
+export interface MassCapability {
+    hullmass: UInt32
+}
+
+export interface ScheduleCapability {
+    schedule?: ServerContract.Types.schedule
+}
+
+export interface EntityCapabilities {
+    hullmass?: UInt32
+    capacity?: UInt32
+    engines?: ServerContract.Types.movement_stats
+    generator?: ServerContract.Types.energy_stats
+    loaders?: ServerContract.Types.loader_stats
+    gatherer?: ServerContract.Types.gatherer_stats
+    crafter?: ServerContract.Types.crafter_stats
+}
+
+export interface EntityState {
+    owner: Name
+    location: ServerContract.Types.coordinates
+    energy?: UInt16
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_item[]
+}
+
+export function capsHasMovement(caps: EntityCapabilities): boolean {
+    return caps.engines !== undefined && caps.generator !== undefined
+}
+
+export function capsHasStorage(caps: EntityCapabilities): boolean {
+    return caps.capacity !== undefined
+}
+
+export function capsHasLoaders(caps: EntityCapabilities): boolean {
+    return caps.loaders !== undefined
+}
+
+export function capsHasGatherer(caps: EntityCapabilities): boolean {
+    return caps.gatherer !== undefined
+}
+
+export function capsHasMass(caps: EntityCapabilities): boolean {
+    return caps.hullmass !== undefined
+}