Я хочу поделиться с вами опытом создания «с нуля» iOS приложения известной игры 2048 с элементами ИИ (искусственного интеллекта) в SwiftUI с помощью ChatGPT .
В своем классическом варианте, когда играет пользователь с помощью жестов (вверх, вниз, вправо, влево), это довольно простая игра и создать полноценное iOS приложение для такой игры 2048 можно за короткое время, при этом код будет понятен каждому. Но простые правила игры только подталкивают к созданию оптимальных алгоритмов решения игры 2048, то есть к созданию ИИ, который мог бы играть в эту игру автоматически и максимизировать счет игры в разумные сроки.
Мне хотелось написать игру 2048 именно на SwiftUI, пользуясь его прекрасной и мощной анимацией и приличным быстродействием , a также предоставить в распоряжения пользователя не только “ручной” способ игры, когда Вы руководите тем, каким должен быть следующий ход: вверх, вниз, влево и вправо, но и ряд алгоритмов с оптимальной стратегией (метода Монте-Карло, стратегий поиска по деревьям (Minimax, Expectimax) ), позволяющих АВТОМАТИЧЕСКИ выполнять ходы — вверх, вниз, влево и вправо — и добиться плитки с числом 2048 и более (эти алгоритмы и называют алгоритмами “искусственного интеллекта” (ИИ)). Необходимым элементом ИИ является алгоритм поиска, который позволяет смотреть вперед на возможные будущие позиции, прежде чем решить, какой ход он хочет сделать в текущей позиции.
2048 — это очень известная игра, и мне не нужно было объяснять ChatGPT ее правила, он сам всё про неё знает. Кроме того, оказалось, что ChatGPT прекрасно осведомлен об ИИ алгоритмах для игры 2048, так что мне вообще не пришлось описывать ChatGPT контекст решаемой задачи. И он предлагал мне множество таких неординарных решений, которые мне пришлось бы долго выискивать в научных журналах.
Чтобы вы в дальнейшем смогли оценить эти решения, я кратко напомню правила игры 2048.
Сама игра проста. Вам дается игровое поле размером 4×4, где каждая плитка может содержать число внутри себя.
Числа на игровом поле всегда будут степенью двойки. Изначально есть только две плитки с номерами 2 или 4. Вы можете менять игровое поле, нажимая на клавиши со стрелками — вверх, вниз, вправо, влево — и все плитки будут двигаться в этом направлении, пока не будет остановлены либо другой плиткой, либо границей сетки. Если две плитки с одинаковыми числами столкнутся во время движения, они сольются в новую плитку с их суммой. Новая плитка не может повторно слиться с другой соседней плиткой во время этого перемещения. После перемещения новая плитка с числом 2 или 4 случайным образом появится на одной из пустых плиток, после чего игрок делает новый ход.
Цель игры состоит в том, чтобы достичь плитки с числом 2048, но её можно рассматривать более широко и достигать плитку с максимально возможным числом. На самом деле существует система подсчета очков, применяемая к каждому ходу. Счет игрока начинается с нуля и увеличивается всякий раз, когда две плитки объединяются, на значение нового числа объединенной плитки. Если нет пустой ячейки и больше нет допустимых ходов, то игра заканчивается.
Итак, моя задача заключалась не только в том, чтобы создать движок игры 2048 на Swift, но и разработать UI c анимацией движения плиток с помощью SwiftUI, a также задействовать ИИ (алгоритмы Expectimax и Monte Carlo) в игре 2048. При этом я хотела максимально использовать возможности ChatGPT.
В статье подробно рассмотрены следующие этапы разработки такого iOS приложения игры 2048 с помощью ChatGPT:
-
Логика игры без анимации.
-
Разработка UI (анимация перемещения плиток и появления новых случайных плиток, отображение оптимального направления перемещения плиток на игровом поле).
-
Добавление AI (алгоритмы Greedy, Expectimax и MonteCarlo) в игру 2048 c автоматическим запуском.
На третьем этапе я получила от ChatGPT два алгоритма ИИ — Expectimax и Monte Carlo — и их варианты, которые позволяют получать очень приличные результаты — плитки со значениями 4096 и 8092.
Алгоритм Expectimax в действии
Заметьте, какой разный рисунок игры у этих двух совершенно разных ИИ алгоритмов, стремящихся к одному и тому же результату.
Я использовала бесплатную версию ChatGPT 4-o.mini (не самую мощную). Все вопросы задавались на английском и ответы от ChatGPT 4-o.mini тоже были получены на английском, но впоследствие переведены самим же ChatGPT для вас на русский.
В плане движка игры 2048 и UI с анимацией ChatGPT дал возможность очень быстро получить понятный лаконичный код с отличными функциональными возможностями, хотя без ошибок не обошлось. У меня было очень мало ошибок, но они были завуалированными, которые не так-то просто найти. Вот тогда и приходилось прибегать к использованию тестов, которые ChatGPT генерирует отлично.
В плане ИИ для игры 2048 ChatGPT не просто поразил меня своей эрудицией, он предоставил мне готовыми такие ИИ алгоритмы, как Expextimax и Monte Carlo со множеством оптимизирующих возможностей для получения более значимого результата. И это не просто советы, все это сопровождается соответствующим кодом. В частности, использование Swift многопоточности позволило сделать код более эффективным, особенно для больших и глубоких деревьев поиска в игре 2048.
Еще более ценно то, что этот материал можно эффективно использовать для обучения программированию на Swift и SwiftUI не хуже Стэнфордского курса.
Полный протокол взаимодействия с ChatGPT при создании iOS приложения игры 2048 представлен в 3-х постах на моем сайте:
-
iOS приложения игры 2048 в SwiftUI с ChatGPT 4-o. Часть 1. Введение. Логика игры 2048.
-
iOS приложения игры 2048 в SwiftUI с ChatGPT 4-o. Часть 2. Анимация и UI.
-
iOS приложение игры 2048 в SwiftUI с ChatGPT. Часть 3. ИИ (AI) для игры 2048.
А код находится на GitHub. В этой статье я представляю лишь отдельные фрагменты этого протокола, чтобы вы могли почувствовать, насколько полезным может быть ChatGPT как при разработки, так и при обучении.
Логика игры 2048
Итак, первый запрос к ChatGPT:
ШАГ 1. Начало
код GameViwModel
import SwiftUI enum Direction { case up, down, left, right } class GameViewModel: ObservableObject { @Published var board: [[Int]] @Published var gameOver = false init() { board = Array(repeating: Array(repeating: 0, count: 4), count: 4) addNewTile() addNewTile() } func addNewTile() { var emptyTiles: [(Int, Int)] = [] for row in 0..<4 { for col in 0..<4 { if board[row][col] == 0 { emptyTiles.append((row, col)) } } } if let randomTile = emptyTiles.randomElement() { board[randomTile.0][randomTile.1] = Bool.random() ? 2 : 4 } } func resetGame(_ direction: Direction) { // Reset the board to the initial state board = Array(repeating: Array(repeating: 0, count: 4), count: 4) gameOver = false addNewTile() addNewTile() } func move(_ direction: Direction) { // Implement the movement logic here // This will include merging tiles and updating the board state // After moving tiles, call addNewTile() to add a new tile } func checkGameOver() { // Implement the logic to check if the game is over // This will involve checking if there are any valid moves left } }
код GameView
struct GameView: View { @StateObject private var viewModel = GameViewModel() var body: some View { VStack { Text("2048") .font(.largeTitle) .padding() GridView(board: viewModel.board) .padding() Button(action: { // Implement restart functionality viewModel = GameViewModel() }) { Text("Restart") .font(.title) .padding() } } .onAppear { // Initialize game state } .onReceive(NotificationCenter.default.publisher(for: UIResponder.keyboardWillShowNotification)) { _ in // Handle keyboard events or gestures here } } } struct GridView: View { let board: [[Int]] var body: some View { VStack(spacing: 8) { ForEach(0..<4) { row in HStack(spacing: 8) { ForEach(0..<4) { col in TileView(value: board[row][col]) } } } } } } struct TileView: View { let value: Int var body: some View { Text(value == 0 ? "" : "\(value)") .frame(width: 80, height: 80) .background(Color.gray.opacity(0.4)) .cornerRadius(10) .font(.title) .foregroundColor(.black) } }
код GameView с жестом DragGesture
struct GameView: View { @StateObject private var viewModel = GameViewModel() var body: some View { VStack { Text("2048") .font(.largeTitle) .padding() GridView(board: viewModel.board) .padding() .gesture( DragGesture() .onEnded { value in let horizontalAmount = value.translation.width let verticalAmount = value.translation.height if abs(horizontalAmount) > abs(verticalAmount) { if horizontalAmount > 0 { viewModel.move(.right) } else { viewModel.move(.left) } } else { if verticalAmount > 0 { viewModel.move(.down) } else { viewModel.move(.up) } } } ) Button(action: { viewModel = viewModel.resetGame() }) { Text("Restart") .font(.title) .padding() } } } }
Копируем полученный код в наш проект в Xcode:
Мы получили вполне себе работающий код генерации UI с необходимыми “заглушками” для логики игры 2048, которые придется наполнять кодом.
ШАГ 2. Функция move()
Получим код для самой главной функции move() с помощью CharGPT:
Функция move (_ direction:Direction)
func move(_ direction: Direction) { var moved = false // Rotate the board so that we can treat each move as if it's a "left" move switch direction { case .up: rotateLeft() case .down: rotateRight() case .right: rotateRight() rotateRight() case .left: break } for i in 0..<4 { let compressedRow = compressRow(board[i]) let mergedRow = mergeRow(compressedRow) let finalRow = compressRow(mergedRow) if finalRow != board[i] { moved = true } board[i] = finalRow } // Rotate the board back to its original orientation switch direction { case .up: rotateRight() case .down: rotateLeft() case .right: rotateRight() rotateRight() case .left: break } if moved { addNewTile() checkGameOver() } }
func rotateLeft() { board = (0..<4).map { i in (0..<4).map { j in board[j][3 - i] } } } func rotateRight() { board = (0..<4).map { i in (0..<4).map { j in board[3 - j][i] } } }
func compressRow(_ row: [Int]) -> [Int] { let filteredRow = row.filter { $0 != 0 } let zeros = Array(repeating: 0, count: 4 - filteredRow.count) return filteredRow + zeros }
func mergeRow(_ row: [Int]) -> [Int] { var newRow = row for i in 0..<3 { if newRow[i] != 0 && newRow[i] == newRow[i + 1] { newRow[i] *= 2 newRow[i + 1] = 0 } } return newRow }
Новый GameViewModel:
enum Direction { case up, down, left, right } class GameViewModel: ObservableObject { @Published var board: [[Int]] @Published var isGameOver = false init() { board = Array(repeating: Array(repeating: 0, count: 4), count: 4) addNewTile() addNewTile() } func addNewTile() { var emptyTiles: [(Int, Int)] = [] for row in 0..<4 { for col in 0..<4 { if board[row][col] == 0 { emptyTiles.append((row, col)) } } } if let randomTile = emptyTiles.randomElement() { board[randomTile.0][randomTile.1] = Bool.random() ? 2 : 4 } } func move(_ direction: Direction) { var moved = false switch direction { case .up: rotateLeft() case .down: rotateRight() case .right: rotateRight() rotateRight() case .left: break } for i in 0..<4 { let compressedRow = compressRow(board[i]) let mergedRow = mergeRow(compressedRow) let finalRow = compressRow(mergedRow) if finalRow != board[i] { moved = true } board[i] = finalRow } switch direction { case .up: rotateRight() case .down: rotateLeft() case .right: rotateRight() rotateRight() case .left: break } if moved { addNewTile() checkGameOver() } } func checkGameOver() { // Implement the logic to check if the game is over // This will involve checking if there are any valid moves left } func resetGame() { board = Array(repeating: Array(repeating: 0, count: 4), count: 4) gameOver = false addNewTile() addNewTile() } private func rotateLeft() { board = (0..<4).map { i in (0..<4).map { j in board[j][3 - i] } } } private func rotateRight() { board = (0..<4).map { i in (0..<4).map { j in board[3 - j][i] } } } private func compressRow(_ row: [Int]) -> [Int] { let filteredRow = row.filter { $0 != 0 } let zeros = Array(repeating: 0, count: 4 - filteredRow.count) return filteredRow + zeros } private func mergeRow(_ row: [Int]) -> [Int] { var newRow = row for i in 0..<3 { if newRow[i] != 0 && newRow[i] == newRow[i + 1] { newRow[i] *= 2 newRow[i + 1] = 0 } } return newRow } }
Круто!!
За 2 шага мы получили работающий вариант игры 2048. Перемещение и слияние плиток работает, но без анимации, кроме того, нет индикации об окончании игры и счета. Давайте сначала добавим анимацию плиток на игровом поле.
UI и анимация игры 2048
ШАГ 3. Подготовка модели к анимации перемещения плиток
Давайте проведем подготовку к анимации перемещения плиток и наделим наши плитки не только значением value, но и положением position плитки на игровом поле. Теперь нашу плитку будет моделировать структура struct Tile, в которой в качестве свойства плитки position используется структура struct Position { var row: int var col: Int}, a игровое поле представлено двухмерным массивом var board: [[Tile]]:
import SwiftUI struct Position { var row: Int var col: Int } struct Tile { var value: Int var position: Position }Обновление GameViewModel в связи с использованием Tile:
import SwiftUI enum Direction { case up, down, left, right } class GameViewModel: ObservableObject { @Published var tiles: [[Tile]] = [] @Published var isGameOver = false init() { resetGame() } func resetGame() { isGameOver = false tiles = (0..<4).map { row in (0..<4).map { col in Tile(value: 0, position: Position(row: row, col: col)) } } addNewTile() addNewTile() } func addNewTile() { var emptyPositions: [Position] = [] for row in 0..<4 { for col in 0..<4 { if tiles[row][col].value == 0 { emptyPositions.append(Position(row: row, col: col)) } } } if let randomPosition = emptyPositions.randomElement() { let newValue = Bool.random() ? 2 : 4 tiles[randomPosition.row][randomPosition.col].value = newValue } } func move(_ direction: Direction) { var moved = false // Rotate the board so we can always handle the move as a "left" move switch direction { case .up: rotateLeft() case .down: rotateRight() case .right: rotateRight() rotateRight() case .left: break } for i in 0..<4 { let row = getRow(i) let compressedRow = compressRow(row) let mergedRow = mergeRow(compressedRow) if mergedRow != row { moved = true updateRow(i, with: mergedRow) } } switch direction { case .up: rotateRight() case .down: rotateLeft() case .right: rotateRight() rotateRight() case .left: break } if moved { addNewTile() checkGameOver() } } func checkGameOver() { // Implement the logic to check if the game is over } private func rotateLeft() { tiles = (0..<4).map { col in (0..<4).map { row in var tile = tiles[row][3 - col] tile.position = Position(row: col, col: row) return tile } } } private func rotateRight() { tiles = (0..<4).map { col in (0..<4).map { row in var tile = tiles[3 - row][col] tile.position = Position(row: col, col: row) return tile } } } private func getRow(_ index: Int) -> [Tile] { return tiles[index] } private func updateRow(_ index: Int, with newRow: [Tile]) { for col in 0..<4 { tiles[index][col] = newRow[col] } } private func compressRow(_ row: [Tile]) -> [Tile] { let nonZeroTiles = row.filter { $0.value != 0 } // Guard to check if we need to compress guard !nonZeroTiles.isEmpty, nonZeroTiles.count != 4, !(nonZeroTiles.count == 1 && nonZeroTiles[0].position.col == 0) else { // If the row is already in a compressed state, return it as is return row } // Create new row with non-zero tiles and update their positions let newRow: [Tile] = nonZeroTiles.enumerated().map { (index, tile) in var updatedTile = tile updatedTile.position = Position(row: tile.position.row, col: index) return updatedTile } // Add zeros to the end of the row with updated positions let zeros = (newRow.count..<row.count).map { colIndex in Tile(value: 0, position: Position(row: row[0].position.row, col: colIndex)) } return newRow + zeros } private func mergeRow(_ row: [Tile]) -> [Tile] { var newRow = row let nonZeroTiles = row.filter { $0.value != 0 } // If the row has less than 2 tiles return it as is guard nonZeroTiles.count > 1 else { return row } for i in 0..<row.count - 1 { if newRow[i].value != 0 && newRow[i].value == newRow[i + 1].value { // Merge tiles newRow[i].value *= 2 // New zero tile on i + ! position newRow[i + 1] = Tile(value: 0, position: Position(row: newRow[i].position.row, col: i + 1)) } } // Compress the row after merging return compressRow(newRow) } }
GameView c TileView
struct GameView: View { @StateObject private var viewModel = GameViewModel() var body: some View { VStack { Text("2048") .font(.largeTitle) .padding() GridView(tiles: viewModel.tiles) .padding() .gesture( DragGesture() .onEnded { value in let horizontalAmount = value.translation.width let verticalAmount = value.translation.height if abs(horizontalAmount) > abs(verticalAmount) { if horizontalAmount > 0 { viewModel.move(.right) } else { viewModel.move(.left) } } else { if verticalAmount > 0 { viewModel.move(.down) } else { viewModel.move(.up) } } } ) Button(action: { viewModel.resetGame() }) { Text("Restart") .font(.title) .padding() } } } } struct GridView: View { let tiles: [[Tile]] var body: some View { VStack(spacing: 8) { ForEach(0..<4) { row in HStack(spacing: 8) { ForEach(0..<4) { col in TileView(tile: tiles[row][col]) } } } } } } struct TileView: View { let tile: Tile var body: some View { Text(tile.value == 0 ? "" : "\(tile.value)") .frame(width: 80, height: 80) .background(Color.gray.opacity(0.4)) .cornerRadius(10) .font(.title) .foregroundColor(.black) } }Используем код в нашем проекте и в GameViewModel получаем ошибку:
Спрашиваем ChatGPT, как её исправить:
struct Position:Equatable { var row: Int var col: Int } struct Tile: Equatable { var value: Int var position: Position }
struct Tile: Equatable { var value: Int var position: Position // Manually implement Equatable conformance /* static func == (lhs: Tile, rhs: Tile) -> Bool { return lhs.value == rhs.value && lhs.position == rhs.position }*/ } struct Position: Equatable { var row: Int var col: Int }
Мы использовали соответствие структуры Position протоколу Equatable, которое выполняется Swift автоматически, и ручную реализацию c использованием только свойство value, что необходимо для логики игры 2048 :
struct Tile: Equatable { var value: Int var position: Position // Manually implement Equatable conformance static func == (lhs: Tile, rhs: Tile) -> Bool { return lhs.value == rhs.value } } struct Position: Equatable { var row: Int var col: Int }Все работает как и прежде, но с новой структурой Tile со свойством position:
Однако для анимации нам нужно работать с изображением плитки TileView на игровой доске, и первое, что нам нужно сделать, — это добавить позиционирование плитки TileView на игровой доске с помощью модификатора .position, используя свойство position самой модели Tile.
ШАГ 4. Модификатор .position для TileView
код TileView и GridView
import SwiftUI // Define the TileView struct TileView: View { let tile: Tile var body: some View { Text(tile.value == 0 ? "" : "\(tile.value)") .frame(width: 80, height: 80) .background( Color.gray.opacity(0.4)) .cornerRadius(10) .font(.title) .foregroundColor(.black) .position(getTilePosition()) } private func getTilePosition() -> CGPoint { let tileSize: CGFloat = 80 // Adjust based on tile size and padding let spacing: CGFloat = 8 // Space between tiles let x = CGFloat(tile.position.col) * (tileSize + spacing) + tileSize / 2 let y = CGFloat(tile.position.row) * (tileSize + spacing) + tileSize / 2 return CGPoint(x: x, y: y) } } // Define the GridView to use TileView struct GridView: View { let tiles: [[Tile]] var body: some View { ZStack { ForEach(tiles.flatMap { $0 }, id: \.position) { tile in TileView(tile: tile) } } .frame(width: 4 * 80 + 3 * 8, height: 4 * 80 + 3 * 8) // Adjust frame size } }
ШАГ 6. Протокол Identifiable для ForEach
Ранее у нас был такой код для GridView:
struct GridView: View { let tiles: [[Tile]] var body: some View { VStack(spacing: 8) { ForEach(0..<4) { row in HStack(spacing: 8) { ForEach(0..<4) { col in TileView(value:tiles [row][col]) } } } } } }Теперь мы получили новый код GridView:
// Define the GridView to use TileView struct GridView: View { let tiles: [[Tile]] var body: some View { ZStack { ForEach(tiles.flatMap { $0 }, id: \.position) { tile in TileView(tile: tile) } } .frame(width: 4 * 80 + 3 * 8, height: 4 * 80 + 3 * 8) // Adjust frame size } }Заметьте, как только мы добавили модификатор .position для TileView, необходимость в сетке, состоящей из вложенных ForEach, пропала. ChatGPT четко это уловил и ”вытянул“ 2D массив в 1D массив с помощью функции высшего порядка flatMap и для единственного ForEach использовал этот массив, полагая, что свойство positionплитки Tile не только определяет местоположение плитки TileView на игровой доске, но однозначно идентифицирует саму плитку Tile.
Но это не так, так как позиция position плитки Tile с течением игры меняется, хотя плитка остается той же самой, так что position вовсе не является нужным нам идентификатором уникальности плитки Tile.
// Define the GridView to use TileView struct GridView: View { let tiles: [[Tile]] var body: some View { ZStack { ForEach(tiles.flatMap { $0 }) { tile in TileView(tile: tile) } } .frame(width: 4 * 80 + 3 * 8, height: 4 * 80 + 3 * 8) // Adjust frame size } }Нам нужна какая-то другая вещь, которая идентифицирует плитку навсегда и однозначно. Неважно, что произойдет с этой плиткой, неважно как сильно она поменяется, мы знаем, что это та же самая плитка, нашForEach всегда будет точно знать, с какой плиткой он имеет дело. Это важно для анимации.
Но как только мы уберем id: \.position, мы получаем ошибку:
Давайте спросим ChatGPT, что нам делать с этой ошибкой:
struct Tile: Equatable, Identifiable { // Manually static func == (lhs: Tile, rhs: Tile) -> Bool { return lhs.value == rhs.value } var value: Int var position: Position var id = UUID() // This provides a unique identifier for each tile } struct Position: Equatable { var row: Int var col: Int }
// Define the GridView to use TileView struct GridView: View { let tiles: [[Tile]] var body: some View { ZStack { ForEach(tiles.flatMap { $0 }) { tile in TileView(tile: tile) } } .frame(width: 4 * 80 + 3 * 8, height: 4 * 80 + 3 * 8) // Adjust frame size } }
Шаг 5. Анимация
TileView с неявной анимацией и модификатором перехода .transition
import SwiftUI struct TileView: View { let tile: Tile let tileSize: CGFloat let padding: CGFloat var body: some View { RoundedRectangle(cornerRadius: padding) .fill(Color.colorForTile(tile.value)) .frame(width: tileSize, height: tileSize) .overlay( Text(tile.value > 0 ? "\(tile.value)" : "") .font(.largeTitle) .foregroundColor(.black) ) .position (getTilePosition()) .animation(.easeInOut(duration: 0.2), value: tile.position) .transition(.scale) } private func getTilePosition() -> CGPoint { let x = CGFloat(tile.position.col) * (tileSize + padding) + tileSize / 2 let y = CGFloat(tile.position.row) * (tileSize + padding) + tileSize / 2 return CGPoint(x: x, y: y) } } extension Color { static func colorForTile(_ value: Int) -> Color { switch value { case 0: return Color(UIColor.systemGray5) case 2: return Color(UIColor.systemGray4) case 4: return Color.orange case 8: return Color.red case 16: return Color.purple case 32: return Color.blue case 64: return Color.green case 128: return Color.yellow case 256: return Color.pink case 512: return Color.brown case 1024: return Color.cyan case 2048: return Color.indigo default: return Color.mint } } }
GameView c явной анимацией withAnimation
struct GameView: View { @StateObject private var viewModel = GameViewModel() let tileSize: CGFloat = 80 let padding: CGFloat = 8 var body: some View { VStack { Text("2048") .font(.largeTitle) .padding() GridView(tiles: viewModel.tiles, tileSize: tileSize, padding: padding) .gesture( DragGesture() .onEnded { value in withAnimation(.easeInOut) { handleSwipe(value: value) } } ) Button(action: { withAnimation(.easeInOut) { viewModel.resetGame() } }) { Text("Restart") .font(.title2) .padding() } } } // Handle swipe gesture and trigger game actions private func handleSwipe(value: DragGesture.Value) { let threshold: CGFloat = 20 let horizontalShift = value.translation.width let verticalShift = value.translation.height if abs(horizontalShift) > abs(verticalShift) { if horizontalShift > threshold { viewModel.move(.right) } else if horizontalShift < -threshold { viewModel.move(.left) } } else { if verticalShift > threshold { viewModel.move(.down) } else if verticalShift < -threshold { viewModel.move(.up) } } } }
Скрытый текст
// Define the GridView to use TileView struct GridView: View { let tiles: [[Tile]] let tileSize : CGFloat let padding : CGFloat var body: some View { ZStack { // Background grid VStack(spacing: padding) { ForEach(0..<4) { row in HStack(spacing: padding) { ForEach(0..<4) { col in RoundedRectangle(cornerRadius:padding) .fill(Color.colorForTile(0)) .frame(width: tileSize, height: tileSize) } } } } // Foreground tiles (only non-zero values) ForEach(tiles.flatMap { $0 }.filter { $0.value != 0 }){ tile in TileView(tile: tile, tileSize: tileSize, padding: padding) } } .frame(width: 4 * tileSize + 3 * padding, height: 4 * tileSize + 3 * padding) // Adjust frame size } }
Вот как работает этот код:
A вот в режиме “Медленной Анимации” (Slow Animation) :
Мы видим, что появление новых плиток анимируется из середины (.center), и это выглядит не совсем хорошо, нам бы хотелось, чтобы появление новых плиток анимировалось “по месту” плиток в игровом поле.
Усовершенствованный переход .transition (.scale)
Давайте спросим, как добиться этого у ChatGPT:
код TileView c .transition (.scale) и .transition(.offset):
struct TileView: View { let tile: Tile let tileSize: CGFloat let padding: CGFloat var body: some View { let tilePosition = getTilePosition() RoundedRectangle(cornerRadius:padding) .fill(Color.colorForTile(tile.value)) .frame(width: tileSize, height: tileSize) .overlay( Text(tile.value > 0 ? "\(tile.value)" : "") .font(.largeTitle) .foregroundColor(.black) ) .position(tilePosition) .animation(.easeInOut(duration: 0.2), value: tile.position) .transition(.scale(scale: 0.12).combined (with: .offset( x: tilePosition.x - 2.0 * tileSize, y: tilePosition.y - 2.0 * tileSize))) } private func getTilePosition() -> CGPoint { let x = CGFloat(tile.position.col) * (tileSize + padding) + tileSize / 2 let y = CGFloat(tile.position.row) * (tileSize + padding) + tileSize / 2 return CGPoint(x: x, y: y) } }
Вот как работает этот код:
A вот в режиме “Медленной Анимации” (Slow Animation) :
Следующие шаги я не буду рассматривать здесь, с ними можно подробно познакомиться в посте :
ШАГ 6. Цвета специфические для игры 2048
Шаг 7. Счет score для игры 2048
ШАГ 8. Окончание игры 2048.
ШАГ 9. Оптимальное направление жеста для игры 2048.
Результат работы приложения после применения вышеуказанных шагов:
Теперь, когда на любом этапе игры 2048 мы можем определить оптимальное направление перемещения плиток с помощью bestMoveDirection(), мы можем заменить ручной swipe жест на автоматический запуск перемещение плиток в оптимальном направлении. и тем самым реализовать своего рода «жадный» (greedy) ИИ (AI) алгоритм в игре 2048.
Искусственный интеллект (AI) в игре 2048
ШАГ 10. Добавление AI в игру 2048
Добавление ИИ в игру 2048 подразумевает реализацию логики, которая может автоматически выбирать лучший ход на каждом шаге. ИИ будет, например, использовать функцию bestMoveDirection(), которую мы ранее обсуждали, чтобы определить, какой ход выполнить, основываясь, на максимальном увеличении счета. В этом случае ИИ может автоматически играть в игру 2048, делая оптимальные ходы.
Таким образом, нам понадобится метод выполнения хода ИИ, возможность запуска его автоматически с определенной периодичностью, и, переключатель для переключения между ручным режимом со swipe жестом и воспроизведением ИИ.
Но давайте сначала поймем, какие в SwiftUI есть средства запуска определенный код автоматически через равные промежутки времени:
View, обновляющее счетчик каждую секунду
import SwiftUI struct PeriodicTaskView: View { @State private var counter = 0 // Create a timer publisher that fires every second let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect() var body: some View { VStack { Text("Counter: \(counter)") .font(.largeTitle) .padding() // Example of something happening periodically Text("This text will update every second.") } .onReceive(timer) { _ in // Increment the counter every time the timer fires counter += 1 // Place any other periodic code here print("Timer fired. Counter is now \(counter).") } } } #Preview { PeriodicTaskView() }
struct GameView: View { @ObservedObject var viewModel: GameViewModel @State private var isAIEnabled = false // Create a timer publisher that fires every second let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect() var body: some View { VStack { Toggle("Enable AI", isOn: $isAIEnabled) .padding() // Your game UI components go here... } .onReceive(timer) { _ in if isAIEnabled { let direction = viewModel.bestMoveDirection() viewModel.move(direction) } } } }
Использование модификатора .onReceive (timer) и Timer.publish в GameView
код GameView c Timer.publish и .omReceive
import SwiftUI struct GameView: View { @ObservedObject var viewModel = GameViewModel () let tileSize: CGFloat = 80 let padding: CGFloat = 8 @State var isAIPlaying = false @State private var isShowingOptimalDirection = false // Timer that triggers every 0.5 seconds private let timer = Timer.publish(every: 0.5, on: .main, in:.common).autoconnect() var body: some View { VStack { // Your game UI components here (e.g., grid view, score display)... HStack { Button(action: { isAIPlaying.toggle() }) { HStack { Image(systemName: isAIPlaying ? "checkmark.square" : "square") .resizable() .frame(width: 24, height: 24) Text( isAIPlaying ? "AI Stop" : "AI Play") } } .padding() .background(.accentColor) } if viewModel.isGameOver { Text(viewModel.isGameOver ? "Game Over": " ___ ") .font(.title) .foregroundColor(viewModel.isGameOver ? .red : .clear) } } .padding() // This triggers AI moves at intervals when AI is playing .onReceive(timer) { _ in if isAIPlaying { viewModel.executeAIMove() } } } }
Скрытый текст
class GameViewModel: ObservableObject { @Published var tiles: [[Tile]] = [] @Published var score: Int = 0 private var aiGame = AIGame() init() { resetGame() } func resetGame() { . . .} // Reset the game board, score, and other states func executeAIMove() { var bestDirection : Direction guard !isGameOver else { return } bestDirection = bestMoveDirection() move(bestDirection) } func bestMoveDirection() -> Direction { var bestDirection: Direction = .right var maxScore = 0 for direction in Direction.allCases { let result = aiGame.oneStepGame(direction: direction, matrix: tiles) if result.moved && result.score >= maxScore { maxScore = result.score bestDirection = direction } } return bestDirection } func move(_ direction: Direction) { // Logic to slide and merge tiles, add newTile if moved and gain the score let (moved, score) = slide(direction) if moved { self.score += score addNewTile() } checkGameOver() } private func checkGameOver() { if !canMove() { isGameOver = true } } private func canMove() -> Bool { return Direction.allCases.contains { direction in aiGame.oneStepGame(direction: direction, matrix: tiles).moved } } private func addNewTile() { // Logic to add a new tile at a random empty position } func slide(_ direction: Direction) -> (moved: Bool, score: Int) { // Logic to slide and merge tiles, returning whether any tiles moved and the score gained var moved = false var totalScore = 0 // Rotate board, compress, merge, and update rows... return (moved, totalScore) } }
A вот наш UI:
ШАГ 11. Лучшая ИИ (AI) стратегия
ШАГ 12. Алгоритм Expectimax
enum Direction: CaseIterable { case up, down, left, right }
struct Tile : Equatable, Identifiable { var value: Int var position: Position var id = UUID() // This provides a unique identifier for each tile // Manually implement Equatable conformance static func == (lhs: Tile, rhs: Tile) -> Bool { return lhs.value == rhs.value } } struct Position: Equatable { var row: Int var col: Int }
код алгоритмв expectimax:
func expectimax(board: [[Tile]], depth: Int, isAITurn: Bool) -> Double { // Base case: return the board evaluation if depth is 0 or game is over if depth == 0 || isGameOver(board) { return evaluateBoard (board) } // AI's move (maximize the score) if isAITurn { var maxScore = -Double.infinity for direction in Direction.allCases { let newBoard = GameViewModel (matrix: board) let (moved, _) = newBoard.slide(direction) if moved { // Recur for the next move, but now it's the tile placement's turn maxScore = max(maxScore, expectimax(board: newBoard.tiles, depth: depth - 1, isAITurn: false)) } } return maxScore } // Random tile placement's move (chance node) else { var expectedScore = 0.0 let emptyTiles = board.flatMap{$0}.filter{$0.value == 0} // If no empty tiles, the game is over if emptyTiles.isEmpty { return evaluateBoard (board) } // For each empty tile, calculate the expected value for tile in emptyTiles { var boardWith2 = board boardWith2[tile.position.row][tile.position.col].value = 2 var boardWith4 = board boardWith4[tile.position.row][tile.position.col].value = 4 // 90% probability of placing a '2' tile, 10% of placing a '4' tile expectedScore += 0.9 * expectimax(board: boardWith2, depth: depth - 1, isAITurn: true) expectedScore += 0.1 * expectimax(board: boardWith4, depth: depth - 1, isAITurn: true) } return expectedScore / Double(emptyTiles.count) } } func evaluateBoard(_ board: [[Tile]]) -> Double { let monotonicityWeight = 1.0 let smoothnessWeight = 0.1 let emptyTilesWeight = 2.7 let maxTileWeight = 1.0 let emptyTilesCount = Double(board.flatMap{$0}.filter{$0.value == 0}.count) return monotonicity(board) * monotonicityWeight + smoothness(board) * smoothnessWeight + emptyTilesCount * emptyTilesWeight + maxTileInCorne() * maxTileWeight } func monotonicity (_ board: [[Tile]]) -> Double { // calculate return 0.0 } func smoothness (_ board: [[Tile]]) -> Double { // calculate return 0.0 } func maxTileInCorner(_ board: [[Tile]]) -> Double // calculate return 0.0 }
код функции expectimaxBestMove (
// MARK: - Expectimax func expectimaxBestMove (depth: Int, matr [[Tile]]) -> Direction { var bestDirection = Direction.right var bestScore: Double = -Double.infinity // for move in possibleMoves { for direction in Direction.allCases { var model = GameViewModel (matrix: matrix) // Initialize Game let (moved, _ ) = model.slide(direction) if moved { let newScore = expectimaxScore (board: model.tiles, depth: depth, isAITurn: false) if newScore > bestScore { bestScore = newScore bestDirection = direction } } } return bestDirection }
код GameViewModel
class GameViewModel: ObservableObject { @Published var tiles: [[Tile]] = [] @Published var isGameOver = false @Published var score: Int = 0 private var aiGame = AIGame() init() { resetGame() } func resetGame() { . . .} // Reset the game board, score, and other states // ------ AI --------- func executeAIMove() { guard !isGameOver else { return } move(bestAIMoveDirection()) } func bestAIMoveDirection() -> Direction { aiGame.expectimaxBestMove(depth: 4, matrix: tiles) } // Other functions: move, slide, compress, merge, and update rows... }
GameView
import SwiftUI struct GameView: View { @ObservedObject var viewModel = GameViewModel () let tileSize: CGFloat = 80 let padding: CGFloat = 8 @State var isAIPlaying = false @State private var isShowingOptimalDirection = false // Timer that triggers every 0.5 seconds private let timer = Timer.publish(every: 0.5, on: .main, in:.common).autoconnect() var body: some View { VStack { // Your game UI components here (score display)... HStack { Button(action: { isAIPlaying.toggle() }) { HStack { Image(systemName: isAIPlaying ? "checkmark.square" : "square") .resizable() .frame(width: 24, height: 24) Text(isAIPlaying ? "AI Stop" : "AI Play") } } .padding() } if viewModel.isGameOver { Text(viewModel.isGameOver ? "Game Over": " ___ ") .font(.title) .foregroundColor(viewModel.isGameOver ? .red : .clear) } // Your game UI components here (e.g., grid view, reset display)... } .padding() // This triggers AI moves at intervals when AI is playing .onReceive(timer) { _ in if isAIPlaying { viewModel.executeAIMove() } } } }Вот как работает expectimax поиск оптимального хода:
ШАГ 13. Улучшение функции evaluate()
функция monotonicity (grid: )
func monotonicity (_ grid: [[Int]]) -> Double { func calculateMonotonicity(values: [Int]) -> (Double, Double) { var increasing = 0.0 var decreasing = 0.0 var current = 0 // Skip over any initial zeros in the row/column while current < values.count && values[current] == 0 { current += 1 } var next = current + 1 while next < values.count { // Skip over any zeros in the middle while next < values.count && values[next] == 0 { next += 1 } if next < values.count { let currentValue = values[current] != 0 ? log2(Double(values[current])) : 0 let nextValue = values[next] != 0 ? log2(Double(values[next])) : 0 if currentValue > nextValue { decreasing += nextValue - currentValue } else if currentValue < nextValue { increasing += currentValue - nextValue } // Move to the next non-zero tile current = next next += 1 } } return (increasing, decreasing) } var rowMonotonicity = (increasing: 0.0, decreasing: 0.0) var colMonotonicity = (increasing: 0.0, decreasing: 0.0) // Check row monotonicity (left-right) for row in grid { let (increasing, decreasing) = calculateMonotonicity(values: row) rowMonotonicity.increasing += increasing rowMonotonicity.decreasing += decreasing } // Check column monotonicity (up-down) for col in 0..<grid[0].count { let columnValues = grid.map { $0[col] } let (increasing, decreasing) = calculateMonotonicity(values: columnValues) colMonotonicity.increasing += increasing colMonotonicity.decreasing += decreasing } return max(rowMonotonicity.increasing, rowMonotonicity.decreasing) + max(colMonotonicity.increasing, colMonotonicity.decreasing) }
функция smoothness (grid: )
func smoothness(_ grid: [[Int]]) -> Double { var smoothness: Double = 0 for row in 0..<4 { for col in 0..<4 { if grid[row][col] != 0 { let value = Double(grid[row][col]) if col < 3 && grid[row][col+1] != 0 { smoothness -= abs(value - Double(grid[row][col+1])) } if row < 3 && grid[row+1][col] != 0 { smoothness -= abs(value - Double(grid[row+1][col])) } } } } return smoothness }
функция func emptyTileCount(board: )
func emptyTileCount(_ board: [[Tile]]) -> Double { return Double(board.flatMap { $0 }.filter { $0.value == 0 }.count) }
функция maxTileInCorner(board: ) -> Double
func maxTileInCorner(_ board: [[Tile]]) -> Double { let maxTile = board.flatMap { $0 }.max(by: { $0.value < $1.value })?.value ?? 0 let cornerTiles = [ board[0][0], board[0][3], board[3][0], board[3][3] ] return cornerTiles.contains(where: { $0.value == maxTile }) ? 1.0 : 0.0 }Объединение эвристик в функцию оценки игровой доски evaluate()
функция evaluate(board:)
func evaluateBoard(_ board: [[Tile]]) -> Double { let emptyWeight = 2.7 let smoothnessWeight = 0.1 let monotonicityWeight = 1.0 let maxTileCornerWeight = 1.0 let emptyTilesScore = Double(emptyTileCount(board)) * emptyWeight let smoothnessScore = smoothness(board) * smoothnessWeight let monotonicityScore = monotonicity(board) * monotonicityWeight let maxTileInCornerScore = maxTileInCorner(board) * maxTileCornerWeight return emptyTilesScore + smoothnessScore + monotonicityScore + maxTileInCornerScore }
ШАГ 14. Эвристика в виде Snake (Змея) паттерна
Два способа организации игровой доски в виде Snake паттерна показаны на рисунке:
[15, 14, 13, 12] [8, 9, 10, 11] [7, 6, 5, 4] [0, 1, 2, 3]
функция snakeHeuristic(board:)
func snakeHeuristic(_ board: [[Tile]]) -> Double { // Snake pattern score weights for each tile position let snakePattern: [[Double]] = [ [15, 14, 13, 12], [8, 9, 10, 11], [7, 6, 5, 4], [0, 1, 2, 3] ] var score = 0.0 // Evaluate how well the board follows the snake pattern for row in 0..<4 { for col in 0..<4 { let tileValue = board[row][col].value if tileValue > 0 { score += Double(log2(Double(tileValue))) * snakePattern[row][col] } } } return score }
функция evaluateBoard ( board: )
func evaluateBoard (_ board: [[Tile]]) -> Double { let grid = board.map {$0.map{$0.value}} let emptyCells = board.flatMap { $0 }.filter { $0.value == 0 }.count let smoothWeight: Double = 0.1 let monoWeight: Double = 1.0 let emptyWeight: Double = 5.7 let maxWeight: Double = 1.0 let maxTileCornerWeight = 1.0 return monoWeight * monotonicity(grid) + smoothWeight * smoothness(grid) + emptyWeight * Double(emptyCells) + maxWeight * Double(grid.flatMap { $0 }.max() ?? 0) + maxTileCornerWeight * maxTileInCorner(board) + snakeHeuristic(grid) }
[2^15, 2^14, 2^13, 2^12] [2^8, 2^9, 2^10, 2^11] [2^7, 2^6, 2^5, 2^4] [2^0, 2^1, 2^2, 2^3]функция snakeHeuristic(_ board: )
func snakeHeuristic(_ board: [[Tile]]) -> Double { // Snake pattern score weights for each tile position based on powers of 2 let snakePattern: [[Double]] = [ [pow(2, 15), pow(2, 14), pow(2, 13), pow(2, 12)], [pow(2, 8), pow(2, 9), pow(2, 10), pow(2, 11)], [pow(2, 7), pow(2, 6), pow(2, 5), pow(2, 4)], [pow(2, 0), pow(2, 1), pow(2, 2), pow(2, 3)] ] var score = 0.0 // Evaluate how well the board follows the snake pattern for row in 0..<4 { for col in 0..<4 { let tileValue = board[row][col].value score += Double(tileValue) * snakePattern[row][col] } } return score 
ШАГ 15. Метод Monte Carlo как ИИ для игры 2048
функция monteCarloSearch (board: simulations: depth: )
func monteCarloSearch(board: [[Tile]], simulations: Int, depth: Int) -> Direction { var bestDirection: Direction = .up var bestScore: Double = -Double.infinity // Iterate over all possible moves for direction in Direction.allCases { var totalScore: Double = 0 // Simulate a number of games for each move for _ in 0..<simulations { var gameBoard = GameViewModel(matrix: board) let (moved, _) = gameBoard.slide(direction) if moved { // Play a random game starting from this move let score = randomGame(board: gameBoard.tiles, depth: depth) totalScore += score } } // Calculate the average score for this move let averageScore = totalScore / Double(simulations) // Select the move with the highest average score if averageScore > bestScore { bestScore = averageScore bestDirection = direction } } return bestDirection }
функция randomGame(board: depth:)
func randomGame(board:[[Tile]], depth: Int) -> Double{ var moves = 0 var gameBoard = GameViewModel(matrix:board) // Play until no more moves or reach max depth while !isGameOver(gameBoard.tiles) && moves < depth { let randomMove = Direction.allCases.randomElement()! gameBoard.move (randomMove) moves += 1 } // Evaluate the board at the end of the game return evaluateBoard(gameBoard.tiles) }
функция evaluateBoard( board: )
func evaluateBoard(_ board: [[Tile]]) -> Double { // Use a heuristic to evaluate the current state of the board // For example: Sum of tiles, number of empty spaces, smoothness, monotonicity, etc. }
ШАГ 16. Усовершенствование Monte Carlo как ИИ для игры 2048
код biasedRandomGame(direction: board:depth: Int)
func biasedRandomGame(direction: Direction,board:[[Tile]], depth: Int) -> Double{ var moves = 0 var gameBoard = GameViewModel(matrix:board) // Play until no more moves or reach max depth while !isGameOver(gameBoard.tiles) && moves < depth { let biasedMoves = biasedMoveSelection(board: gameBoard.tiles) let randomMove = biasedMoves.randomElement()! gameBoard.move (randomMove) moves += 1 } // Evaluate the board at the end of the game return evaluateBoard(gameBoard.tiles) } func biasedMoveSelection(board: [[Tile]]) -> [Direction] { var possibleMoves: [Direction] = [] for direction in Direction.allCases { var gameBoard = GameViewModel(matrix:board) let (moved, _) = gameBoard.slide(direction) if moved { // Prioritize moves that make the board smoother or merge tiles if mergesTiles(gameBoard.tiles) || isBoardSmoother(gameBoard.tiles) { possibleMoves.append(direction) } else { possibleMoves.append(direction) } } } return possibleMoves.isEmpty ? Direction.allCases : possibleMoves }
код randomGameWithEarlyStopping(board: depth: maxBadMoves:)
func randomGameWithEarlyStopping(board: [[Tile]], depth: Int, maxBadMoves: Int = 3) -> Double { var moves = 0 var badMoves = 0 var gameBoard = GameViewModel(matrix:board) // Play until no more moves or reach max depth while !isGameOver(gameBoard.tiles) && moves < depth { let randomMove = Direction.allCases.randomElement()! let (moved, _) = gameBoard.slide( randomMove) if moved { gameBoard.addNewTile() } else { badMoves += 1 if badMoves >= maxBadMoves { break } } moves += 1 } return evaluateBoard(gameBoard.tiles)
код monteCarloSearchWithDynamicSimulations(board: maxSimulations: depth:
func monteCarloSearchWithDynamicSimulations(board: [[Tile]], maxSimulations: Int, depth: Int) -> Direction { var bestDirection: Direction = .up var bestScore: Double = -Double.infinity // Adjust simulations based on the number of empty tiles let emptyTilesCount = board.flatMap{$0}.filter{$0.value == 0}.count let simulations = max(1, maxSimulations - emptyTilesCount * 2) for direction in Direction.allCases { var totalScore: Double = 0 for _ in 0..<simulations { let gameBoard = GameViewModel(matrix: board) let (moved, _ ) = gameBoard.slide( direction) if moved { let score = randomGame(board:gameBoard.tiles, depth: depth) totalScore += score } } let averageScore = totalScore / Double(simulations) if averageScore > bestScore { bestScore = averageScore bestDirection = direction } } return bestDirection }
код runSimulationsParallel(board: direction: simulations: depth: )
func runSimulationsParallel(board: [[Tile]], direction: Direction, simulations: Int, depth: Int) -> Double { let queue = DispatchQueue.global(qos: .userInitiated) let group = DispatchGroup() var totalScore = 0.0 for _ in 0..<simulations { queue.async(group: group) { var gameBoard = GameViewModel(matrix: board) let (moved, _) = gameBoard.slide(direction) if moved { let score = randomGame(board: gameBoard.tiles, depth: depth) DispatchQueue.main.sync { totalScore += score } } } } group.wait() return totalScore / Double(simulations) }
код evaluateBoard(board: )
func evaluateBoard(_ board: [[Tile]]) -> Double { let smoothness = calculateSmoothness(board) let monotonicity = calculateMonotonicity(board) let emptySpaces = Double(getEmptyTiles(board).count) return smoothness + monotonicity + emptySpaces * 2 }
Давайте выберем параллельное симулирование и просим ChatGPT реализовать предложенную ранее функцию runSimulationsParallel(board: direction: simulations: depth: ) с помощью более современных async await:
ШАГ 17. Сделай рефакторинг runSimulationsParallel с async await
func runSimulationsParallel(board: [[Tile]], direction: Direction, simulations: Int, depth: Int) async -> Double { var totalScore = 0.0 // Create an array of tasks for parallel execution await withTaskGroup(of: Double.self) { taskGroup in for _ in 0..<simulations { taskGroup.addTask { let gameBoard = Game(matrix: matrix) let (moved, _) = gameBoard.slide(direction) if moved { let score = randomGame(board:gameBoard.tiles, depth: depth) return score } else { return 0.0 // If no move is made, return a score of 0 } } } // Collect all the results from the tasks for await score in taskGroup { totalScore += score } } return totalScore / Double(simulations) }
ШАГ 18. Параллелизм expectimax с async await
код expectimaxAsyn (grid: depth: isAITurn)
// Asynchronous expectimax algorithm with improved parallelism func expectimaxAsyn(grid: [[Tile]], depth: Int, isAITurn: Bool) async -> Double { // Base case: return the board evaluation if depth is 0 or game is over if depth == 0 || isGameOver (grid.map {$0.map{$0.value}}){ // return evaluateBoard(grid.map {$0.map{$0.value}}) return evaluateBoard(grid) } if isAITurn { //------ // Player's turn (maximize the score) var maxScore = -Double.infinity // Use task group for parallel evaluation of all directions return await withTaskGroup(of: Double.self) { group in for direction in Direction.allCases { group.addTask { var game = Game (matrix: grid) // Initialize Game let (moved, _) = game.slide( direction) if moved { return await expectimaxAsyn (grid: game.tiles, depth: depth - 1, isAITurn: false) } return -Double.infinity } } for await result in group { maxScore = max(maxScore, result) } return maxScore } //------ } else { // AI's turn (chance node) // var expectedScore = 0.0 let emptyTiles = grid.flatMap { $0 }.filter { $0.value == 0 } // If no empty tiles, the game is over if emptyTiles.isEmpty { // return evaluateBoard(grid.map {$0.map{$0.value}}) return evaluateBoard(grid) } // Limit parallelism at deeper levels to avoid overwhelming system if depth > 4 {//3 { var expectedValue = 0.0 for tile in emptyTiles { var boardWith2 = grid boardWith2[tile.position.row][tile.position.col].value = 2 let valueFor2 = await expectimaxAsyn(grid: boardWith2, depth: depth - 1, isAITurn: true) var boardWith4 = grid boardWith4[tile.position.row][tile.position.col].value = 4 let valueFor4 = await expectimaxAsyn(grid: boardWith4, depth: depth - 1, isAITurn: true) expectedValue += 0.9 * valueFor2 + 0.1 * valueFor4 } return expectedValue / Double(emptyTiles.count) } else { // Use task group for parallel execution in shallower levels return await withTaskGroup(of: Double.self) { group in var expectedValue = 0.0 for tile in emptyTiles { group.addTask { var boardWith2 = grid boardWith2[tile.position.row][tile.position.col].value = 2 return await expectimaxAsyn(grid: boardWith2, depth: depth - 1, isAITurn: true) * 0.9 } group.addTask { var boardWith4 = grid boardWith4[tile.position.row][tile.position.col].value = 4 return await expectimaxAsyn(grid: boardWith4, depth: depth - 1, isAITurn: true) * 0.1 } } for await result in group { expectedValue += result } return expectedValue / Double(emptyTiles.count) } } } }
// MARK: - ExpectimaxAsync AI func bestExpectimaxAsync (depth: Int, matrix: [[Tile]]) async -> Direction { var bestDirection = Direction.right var bestScore: Double = -Double.infinity // for move in possibleMoves { for direction in Direction.allCases { var model = Game (matrix: matrix) // Initialize Game // let (moved, _ ) = model.slide(move) let (moved, _ ) = model.slide(direction) if moved { let newScore = await expectimaxAsyn (grid: model.tiles, depth: depth , isAITurn: false) if newScore > bestScore { bestScore = newScore // bestMove = move bestDirection = direction } } } return bestDirection }
func bestMoveDirectionExpectimaxAsync() async -> Direction { let direction = await aiGame.bestExpectimaxAsync(depth: 5, matrix: tiles) return direction }
func expectimaxAsyncAIMove() { Task{ let bestDirection = await game.bestMoveDirectionExpectimaxAsync() game.move(bestDirection) } }
.onReceive(timer){ value in if isAIPlaying && !viewModel.isGameOver { if selectedAlgorithm == Algorithm.MonteCarloAsync { viewModel.monteCarloAsyncAIMove() } else if selectedAlgorithm == Algorithm.Expectimax1 { viewModel.expectimaxAsyncAIMove() } else { viewModel.executeAIMove() } } }
Заключение:
Благодаря ChatGPT разработка iOS приложений стала более осмысленной. Не нужно отвлекаться на очевидные вещи типа создание кнопки или меню на UI — а сфокусироваться на высокоуровневых концепциях. То есть на самом интересном и важном. Это рождает желание попробовать что-то более рискованное и, возможно, более эффективное, не прикладывая при этом никаких дополнительных усилий. Иными словами просыпается чувство азарта и от программирования с ChatGPT получаешь истинное удовольствие.
Что же понравилось больше всего?
-
ChatGPT сразу предлагает полную архитектуру вашего приложения с “заглушками” для конкретных методов и вычисляемых переменных, но которую вы можете дальше успешно развивать, ссылаясь на эти заглушки без дополнительных разъяснений.
-
ChatGPT предлагает очень содержательные идентификаторы для переменных
var, константletи названий функцийfunc, что существенно облегчает чтение кода и избавляет вас от того, чтобы “ломать голову” над этим. И вы также можете ссылаться на них в последующем диалоге с ChatGPT. -
ChatGPT 4-o в совершенстве владеет функциями высшего порядка для работы с коллекциями (
map,flatMap,compactMap,filter,allSatisfy) в Swift и всюду предлагает их, иногда в самых неожиданных ситуациях и самым изобретательным образом, что приятно удивляет. -
Прекрасно владеет архитектурой MVVM (возможно, и другими, просто не пробовала), предлагая как незащищенную модель, когда
ViewModelиModelв одном классе (с протоколомObservableObjectили новым макросом@Observable), так и классическую защищенную модель:Modelотдельно отViewModelиView. Легко переходит от одной к другой. -
Расшифровывает все ошибки и даёт дельные советы по их исправлению.
-
В большинстве случаев запоминает и хранит наработанный в процессе взаимодействия код для поставленной задачи на протяжении почти всей сессии и позволяет ссылаться на различные его этапы.
-
Хорошо рефакторит код.
-
Генерирует Unit тесты с использованием XCTest.
-
Проявляет фантастическую эрудицию в части ИИ алгоритмов для игр типа 2048.
И много чего еще ….
Все свои предложения кода ChatGPT сопровождает такими подробными объяснениями, которые не даст вам ни один курс обучения. Так что параллельно идет очень интенсивное обучение языку программирования Swift и фреймворку SwiftUI (мне это вроде как не требовалось, но все равно всякий раз открывала что-то новое!!!). Если вы изучаете программирование на Swift и SwiftUI, попробуйте самостоятельно пройти мой путь. Вы получите колоссальный опыт разработки iOS приложений.
Недостатки:
-
Хотя держит контекст решаемой задачи в процессе одной сессии, код полного приложения приходится собирать по кусочкам, это вам не Claude 3.5 Sonnet. Однако к настоящему моменту появился новый способ взаимодействия — ChatGPT 4 Canvas, который полностью держит разрабатываемый проект, но я его еще не пробовала.
-
Иногда «увиливает» от прямо поставленного вопроса.
-
Часто даёт код предыдущей версии: протокол
ObservableObjectвместо макроса @Observable,GCD(Grand Central Dispatch) вместоasyncawait, но стоит на это указать и ChatGPT великолепно выполняет рефакторинг кода и объясняет различие между новым синтаксисом и старым.
При работе над iOS приложением игры 2048 с помощью chatGPT мне ни разу не пришлось обращаться к Google или StackOverFlow, так что ChatGPT вполне может заменить эти два инструмента при разработке iOS приложений.
ссылка на оригинал статьи https://habr.com/ru/articles/851904/
Добавить комментарий