Итерация по вложенной структуре и возвращение итоговых значений для каждой структуры

Question

Я экспериментирую со Swift, пытаюсь создать базовый игровой движок.

У меня есть Struct, который определяет бойца, внутри которого находится ряд структур, используемых для определения набора навыков, который имеет боец.

Я хотел бы пройтись по каждому «бойцу» и суммировать каждый отдельный набор навыков, возвращая по существу 3 значения - итоговые значения standUp, clinch, ground

Я могу перебрать структуру Fighter, однако я могу только выйти из этих вложенных структур.

Как мне подойти к циклу по структуре и затем к циклу по вложенным структурам, возвращая сумму каждого цикла как его собственное значение? возможно, как часть кортежа?

import UIKit

struct StandUp {
    let boxing: Int
    let kickBoxing: Int
}

struct Clinch {
    let judo: Int
    let freestyle: Int
}

struct Ground {
    let bjj: Int
    let judo: Int
}

struct Fighter {
    let standUp: StandUp
    let clinch: Clinch
    let ground: Ground
}

let striker = Fighter(
    standUp: StandUp(boxing: 8, kickBoxing: 7),
    clinch: Clinch(judo: 5, freestyle: 4),
    ground: Ground(bjj: 6, judo: 5)
)

let bjj = Fighter(
    standUp: StandUp(boxing: 5, kickBoxing: 4),
    clinch: Clinch(judo: 7, freestyle: 8),
    ground: Ground(bjj: 8, judo: 7)
)

class FightEngine {
    private let fOne: Fighter
    private let fTwo: Fighter

    init(fighterOne: Fighter, fighterTwo: Fighter) {
        fOne = fighterOne
        fTwo = fighterTwo
    }

   private func sumSkillSet(fighter: Fighter) -> Int {
        var total: Int
        let mirror = Mirror(reflecting: fighter)

        for skill in mirror.children {
            print(skill.value)
        }

        return 1 // Only returning this so the code will run
    }


    func getTotals() -> (Int, Int) {
        let totalOne = sumSkillSet(fighter: fOne)
        let totalTwo = sumSkillSet(fighter: fTwo)

        return (1, 2) // Only returning this so the code will run
    }

}


let fE = FightEngine(fighterOne: striker, fighterTwo: bjj)

fE.getTotals() // This should be a dictionary of each fighters totals, 3 values for each fighter

В идеале я хотел бы получить какой-то доход от fE.getTotals(), как

["fighterOne":(1,2,3), "fighterTwo":(4,5,6)] 

Answer 1

Вы можете сделать это с помощью enum, где каждый случай представляет набор навыков, в котором есть аргументы инициализации, используемые для вычисления общего балла набора навыков.

enum SkillSet {

    case standUp(boxing: Int, kickBoxing: Int)
    case clinch(judo: Int, freestyle: Int)
    case ground(bjj: Int, judo: Int)

    var score: Int {
        switch self {
        case .standUp(let boxing, let kickBoxing): return boxing + kickBoxing
        case .clinch(let judo, let freestyle): return judo + freestyle
        case .ground(let bjj, let judo): return bjj + judo
        }
     }
}

У бойца может быть массив SkillSet, с помощью которого мы можем уменьшить общий счет, суммируя вместе счет каждого набора навыков.

struct Fighter {

    let skillSets: [SkillSet]

    var total: Int {
        return skillSets.reduce(0) { (sum, skillSet) in
            return sum + skillSet.score
        }
    }
}

Ваш двигатель может быть упрощен и может быть связан только с началом боя и подсчетом очков.

class FightEngine {

    let fighters: (Fighter, Fighter)

    init(one: Fighter, two: Fighter) { self.fighters = (one, two) }

    func getTotals() -> (Int, Int) { return (fighters.0.total, fighters.1.total) }
}

Дин Дин

let fightEngine = FightEngine(
    one: Fighter(
        skillSets: [
            .standUp(boxing: 8, kickBoxing: 7),
            .clinch(judo: 5, freestyle: 4),
            .ground(bjj: 6, judo: 5)
        ]
    ),
    two: Fighter(
        skillSets: [
            .standUp(boxing: 5, kickBoxing: 4),
            .clinch(judo: 7, freestyle: 8),
            .ground(bjj: 8, judo: 7)
        ]
    )
)

print(fightEngine.getTotals())

Answer 2

Я думаю, это то, что вы ищете.

struct StandUp {
    let boxing: Int
    let kickBoxing: Int

    func sum() -> Int {
        return boxing + kickBoxing
    }
}

struct Clinch {
    let judo: Int
    let freestyle: Int

    func sum() -> Int {
        return judo + freestyle
    }
}

struct Ground {
    let bjj: Int
    let judo: Int

    func sum() -> Int {
        return bjj + judo
    }
}

struct Fighter {
    let standUp: StandUp
    let clinch: Clinch
    let ground: Ground

    func sum() -> [Int] {
        return [standUp.sum(), clinch.sum(), ground.sum()]
    }
}

let striker = Fighter(
    standUp: StandUp(boxing: 8, kickBoxing: 7),
    clinch: Clinch(judo: 5, freestyle: 4),
    ground: Ground(bjj: 6, judo: 5)
)

let bjj = Fighter(
    standUp: StandUp(boxing: 5, kickBoxing: 4),
    clinch: Clinch(judo: 7, freestyle: 8),
    ground: Ground(bjj: 8, judo: 7)
)

class FightEngine {
    private let fOne: Fighter
    private let fTwo: Fighter

    init(fighterOne: Fighter, fighterTwo: Fighter) {
        fOne = fighterOne
        fTwo = fighterTwo
    }

    func getTotals() -> [String: [Int]] {
        return ["fighterOne": fOne.sum(), "fighterTwo": fTwo.sum()]
    }

}

Примечание: Я рекомендую добавить параметр name в Fighter и использовать его в качестве ключа вместо "fighterOne" и "fighterTwo".

[fOne.name: totalOne, fTwo.name: totalTwo]