SwiftUI Combine: вложенные наблюдаемые объекты

Когда Ball в массиве balls изменяется, вы можете вызвать objectWillChange.send(), чтобы обновить ObservableObject.

Следующее должно сработать для вас:

class BallManager: ObservableObject {
    @Published var balls: [Ball] {
        didSet { setCancellables() }
    }
    let ballPublisher = PassthroughSubject<Ball, Never>()
    private var cancellables = [AnyCancellable]()
    
    init() {
        self.balls = []
    }
    
    private func setCancellables() {
        cancellables = balls.map { ball in
            ball.objectWillChange.sink { [weak self] in
                guard let self = self else { return }
                self.objectWillChange.send()
                self.ballPublisher.send(ball)
            }
        }
    }
}

И получите изменения с помощью:

.onReceive(bm.ballPublisher) { ball in
    print("ball update:", ball.id, ball.color)
}

Примечание. Если было передано начальное значение balls, а не всегда пустой массив, вам также следует вызвать setCancellables() в файле init.

Модель

Ball - это модель, которая может быть структурой или классом (обычно рекомендуется структура, вы можете найти дополнительную информацию здесь)

ViewModel

Обычно вы используете ObservableObject как ViewModel или компонент, который управляет данными. Обычно для шаров (моделей) обычно устанавливают значение по умолчанию, поэтому вы можете установить пустой массив. Затем вы можете заполнить модели сетевым запросом из базы данных или хранилища.

BallManager можно переименовать в BallViewModel

BallViewModel имеет функцию, которая изменяет базовую модель на основе индекса в компоненте ForEach. id: \.self в основном отображает мяч (модель) для текущего индекса.

Предложенное решение

Следующие изменения будут работать для достижения того, что вы хотите сделать.

struct Ball: Identifiable {
    let id: UUID
    var color: String
    init(ofColor color: String) {
        self.id = UUID()
        self.color = color
    }
}

class BallViewModel: ObservableObject {
    @Published var balls: [Ball] = []

    func changeBallColor(in index: Int, color: String) {
        balls[index] = Ball(ofColor: color)
    }
}

struct Arena: View {
   @StateObject var bm = BallViewModel()

    var body: some View {
        VStack(spacing: 20) {
            ForEach(bm.balls.indices, id: \.self) { index in
                Button(bm.balls[index].color) {
                    bm.changeBallColor(in: index, color: "cx")
                }
            }
        }
        .onAppear(perform: createBalls)
        .onReceive(bm.$balls, perform: {
            print("ball update: \($0)")
        })
    }

    func createBalls() {
        for i in 1..<4 {
            bm.balls.append(Ball(ofColor: "c\(i)"))
        }
    }
}

В этом примере вложенный ObserverObjects не нужен:

Модель должна быть простой структурой:

struct Ball: Identifiable {
    let id: UUID
    let color: String
    init(id: UUID = UUID(),
         color: String) {
        self.id = id
        self.color = color
    }
}

ViewModel должен обрабатывать всю логику, поэтому я переместил сюда все функции, управляющие шарами, и сделал массив шаров приватным. Поскольку вызов changeBall заменяет одну структуру в массиве другой, запускается objectWillChange, обновляется представление и запускается onReceive.

class BallManager: ObservableObject {
    @Published private (set) var balls = [Ball]()
    
    func changeBall(_ ball: Ball) {
        guard let index = balls.firstIndex(where: { $0.id == ball.id }) else { return }
        balls[index] = Ball(id: ball.id, color: "cx")
    }
    
    func createBalls() {
        for i in 1..<4 {
            balls.append(Ball(color: "c\(i)"))
        }
    }
}

View должен просто сообщать намерения пользователя ViewModel:

struct Arena: View {

   @StateObject var ballManager = BallManager()

    var body: some View {
        VStack(spacing: 20) {
            ForEach(ballManager.balls) { ball in
                Text(ball.color)
                    .onTapGesture {
                        ballManager.changeBall(ball)
                    }
            }
        }
        .onAppear(perform: ballManager.createBalls)
        .onReceive(ballManager.$balls) {
            print("ball update: \($0)")
        }
    }
}

Вы просто создаете BallView, наблюдаете за ним и вносите изменения оттуда. Вы должны наблюдать за каждым ObservableObject напрямую

struct Arena: View {
    @StateObject var bm = BallManager()
    
    var body: some View {
        VStack(spacing: 20) {
            ForEach(bm.balls) { ball in
                BallView(ball: ball)
            }
        }
        .onAppear(perform: createBalls)
        .onReceive(bm.$balls, perform: {
            print("ball update: \($0)")
        })
    }
    
    func createBalls() {
        for i in 1..<4 {
            bm.balls.append(Ball(ofColor: "c\(i)"))
        }
    }
    
    
}
struct BallView: View {
    @ObservedObject var ball: Ball
    
    var body: some View {
        Text(ball.color)
            .onTapGesture {
                changeBall(ball)
            }
    }
    func changeBall(_ ball: Ball) {
        ball.color = "cx"
    }
}