@shipload/sdk 1.0.0-next.4 → 1.0.0-next.41

package/src/derivation/capability-mappings.ts

@@ -1,13 +1,10 @@
 import {SLOT_FORMULAS, type SlotConsumerKind} from '../data/capability-formulas'
 import {getStatDefinitions, type StatDefinition} from './stats'
-import {
-    getRecipe,
-    type Recipe,
-    type RecipeInput,
-    type RecipeInputCategory,
-} from '../data/recipes-runtime'
+import {getRecipe, type Recipe} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
 import {
     ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_GENERATOR_T1,
     ITEM_GATHERER_T1,
     ITEM_LOADER_T1,
@@ -15,6 +12,7 @@ import {
     ITEM_STORAGE_T1,
     ITEM_HAULER_T1,
     ITEM_WARP_T1,
+    ITEM_BATTERY_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_CONTAINER_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
@@ -31,16 +29,14 @@ export const KIND_TO_ITEM_ID: Record<SlotConsumerKind, number> = {
     storage: ITEM_STORAGE_T1,
     hauler: ITEM_HAULER_T1,
     warp: ITEM_WARP_T1,
+    battery: ITEM_BATTERY_T1,
     'ship-t1': ITEM_SHIP_T1_PACKED,
     'container-t1': ITEM_CONTAINER_T1_PACKED,
     'warehouse-t1': ITEM_WAREHOUSE_T1_PACKED,
+    'extractor-t1': ITEM_EXTRACTOR_T1_PACKED,
     'container-t2': ITEM_CONTAINER_T2_PACKED,
 }
 
-function isCategoryInput(input: RecipeInput): input is RecipeInputCategory {
-    return 'category' in input
-}
-
 /**
  * Walk a recipe's slot source down to the raw category stat that ultimately
  * lands in that slot. Returns the StatDefinition or undefined if the trace
@@ -56,8 +52,9 @@ function traceToRawCategoryStat(
 ): StatDefinition | undefined {
     const input = recipe.inputs[source.inputIndex]
     if (!input) return undefined
-    if (isCategoryInput(input)) {
-        const defs = getStatDefinitions(input.category)
+    const inputItem = getItem(input.itemId)
+    if (inputItem.type === 'resource' && inputItem.category) {
+        const defs = getStatDefinitions(inputItem.category)
         return defs[source.statIndex]
     }
     if (visited.has(input.itemId)) return undefined

package/src/derivation/crafting.ts

@@ -1,6 +1,6 @@
 import {UInt64} from '@wharfkit/antelope'
 import type {ResourceCategory} from '../types'
-import {findItemByCategoryAndTier, getRecipe, type Recipe} from '../data/recipes-runtime'
+import {getRecipe, type Recipe} from '../data/recipes-runtime'
 import {getItem} from '../data/catalog'
 import {getStatDefinitions} from './stats'
 import {deriveResourceStats} from './stratum'
@@ -58,11 +58,8 @@ function keyForStatSlot(
 function keyForRecipeInputStat(recipe: Recipe, inputIndex: number, statIndex: number): string {
     const input = recipe.inputs[inputIndex]
     if (!input) return ''
-    if ('category' in input) {
-        const defs = getStatDefinitions(input.category)
-        return defs[statIndex]?.key ?? ''
-    }
-    // itemId-typed input — its stats follow that item's own statSlots layout.
+    // Every input names an item by id; its stats follow that item's own layout
+    // (resource stat definitions for resources, statSlots for crafted items).
     const innerKeys = getItemStatKeys(input.itemId)
     return innerKeys[statIndex] ?? ''
 }
@@ -117,10 +114,11 @@ export function computeComponentStats(
         const src = slot.sources[0]
         const key = keyForStatSlot(recipe, slot)
         const input = src ? recipe.inputs[src.inputIndex] : undefined
-        if (!input || !('category' in input)) {
+        const inputItem = input ? getItem(input.itemId) : undefined
+        if (!inputItem || inputItem.type !== 'resource' || !inputItem.category) {
             return {key, value: Math.max(1, Math.min(999, 0))}
         }
-        const matching = categoryStacks.find((cs) => cs.category === input.category)
+        const matching = categoryStacks.find((cs) => cs.category === inputItem.category)
         const value = matching ? blendStacks(matching.stacks, key) : 0
         return {key, value: Math.max(1, Math.min(999, value))}
     })
@@ -147,7 +145,7 @@ export function computeEntityStats(
         const key = keyForStatSlot(recipe, slot)
         if (!src) return {key, value: 1}
         const input = recipe.inputs[src.inputIndex]
-        if (!input || 'category' in input) {
+        if (!input) {
             return {key, value: 1}
         }
         const blended = blendedByComponent[input.itemId] ?? {}
@@ -185,12 +183,7 @@ export function computeInputMass(itemId: number): number {
 
     let total = 0
     for (const input of recipe.inputs) {
-        if ('itemId' in input) {
-            total += getItem(input.itemId).mass * input.quantity
-        } else {
-            const item = findItemByCategoryAndTier(input.category, input.tier)
-            total += item.mass * input.quantity
-        }
+        total += getItem(input.itemId).mass * input.quantity
     }
     return total
 }
@@ -305,10 +298,13 @@ export function computeCraftedOutputStats(
             const key = keyForRecipeInputStat(recipe, src.inputIndex, src.statIndex)
             const input = recipe.inputs[src.inputIndex]
             let value = 0
-            if (input && 'category' in input) {
-                value = blendStacks(decodedByCategory[input.category] ?? [], key)
-            } else if (input) {
-                value = blendedByItem[input.itemId]?.[key] ?? 0
+            if (input) {
+                const inputItem = getItem(input.itemId)
+                if (inputItem.type === 'resource' && inputItem.category) {
+                    value = blendStacks(decodedByCategory[inputItem.category] ?? [], key)
+                } else {
+                    value = blendedByItem[input.itemId]?.[key] ?? 0
+                }
             }
             out.push(Math.max(1, Math.min(999, value)))
         } else {
@@ -319,10 +315,13 @@ export function computeCraftedOutputStats(
                 const input = recipe.inputs[src.inputIndex]
                 const weight = recipe.blendWeights[src.inputIndex] ?? 1
                 let value = 0
-                if (input && 'category' in input) {
-                    value = blendStacks(decodedByCategory[input.category] ?? [], key)
-                } else if (input) {
-                    value = blendedByItem[input.itemId]?.[key] ?? 0
+                if (input) {
+                    const inputItem = getItem(input.itemId)
+                    if (inputItem.type === 'resource' && inputItem.category) {
+                        value = blendStacks(decodedByCategory[inputItem.category] ?? [], key)
+                    } else {
+                        value = blendedByItem[input.itemId]?.[key] ?? 0
+                    }
                 }
                 weightedSum += value * weight
                 totalWeight += weight
@@ -340,7 +339,7 @@ export function computeCraftedOutputStats(
  * returns a UInt64 whose bit-packed form matches what the contract writes
  * to cargo_item.stats on gather.
  *
- * Use this whenever off-chain code simulates a gather (testmap, player
+ * Use this whenever off-chain code simulates a gather (webapp, player
  * scanners that project cargo outcomes) and needs a value that matches
  * what on-chain cargo would carry.
  */

package/src/derivation/index.ts

@@ -7,6 +7,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,
@@ -16,7 +17,9 @@ export {
     DEPTH_THRESHOLD_T5,
     LOCATION_MIN_DEPTH,
     LOCATION_MAX_DEPTH,
-    YIELD_THRESHOLD,
+    yieldThresholdAt,
+    YIELD_FRACTION_SHALLOW,
+    YIELD_FRACTION_DEEP,
     PLANET_SUBTYPE_GAS_GIANT,
     PLANET_SUBTYPE_ROCKY,
     PLANET_SUBTYPE_TERRESTRIAL,
@@ -25,8 +28,28 @@ export {
     PLANET_SUBTYPE_INDUSTRIAL,
 } from './resources'
 
-export {RESERVE_TIERS, TIER_ROLL_MAX, rollTier, rollWithinTier} from './tiers'
+export {
+    RESERVE_TIERS,
+    TIER_ROLL_MAX,
+    tierOfReserve,
+    rollTier,
+    rollWithinTier,
+    RESOURCE_TIER_MULT_TENTHS,
+    applyResourceTierMultiplier,
+} from './tiers'
 export type {ReserveTier, TierRange} from './tiers'
 
+export {getEffectiveReserve} from './reserve-regen'
+export type {EffectiveReserveInput} from './reserve-regen'
+
 export * from './stats'
 export * from './crafting'
+
+export {
+    STAR_STEP,
+    MAX_STARS_PER_STAT,
+    MAX_STAR_RATING,
+    starsForStat,
+    starRating,
+    statMagnitude,
+} from './stars'

package/src/derivation/recipe-usage.test.ts

@@ -0,0 +1,78 @@
+import {expect, test} from 'bun:test'
+import {
+    getAllRecipes,
+    getRecipeConsumers,
+    getComponentDemand,
+    getResourceDemand,
+} from './recipe-usage'
+import {
+    ITEM_SENSOR,
+    ITEM_RESIN,
+    ITEM_PLATE,
+    ITEM_BEAM,
+    ITEM_GATHERER_T1,
+    ITEM_CRAFTER_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_SHIP_T1_PACKED,
+} from '../data/item-ids'
+
+test('getAllRecipes returns the full catalog including the gatherer', () => {
+    const all = getAllRecipes()
+    expect(all.length).toBeGreaterThan(20)
+    expect(all.some((r) => r.outputItemId === ITEM_GATHERER_T1)).toBe(true)
+})
+
+test('getRecipeConsumers lists every recipe that consumes Sensor', () => {
+    const consumers = getRecipeConsumers(ITEM_SENSOR)
+    const ids = consumers.map((c) => c.outputItemId).sort((a, b) => a - b)
+    expect(ids).toEqual(
+        [ITEM_GATHERER_T1, ITEM_CRAFTER_T1, ITEM_SHIP_T1_PACKED, ITEM_EXTRACTOR_T1_PACKED].sort(
+            (a, b) => a - b
+        )
+    )
+})
+
+test('Sensor feeds the gatherer drain stat', () => {
+    const consumers = getRecipeConsumers(ITEM_SENSOR)
+    const gatherer = consumers.find((c) => c.outputItemId === ITEM_GATHERER_T1)
+    expect(gatherer).toBeDefined()
+    const drain = gatherer?.statFlows.find(
+        (f) => f.capability === 'Gathering' && f.attribute === 'drain'
+    )
+    expect(drain).toBeDefined()
+})
+
+test('Sensor is a mass-only sink in the Extractor recipe', () => {
+    const consumers = getRecipeConsumers(ITEM_SENSOR)
+    const extractor = consumers.find((c) => c.outputItemId === ITEM_EXTRACTOR_T1_PACKED)
+    expect(extractor).toBeDefined()
+    expect(extractor?.statFlows).toHaveLength(0)
+})
+
+test('getResourceDemand returns the resource tonnage for a single-resource component', () => {
+    expect(getResourceDemand(ITEM_PLATE)).toEqual({ore: 10})
+})
+
+test('getResourceDemand traces a dual-resource component to both resources', () => {
+    expect(getResourceDemand(ITEM_BEAM)).toEqual({ore: 5, gas: 5})
+})
+
+test('getResourceDemand recurses through a module to raw resources', () => {
+    // Gatherer = 300 Beam (5 ore + 5 gas each) + 300 Sensor (10 crystal each)
+    expect(getResourceDemand(ITEM_GATHERER_T1)).toEqual({
+        ore: 1500,
+        gas: 1500,
+        crystal: 3000,
+    })
+})
+
+test('getResourceDemand scales by quantity', () => {
+    expect(getResourceDemand(ITEM_PLATE, 3)).toEqual({ore: 30})
+})
+
+test('getComponentDemand reports Resin as consumed by exactly one recipe', () => {
+    const demand = getComponentDemand()
+    const resin = demand.find((d) => d.itemId === ITEM_RESIN)
+    expect(resin).toBeDefined()
+    expect(resin?.consumerCount).toBe(1)
+})

package/src/derivation/recipe-usage.ts

@@ -0,0 +1,141 @@
+import recipes from '../data/recipes.json'
+import {getRecipe, type Recipe} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
+import {getStatDefinitions} from './stats'
+import {SLOT_FORMULAS, type SlotConsumerKind} from '../data/capability-formulas'
+import {KIND_TO_ITEM_ID} from './capability-mappings'
+import type {ResourceCategory} from '../types'
+
+export function getAllRecipes(): Recipe[] {
+    return recipes as unknown as Recipe[]
+}
+
+export type ResourceDemand = Partial<Record<ResourceCategory, number>>
+
+function accumulateResourceDemand(itemId: number, quantity: number, out: ResourceDemand): void {
+    const item = getItem(itemId)
+    if (item.type === 'resource' && item.category) {
+        out[item.category] = (out[item.category] ?? 0) + quantity
+        return
+    }
+    const recipe = getRecipe(itemId)
+    if (!recipe) return
+    for (const input of recipe.inputs) {
+        accumulateResourceDemand(input.itemId, input.quantity * quantity, out)
+    }
+}
+
+// Raw-resource tonnage to craft `quantity` of an item, tracing recipes to the resource leaves.
+export function getResourceDemand(itemId: number, quantity = 1): ResourceDemand {
+    const out: ResourceDemand = {}
+    accumulateResourceDemand(itemId, quantity, out)
+    return out
+}
+
+const ITEM_ID_TO_KIND = new Map<number, SlotConsumerKind>()
+for (const [kind, itemId] of Object.entries(KIND_TO_ITEM_ID) as [SlotConsumerKind, number][]) {
+    ITEM_ID_TO_KIND.set(itemId, kind)
+}
+
+// Traces a stat index down to the raw category stat label it carries (Sensor stat 0 → "Conductivity").
+function resolveComponentStatLabel(itemId: number, statIndex: number): string | undefined {
+    let item: ReturnType<typeof getItem>
+    try {
+        item = getItem(itemId)
+    } catch {
+        return undefined
+    }
+    if (item.type === 'resource' && item.category) {
+        return getStatDefinitions(item.category)[statIndex]?.label
+    }
+    const recipe = getRecipe(itemId)
+    const slot = recipe?.statSlots[statIndex]
+    const source = slot?.sources[0]
+    if (!recipe || !source) return undefined
+    const input = recipe.inputs[source.inputIndex]
+    if (!input) return undefined
+    return resolveComponentStatLabel(input.itemId, source.statIndex)
+}
+
+export interface StatFlow {
+    slotIndex: number
+    capability?: string
+    attribute?: string
+    sourceStatIndex: number
+    sourceStatLabel?: string
+}
+
+export interface RecipeConsumer {
+    outputItemId: number
+    quantity: number
+    statFlows: StatFlow[]
+}
+
+/** Every recipe that consumes `componentItemId`, with how its stats flow through. */
+export function getRecipeConsumers(componentItemId: number): RecipeConsumer[] {
+    const out: RecipeConsumer[] = []
+    for (const recipe of getAllRecipes()) {
+        for (let inputIndex = 0; inputIndex < recipe.inputs.length; inputIndex++) {
+            if (recipe.inputs[inputIndex].itemId !== componentItemId) continue
+            const kind = ITEM_ID_TO_KIND.get(recipe.outputItemId)
+            const formulas = kind ? SLOT_FORMULAS[kind] : undefined
+            const statFlows: StatFlow[] = []
+            for (let slotIndex = 0; slotIndex < recipe.statSlots.length; slotIndex++) {
+                for (const source of recipe.statSlots[slotIndex].sources) {
+                    if (source.inputIndex !== inputIndex) continue
+                    const consumer = formulas?.[slotIndex]
+                    statFlows.push({
+                        slotIndex,
+                        capability: consumer?.capability,
+                        attribute: consumer?.attribute,
+                        sourceStatIndex: source.statIndex,
+                        sourceStatLabel: resolveComponentStatLabel(
+                            componentItemId,
+                            source.statIndex
+                        ),
+                    })
+                }
+            }
+            out.push({
+                outputItemId: recipe.outputItemId,
+                quantity: recipe.inputs[inputIndex].quantity,
+                statFlows,
+            })
+        }
+    }
+    return out
+}
+
+export interface DemandRow {
+    itemId: number
+    consumerCount: number
+    statSourceCount: number
+    sinkOnlyCount: number
+    consumers: number[]
+}
+
+/** Demand tally for every item consumed as a recipe input, ascending by usage. */
+export function getComponentDemand(): DemandRow[] {
+    const inputIds = new Set<number>()
+    for (const recipe of getAllRecipes()) {
+        for (const input of recipe.inputs) inputIds.add(input.itemId)
+    }
+    const rows: DemandRow[] = []
+    for (const itemId of inputIds) {
+        const consumers = getRecipeConsumers(itemId)
+        let statSourceCount = 0
+        let sinkOnlyCount = 0
+        for (const c of consumers) {
+            if (c.statFlows.length > 0) statSourceCount++
+            else sinkOnlyCount++
+        }
+        rows.push({
+            itemId,
+            consumerCount: consumers.length,
+            statSourceCount,
+            sinkOnlyCount,
+            consumers: consumers.map((c) => c.outputItemId),
+        })
+    }
+    return rows.sort((a, b) => a.consumerCount - b.consumerCount || a.itemId - b.itemId)
+}

package/src/derivation/reserve-regen.ts

@@ -0,0 +1,34 @@
+import type {BlockTimestamp, UInt32} from '@wharfkit/antelope'
+
+export interface EffectiveReserveInput {
+    remaining: UInt32 | number
+    max_reserve: UInt32 | number
+    last_block: BlockTimestamp
+}
+
+function toNumber(value: UInt32 | number): number {
+    return typeof value === 'number' ? value : Number(value)
+}
+
+function slotsBetween(now: BlockTimestamp, last: BlockTimestamp): number {
+    const nowMs = now.toMilliseconds()
+    const lastMs = last.toMilliseconds()
+    if (nowMs <= lastMs) return 0
+    return Math.floor((nowMs - lastMs) / 500)
+}
+
+export function getEffectiveReserve(
+    row: EffectiveReserveInput,
+    now: BlockTimestamp,
+    epochSeconds: number
+): number {
+    const remaining = toNumber(row.remaining)
+    const max = toNumber(row.max_reserve)
+    if (remaining >= max) return max
+    const epochSlots = epochSeconds * 2
+    if (epochSlots === 0) return remaining
+    const elapsed = slotsBetween(now, row.last_block)
+    const regen = Math.floor((max * elapsed) / epochSlots)
+    const effective = remaining + regen
+    return effective >= max ? max : effective
+}

package/src/derivation/resources.ts

@@ -1,15 +1,29 @@
 import {getItem} from '../data/catalog'
+import {LocationType} from '../types'
 
 export const DEPTH_THRESHOLD_T1 = 0
-export const DEPTH_THRESHOLD_T2 = 2000
-export const DEPTH_THRESHOLD_T3 = 10000
-export const DEPTH_THRESHOLD_T4 = 30000
-export const DEPTH_THRESHOLD_T5 = 55000
+export const DEPTH_THRESHOLD_T2 = 1500
+export const DEPTH_THRESHOLD_T3 = 5000
+export const DEPTH_THRESHOLD_T4 = 12000
+export const DEPTH_THRESHOLD_T5 = 22000
+export const DEPTH_THRESHOLD_T6 = 32000
+export const DEPTH_THRESHOLD_T7 = 42000
+export const DEPTH_THRESHOLD_T8 = 50000
+export const DEPTH_THRESHOLD_T9 = 57000
+export const DEPTH_THRESHOLD_T10 = 63000
 
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
 
-export const YIELD_THRESHOLD = Math.floor(0.001 * 0xffffffff)
+export const YIELD_FRACTION_SHALLOW = 0.002
+export const YIELD_FRACTION_DEEP = 0.0004
+
+export function yieldThresholdAt(stratum: number): number {
+    const clamped = stratum > 65535 ? 65535 : stratum
+    const t = clamped / 65535
+    const fraction = YIELD_FRACTION_SHALLOW + (YIELD_FRACTION_DEEP - YIELD_FRACTION_SHALLOW) * t
+    return Math.floor(fraction * 0xffffffff)
+}
 
 export const PLANET_SUBTYPE_GAS_GIANT = 0
 export const PLANET_SUBTYPE_ROCKY = 1
@@ -18,19 +32,22 @@ export const PLANET_SUBTYPE_ICY = 3
 export const PLANET_SUBTYPE_OCEAN = 4
 export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
+const DEPTH_THRESHOLD_TABLE = [
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
+    DEPTH_THRESHOLD_T6,
+    DEPTH_THRESHOLD_T7,
+    DEPTH_THRESHOLD_T8,
+    DEPTH_THRESHOLD_T9,
+    DEPTH_THRESHOLD_T10,
+]
+
 export function getDepthThreshold(tier: number): number {
-    switch (tier) {
-        case 1:
-            return DEPTH_THRESHOLD_T1
-        case 2:
-            return DEPTH_THRESHOLD_T2
-        case 3:
-            return DEPTH_THRESHOLD_T3
-        case 4:
-            return DEPTH_THRESHOLD_T4
-        default:
-            return DEPTH_THRESHOLD_T5
-    }
+    if (tier < 1 || tier > 10) return 65535
+    return DEPTH_THRESHOLD_TABLE[tier - 1]
 }
 
 export function getResourceTier(itemId: number): number {
@@ -46,9 +63,9 @@ export function getResourceWeight(itemId: number, stratum: number): number {
 
     switch (tier) {
         case 1:
-            if (stratum < 2000) return 100
-            if (stratum < 10000) return 80
-            if (stratum < 30000) return 50
+            if (stratum < DEPTH_THRESHOLD_T2) return 100
+            if (stratum < DEPTH_THRESHOLD_T3) return 80
+            if (stratum < DEPTH_THRESHOLD_T4) return 50
             return 30
         case 2:
             if (depthAbove < 3000) return 40
@@ -67,37 +84,107 @@ export function getResourceWeight(itemId: number, stratum: number): number {
     }
 }
 
-const ASTEROID_RESOURCES = [101, 102, 103, 201, 202]
-const NEBULA_RESOURCES = [202, 203, 301, 302, 303]
-const GAS_GIANT_RESOURCES = [301, 302, 303, 401, 501]
-const ROCKY_RESOURCES = [101, 102, 103, 401, 402, 403, 503]
-const TERRESTRIAL_RESOURCES = [201, 202, 401, 402, 501, 502, 503]
-const ICY_RESOURCES = [101, 301, 302, 401, 403, 501, 502]
-const OCEAN_RESOURCES = [201, 203, 301, 303, 501, 502, 503]
-const INDUSTRIAL_RESOURCES = [101, 102, 103, 201, 203, 402, 403]
+const RESOURCE_ORE = 0
+const RESOURCE_GAS = 1
+const RESOURCE_REGOLITH = 2
+const RESOURCE_BIOMASS = 3
+const RESOURCE_CRYSTAL = 4
 
-export function getLocationCandidates(locationType: number, subtype: number): number[] {
-    if (locationType === 2) return ASTEROID_RESOURCES
-    if (locationType === 3) return NEBULA_RESOURCES
-    if (locationType === 1) {
+interface LocationProfileEntry {
+    category: number
+    maxTier: number
+}
+
+function categoryBaseId(category: number): number {
+    switch (category) {
+        case RESOURCE_ORE:
+            return 100
+        case RESOURCE_CRYSTAL:
+            return 200
+        case RESOURCE_GAS:
+            return 300
+        case RESOURCE_REGOLITH:
+            return 400
+        case RESOURCE_BIOMASS:
+            return 500
+        default:
+            return 0
+    }
+}
+
+function resourceId(category: number, tier: number): number {
+    return categoryBaseId(category) + tier
+}
+
+export function getLocationProfile(locationType: number, subtype: number): LocationProfileEntry[] {
+    if (locationType === LocationType.ASTEROID) {
+        return [
+            {category: RESOURCE_ORE, maxTier: 5},
+            {category: RESOURCE_CRYSTAL, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.NEBULA) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_REGOLITH, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.ICE_FIELD) {
+        return [
+            {category: RESOURCE_GAS, maxTier: 5},
+            {category: RESOURCE_BIOMASS, maxTier: 5},
+        ]
+    }
+    if (locationType === LocationType.PLANET) {
         switch (subtype) {
             case PLANET_SUBTYPE_GAS_GIANT:
-                return GAS_GIANT_RESOURCES
+                return [
+                    {category: RESOURCE_GAS, maxTier: 10},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ROCKY:
-                return ROCKY_RESOURCES
+                return [
+                    {category: RESOURCE_REGOLITH, maxTier: 10},
+                    {category: RESOURCE_ORE, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_TERRESTRIAL:
-                return TERRESTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 10},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_ICY:
-                return ICY_RESOURCES
+                return [
+                    {category: RESOURCE_CRYSTAL, maxTier: 10},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_OCEAN:
-                return OCEAN_RESOURCES
+                return [
+                    {category: RESOURCE_BIOMASS, maxTier: 10},
+                    {category: RESOURCE_GAS, maxTier: 3},
+                ]
             case PLANET_SUBTYPE_INDUSTRIAL:
-                return INDUSTRIAL_RESOURCES
+                return [
+                    {category: RESOURCE_ORE, maxTier: 3},
+                    {category: RESOURCE_CRYSTAL, maxTier: 3},
+                    {category: RESOURCE_REGOLITH, maxTier: 3},
+                    {category: RESOURCE_BIOMASS, maxTier: 3},
+                ]
         }
     }
     return []
 }
 
+export function getLocationCandidates(locationType: number, subtype: number): number[] {
+    const profile = getLocationProfile(locationType, subtype)
+    const ids: number[] = []
+    for (const {category, maxTier} of profile) {
+        for (let tier = 1; tier <= maxTier; tier++) {
+            ids.push(resourceId(category, tier))
+        }
+    }
+    return ids
+}
+
 export function getEligibleResources(
     locationType: number,
     subtype: number,