我正在尝试创建一个基本函数以用于程序中的多个随机化（初级）

Answer 1

Swift 函数可以使用一个元组返回多个值。如果您创建一个通用滚动函数来返回数组和最大值，您可以调用它并将结果分配给您的变量：

func roll() -> (array: [Int], max: Int) {
    var result = [Int]()
    
    for _ in 1...3 {
        var sum = 0
        for _ in 1...3 {
            sum += Int.random(in: 1...6)
        }
        result.append(sum)
    }

    return (result, result.max()!)
}

然后你会这样称呼它：

(strArray, strStat) = roll()
(dexArray, dexStat) = roll()
    

---

定义一个RollData 结构

您的数组和 stat 不应该是两个不同的 @State 变量，因为它们是相关的。您应该将它们组合成一个struct。

struct RollData {
    let array: [Int]
    let stat: Int
}

func roll() -> RollData {
    var result = [Int]()
    
    for _ in 1...3 {
        var sum = 0
        for _ in 1...3 {
            sum += Int.random(in: 1...6)
        }
        result.append(sum)
    }
    
    return RollData(array: result, stat: result.max()!)
}

然后你会像这样声明你的 @State 变量：

@State private var strRoll = roll()
@State private var dexRoll = roll()

像这样滚动：

strRoll = roll()
dexRoll = roll()

并像这样访问数据：

Text(String(strRoll.stat))

Text("\(strRoll.array[0]),\(strRoll.array[1]),\(strRoll.array[2])")

---

完整示例

这是一个有趣的项目。我做了一些额外的更改，我认为您可能希望看到这些更改。

笔记：

1. 我创建了一个DieType enum，它对每种模具类型都有一个值。我将其设为Int 类型，以便我们可以将其用作所有模具数组的索引。我将其设为CaseIterable，以便我们可以使用DieType.allCases 获得所有类型的数组。我将其设为CustomStringConvertible，因此该类型可以很好地打印其名称，如计算属性description。我把它做成了Identifiable，这样我们就可以像这样使用它SwiftUI：ForEach(DieType.allCases) { die in。
2. 我创建了一个AllDice struct 来存放所有的骰子。现在我们只需要一个@State dice = AllDice() 来使用该应用程序。它具有滚动所有骰子、按类型滚动单个骰子、获取骰子的stat 和array 的属性。
3. 应用程序的主循环是VStack，每个模具类型都有一行。模具类型的数量没有硬编码的 6。通过定义新的模具类型或删除一个，代码会自动适应。

   ---

   import SwiftUI
   
   struct RollData {
       let array: [Int]
       let stat: Int
   }
   
   func roll() -> RollData {
       var result = [Int]()
       
       for _ in 1...3 {
           var sum = 0
           for _ in 1...3 {
               sum += Int.random(in: 1...6)
           }
           result.append(sum)
       }
       
       return RollData(array: result, stat: result.max()!)
   }
   
   enum DieType: Int, CaseIterable, CustomStringConvertible, Identifiable {
       case strength = 0, dexterity, constitution, intelligence, wisdom, charisma
       
       var id: Int { self.rawValue }
       
       var description: String {
           switch self {
           case .strength: return "Strength"
           case .dexterity: return "Dexterity"
           case .constitution: return "Constitution"
           case .intelligence: return "Intelligence"
           case .wisdom: return "Wisdom"
           case .charisma: return "Charisma"
           }
       }
   }
   
   struct AllDice {
       private var dice: [RollData] = (0..<DieType.allCases.count).map { _ in roll() }
       
       func array(die: DieType) -> [Int] {
           dice[die.rawValue].array
       }
       
       func stat(die: DieType) -> Int {
           dice[die.rawValue].stat
       }
       
       mutating func rollDie(die: DieType) {
           dice[die.rawValue] = roll()
       }
       
       mutating func rollAll() {
           for die in DieType.allCases {
               rollDie(die: die)
           }
       }
   }
   
   struct ContentView: View {
       
       @State private var dice = AllDice()
       
       var body: some View {
           
           // MARK: STATS UI
           
           VStack {
               ForEach(DieType.allCases) { die in
                   let array = dice.array(die: die)
                   
                   HStack(spacing: 10) {
                       
                       Capsule()
                           .fill(Color.blue.opacity(0.2))
                           .frame(width: 80, height: 30)
                           .overlay (
                               HStack {
                                   Text("3 x")
                                   Image(systemName: "dice")
                                       .foregroundColor(.red)
                               }
                           )
                       
                       Text(String(describing: die))
                           .frame(width: 100)
                       
                       Capsule()
                           .fill(Color.blue.opacity(0.2))
                           .frame(width: 50, height: 30)
                           .overlay (
                               Text(String(describing: dice.stat(die: die)))
   
                           )
                       
                       Capsule()
                           .fill(Color.blue.opacity(0.2))
                           .frame(width: 100, height: 30)
                           .overlay (
                               Text("\(array[0]), \(array[1]), \(array[2])")
                           )
                   } //: HStack
                   
               } //: ForEach
               
               // MARK: BUTTON ROLL
               Button(action:  {
                   
                   dice.rollAll()
                   
               })  {
                   Capsule()
                       .fill(Color.blue.opacity(0.2))
                       .frame(width: 130, height: 30)
                       .overlay (
                           HStack {
                               Image(systemName: "dice")
                               Text("Roll Stats")
                           }
                           .foregroundColor(.red)
                       )
                           
               } //: BUTTON
               
           } //: VStack
       }
   }