gistfile1.txt

function indexOfMatch<T>(value: T, values: T[]) {
    return values.indexOf(value)
}

interface Card {
    power: [number, number, number, number],
    team: number
}

enum UpdateKind {
    None,
    Greater,
    Same,
    Plus
}

class Table {
  sameEnabled: boolean = true
  plusEnabled: boolean = true

  size = { x: 3, y: 3 }
  grid: Card[] = Array(this.size.x * this.size.y)

  getCard(x: number, y: number): Card {
    return this.grid[(y * this.size.x) + x]
  }

  placeCard(card: Card, x: number, y: number) {
    let placedAt = (y * this.size.x) + x
    this.grid[placedAt] = card
    this.tryUpdateCards(placedAt, card.team, false)
  }

  tryUpdateCards(cardIndex: number, toTeam: number, inCombo: boolean) {
    let card = this.grid[cardIndex]
    let updates: UpdateKind[] = [0, 0, 0, 0]
    // let sameMap: number[] = Array(10).fill(-1)
    // let addedMap: number[] = Array(10).fill(-1)

    let offsets = [-this.size.x, -1, 1, this.size.x]
    for(let i = 0; i < offsets.length; i++) {
        let offset = offsets[i]
        let checkAt = cardIndex + offset
        let checkCard = this.grid[checkAt]
        if(!checkCard || checkCard.team == toTeam) continue
        let adjacentPower = checkCard.power[3 - i]
        let addedPower = card.power[i] + adjacentPower
        let isSame = card.power[i] == adjacentPower

        if (updates[i] == 0 && card.power[i] > adjacentPower) {
            updates[i] = UpdateKind.Greater
        }

        if(!inCombo) {
            for(let j = i + 1; j < offsets.length; j++) {
                let offset1 = offsets[j]
                let checkAt1 = cardIndex + offset1
                let checkCard1 = this.grid[checkAt1]
                if(!checkCard1 || checkCard1.team == toTeam) continue
                let adjacentPower1 = checkCard1.power[3 - j]
                let addedPower1 = card.power[j] + adjacentPower1
                let isSame1 = card.power[j] == adjacentPower1
                
                let index = indexOfMatch(true, [
                    addedPower == addedPower1,
                    isSame && isSame1,
                    true
                ])

                let update = [UpdateKind.Plus, UpdateKind.Same, UpdateKind.None][index]

                if(update != 0) {
                    updates[i] = update
                    updates[j] = update
                }
            }
        }

        // let sameIndex = sameMap[adjacentPower]
        // if(sameIndex >= 0) {
        //     updates[i] = UpdateKind.Same
        //     updates[sameIndex] = UpdateKind.Same
        // }
        // sameMap[adjacentPower] = i

        // let addedPower = card.power[i] + adjacentPower
        // let sumSameIndex = addedMap[addedPower]
        // if(sumSameIndex >= 0) {
        //     updates[i] = UpdateKind.Plus
        //     updates[sumSameIndex] = UpdateKind.Plus
        // }
        // addedMap[addedPower] = i
    }

    console.log(updates)
    for(let i = 0; i < offsets.length; i++) {
        if(updates[i] != 0) {
            this.updateCard(cardIndex + offsets[i], toTeam)
            this.tryUpdateCards(cardIndex + offsets[i], toTeam, updates[i] == UpdateKind.Greater ? inCombo : true)
        }
    }
  }

  updateCard(cardIndex: number, toTeam: number) {
    let card = this.grid[cardIndex]
    if(card.team == toTeam) return
    card.team = toTeam
  }
}

const table = new Table

table.placeCard({
    power: [1, 2, 3, 4],
    team: 0,  
}, 1, 0)

table.placeCard({
    power: [1, 2, 3, 4],
    team: 0,  
}, 0, 1)

table.placeCard({
    power: [1, 1, 2, 1],
    team: 1,  
}, 0, 0)

console.log(table.grid.map(card => card.team))