Method sortThangComponents

app/models/Level.js:351–416

(thangs, levelComponents, parentType)

    }

    sortThangComponents (thangs, levelComponents, parentType) {
      // Here we have to sort the Components by their dependencies.
      // It's a bit tricky though, because we don't have either soft dependencies or priority levels.
      // Example: Programmable must come last, since it has to override any Component-provided methods that any other Component might have created. Can't enumerate all soft dependencies.
      // Example: Plans needs to come after everything except Programmable, since other Components that add plannable methods need to have done so by the time Plans is attached.
      // Example: Collides doesn't depend on Allied, but if both exist, Collides must come after Allied. Soft dependency example. Can't just figure out a proper priority to take care of it.
      // Example: Moves doesn't depend on Acts, but if both exist, Moves must come after Acts. Another soft dependency example.
      // Decision? Just special case the sort logic in here until we have more examples than these two and decide how best to handle most of the cases then, since we don't really know the whole of the problem yet.
      // TODO: anything that depends on Programmable will break right now.

      const originalsToComponents = _.indexBy(levelComponents, 'original') // Optimization for speed
      const alliedComponent = _.find(levelComponents, { name: 'Allied' })
      const actsComponent = _.find(levelComponents, { name: 'Acts' })

      return (() => {
        const result = []
        for (const thang of Array.from(thangs != null ? thangs : [])) {
          const originalsToThangComponents = _.indexBy(thang.components, 'original')
          const sorted = []
          const visit = function (c, namesToIgnore) {
            let c2
            if (Array.from(sorted).includes(c)) { return }
            const lc = originalsToComponents[c.original]
            if (!lc) { console.error(thang.id || thang.name, 'couldn\'t find lc for', c, 'of', levelComponents) }
            if (!lc) { return }
            if (namesToIgnore && Array.from(namesToIgnore).includes(lc.name)) { return }
            if (lc.name === 'Plans') {
              // Plans always comes second-to-last, behind Programmable
              for (c2 of Array.from(thang.components)) { visit(c2, [lc.name, 'Programmable']) }
            } else if (lc.name === 'Programmable') {
              // Programmable always comes last
              for (c2 of Array.from(thang.components)) { visit(c2, [lc.name]) }
            } else {
              for (const d of Array.from(lc.dependencies || [])) {
                c2 = originalsToThangComponents[d.original]
                if (!c2) {
                  let dependent = originalsToComponents[d.original]
                  dependent = (dependent != null ? dependent.name : undefined) || d.original
                  console.error(parentType, thang.id || thang.name, 'does not have dependent Component', dependent, 'from', lc.name)
                }
                if (c2) { visit(c2) }
              }
              if ((lc.name === 'Collides') && alliedComponent) {
                const allied = originalsToThangComponents[alliedComponent.original]
                if (allied) {
                  visit(allied)
                }
              }
              if ((lc.name === 'Moves') && actsComponent) {
                const acts = originalsToThangComponents[actsComponent.original]
                if (acts) {
                  visit(acts)
                }
              }
            }
            // console.log thang.id, 'sorted comps adding', lc.name
            return sorted.push(c)
          }