Вот готовый код для простейшей игры «Змейка» на SwiftUI. Змея стартует с длиной в 3 квадрата и растёт при поедании еды разного цвета. Управление происходит свайпами.

import SwiftUI

struct SnakeGameView: View {
    @State private var snake: [CGPoint] = [CGPoint(x: 100, y: 100), CGPoint(x: 80, y: 100), CGPoint(x: 60, y: 100)]
    @State private var food: CGPoint = CGPoint(x: 200, y: 200)
    @State private var direction: CGPoint = CGPoint(x: 20, y: 0)
    @State private var timer = Timer.publish(every: 0.2, on: .main, in: .common).autoconnect()
    
    let gridSize: CGFloat = 20
    let colors: [Color] = [.red, .blue, .yellow, .purple, .orange]
    
    var body: some View {
        ZStack {
            Color.black.ignoresSafeArea()
            
            ForEach(snake.indices, id: \..self) { index in
                Rectangle()
                    .fill(Color.green)
                    .frame(width: gridSize, height: gridSize)
                    .position(snake[index])
            }
            
            Rectangle()
                .fill(colors.randomElement()!)
                .frame(width: gridSize, height: gridSize)
                .position(food)
        }
        .gesture(DragGesture()
            .onEnded { gesture in
                let xMove = gesture.translation.width
                let yMove = gesture.translation.height
                
                if abs(xMove) > abs(yMove) {
                    direction = xMove > 0 ? CGPoint(x: gridSize, y: 0) : CGPoint(x: -gridSize, y: 0)
                } else {
                    direction = yMove > 0 ? CGPoint(x: 0, y: gridSize) : CGPoint(x: 0, y: -gridSize)
                }
            }
        )
        .onReceive(timer) { _ in
            moveSnake()
        }
    }
    
    private func moveSnake() {
        var newHead = snake.first!
        newHead.x += direction.x
        newHead.y += direction.y
        
        if newHead == food {
            snake.insert(newHead, at: 0)
            food = generateNewFood()
        } else {
            snake.insert(newHead, at: 0)
            snake.removeLast()
        }
    }
    
    private func generateNewFood() -> CGPoint {
        let x = CGFloat(Int.random(in: 0..<Int(UIScreen.main.bounds.width / gridSize))) * gridSize
        let y = CGFloat(Int.random(in: 0..<Int(UIScreen.main.bounds.height / gridSize))) * gridSize
        return CGPoint(x: x, y: y)
    }
}

struct ContentView: View {
    var body: some View {
        SnakeGameView()
    }
}

@main
struct SnakeGameApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

Этот код создаёт простейшую змейку, которая управляется свайпами. Когда змея съедает еду, она увеличивается в длине, а еда появляется в новом случайном месте и меняет цвет. Игра бесконечна, но можно добавить столкновение с границами или самой собой для усложнения. ?

Создадим простейшую версию игры "Змейка" на SwiftUI. В этом приложении будет один экран, на котором змейка будет двигаться по экрану и "съедать" квадратики, увеличиваясь в длину.

Шаги для создания приложения:

1. Создадим структуру для змейки и еды.

2. Реализуем логику движения змейки.

3. Добавим обработку касаний для управления змейкой.

4. Отрисуем змейку и еду на экране.

Полный код приложения:

import SwiftUI

struct ContentView: View {
    @State private var snake: [CGPoint] = [
        CGPoint(x: 100, y: 100),
        CGPoint(x: 90, y: 100),
        CGPoint(x: 80, y: 100)
    ]
    @State private var food: CGPoint = CGPoint(x: 200, y: 200)
    @State private var direction: CGPoint = CGPoint(x: 10, y: 0)
    @State private var foodColor: Color = .red
    @State private var score: Int = 0
    
    let timer = Timer.publish(every: 0.1, on: .main, in: .common).autoconnect()
    
    var body: some View {
        ZStack {
            Color.black.edgesIgnoringSafeArea(.all)
            
            // Рисуем змейку
            ForEach(snake, id: \.self) { segment in
                Rectangle()
                    .fill(Color.green)
                    .frame(width: 10, height: 10)
                    .position(segment)
            }
            
            // Рисуем еду
            Rectangle()
                .fill(foodColor)
                .frame(width: 10, height: 10)
                .position(food)
            
            // Отображаем счет
            Text("Score: \(score)")
                .foregroundColor(.white)
                .font(.largeTitle)
                .padding()
        }
        .onReceive(timer) { _ in
            moveSnake()
        }
        .gesture(
            DragGesture()
                .onEnded { gesture in
                    let delta = gesture.translation
                    if abs(delta.width) > abs(delta.height) {
                        // Горизонтальный свайп
                        if delta.width > 0 {
                            direction = CGPoint(x: 10, y: 0) // Вправо
                        } else {
                            direction = CGPoint(x: -10, y: 0) // Влево
                        }
                    } else {
                        // Вертикальный свайп
                        if delta.height > 0 {
                            direction = CGPoint(x: 0, y: 10) // Вниз
                        } else {
                            direction = CGPoint(x: 0, y: -10) // Вверх
                        }
                    }
                }
        )
    }
    
    func moveSnake() {
        var newSnake = snake
        let head = newSnake[0]
        
        // Новое положение головы
        let newHead = CGPoint(x: head.x + direction.x, y: head.y + direction.y)
        
        // Проверяем, съела ли змейка еду
        if abs(newHead.x - food.x) < 10 && abs(newHead.y - food.y) < 10 {
            score += 1
            generateFood()
        } else {
            newSnake.removeLast()
        }
        
        newSnake.insert(newHead, at: 0)
        snake = newSnake
    }
    
    func generateFood() {
        let maxX = UIScreen.main.bounds.width - 10
        let maxY = UIScreen.main.bounds.height - 10
        
        food = CGPoint(
            x: CGFloat.random(in: 0...maxX),
            y: CGFloat.random(in: 0...maxY)
        )
        
        foodColor = Color(
            red: Double.random(in: 0...1),
            green: Double.random(in: 0...1),
            blue: Double.random(in: 0...1)
        )
    }
}

@main
struct SnakeApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

Описание кода:

1. Змейка и еда:

   • Змейка представлена массивом CGPoint, где каждый элемент — это координата одного сегмента змейки.

   • Еда — это случайная точка на экране, которая меняет цвет при каждом появлении.

2. Движение змейки:

   • Змейка движется с постоянной скоростью, обновляя свое положение каждые 0.1 секунды.

   • Если змейка "съедает" еду, ее длина увеличивается на один сегмент, и генерируется новая еда.

3. Управление:

   • Если пользователь свайпает вправо, змейка поворачивает вправо.

   • Если пользователь свайпает влево, змейка поворачивает влево.

   • Аналогично для свайпов вверх и вниз.

4. Отрисовка:

   • Змейка и еда отрисовываются с помощью Rectangle в SwiftUI.

Как запустить:

1. Создайте новый проект в Xcode с использованием SwiftUI.

2. Замените содержимое файла ContentView.swift на приведенный выше код.

3. Запустите приложение на симуляторе или устройстве.

Теперь у вас есть простая версия игры "Змейка" на SwiftUI!

Вот полный код приложения на SwiftUI, которое реализует эффект падающих сердечек с разлетом при клике.

Что делает этот код?

• Сердечки падают сверху экрана с разной скоростью и размером.

• Клик по экрану заставляет сердечки разлететься в стороны.

• Разные оттенки розового и размеры сердечек делают анимацию визуально привлекательной.

import SwiftUI

struct Heart: Identifiable {
    let id = UUID()
    var position: CGPoint
    var size: CGFloat
    var color: Color
    var velocity: CGFloat
}

struct ContentView: View {
    @State private var hearts: [Heart] = []
    @State private var explode = false
    let screenWidth = UIScreen.main.bounds.width
    let screenHeight = UIScreen.main.bounds.height

    var body: some View {
        ZStack {
            Color.black.ignoresSafeArea()

            ForEach(hearts) { heart in
                HeartShape()
                    .fill(heart.color)
                    .frame(width: heart.size, height: heart.size)
                    .position(heart.position)
                    .opacity(explode ? 0.5 : 1)
                    .animation(.easeInOut(duration: 1.5), value: explode)
            }
        }
        .onAppear {
            startDroppingHearts()
        }
        .onTapGesture {
            explodeHearts()
        }
    }

    func startDroppingHearts() {
        Timer.scheduledTimer(withTimeInterval: 0.3, repeats: true) { timer in
            let newHeart = Heart(
                position: CGPoint(x: CGFloat.random(in: 0...screenWidth), y: -50),
                size: CGFloat.random(in: 20...50),
                color: Color(red: Double.random(in: 0.8...1), green: Double.random(in: 0...0.3), blue: Double.random(in: 0.5...0.7)),
                velocity: CGFloat.random(in: 2...5)
            )

            hearts.append(newHeart)

            withAnimation(.linear(duration: 3)) {
                for index in hearts.indices {
                    hearts[index].position.y += screenHeight + 50
                }
            }

            hearts.removeAll { $0.position.y > screenHeight + 50 }
        }
    }

    func explodeHearts() {
        explode = true
        withAnimation(.easeOut(duration: 0.5)) {
            for index in hearts.indices {
                hearts[index].position.x += CGFloat.random(in: -100...100)
                hearts[index].position.y += CGFloat.random(in: -100...100)
            }
        }

        DispatchQueue.main.asyncAfter(deadline: .now() + 0.7) {
            explode = false
        }
    }
}

struct HeartShape: Shape {
    func path(in rect: CGRect) -> Path {
        var path = Path()

        let width = rect.width
        let height = rect.height

        path.move(to: CGPoint(x: width / 2, y: height))
        path.addCurve(to: CGPoint(x: 0, y: height / 3),
                      control1: CGPoint(x: width * 0.3, y: height * 1.1),
                      control2: CGPoint(x: 0, y: height * 0.6))

        path.addArc(center: CGPoint(x: width * 0.25, y: height / 3),
                    radius: width * 0.25,
                    startAngle: .degrees(180),
                    endAngle: .degrees(0),
                    clockwise: false)

        path.addArc(center: CGPoint(x: width * 0.75, y: height / 3),
                    radius: width * 0.25,
                    startAngle: .degrees(180),
                    endAngle: .degrees(0),
                    clockwise: false)

        path.addCurve(to: CGPoint(x: width / 2, y: height),
                      control1: CGPoint(x: width, y: height * 0.6),
                      control2: CGPoint(x: width * 0.7, y: height * 1.1))

        return path
    }
}

@main
struct HeartsApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

Как это работает?

• Падающие сердечки создаются каждые 0.3 секунды и плавно движутся вниз.

• Сердечки разного размера и оттенка розового.

• При клике по экрану сердечки разлетаются в случайном направлении.

• Анимации делают разлет плавным и красивым.

Попробуй запустить этот код в Xcode, и ты увидишь магию ?✨!

Создадим приложение на SwiftUI с анимацией падающих сердечек, которые разлетаются при нажатии на экран. Вот полный код:

import SwiftUI

struct Heart: Identifiable {
    let id = UUID()
    var position: CGPoint
    var color: Color
    var size: CGFloat
    var isFlying: Bool = false
}

struct ContentView: View {
    @State private var hearts: [Heart] = []
    @State private var timer: Timer?
    
    var body: some View {
        ZStack {
            Color.black
                .edgesIgnoringSafeArea(.all)
            
            ForEach(hearts) { heart in
                Image(systemName: "heart.fill")
                    .font(.system(size: heart.size))
                    .foregroundColor(heart.color)
                    .position(heart.position)
                    .animation(.linear(duration: heart.isFlying ? 0.5 : 10), value: heart.position)
            }
        }
        .onAppear {
            startHeartsAnimation()
        }
        .onDisappear {
            timer?.invalidate()
        }
        .onTapGesture {
            explodeHearts()
        }
    }
    
    private func startHeartsAnimation() {
        timer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { _ in
            let size = CGFloat.random(in: 20...50)
            let heart = Heart(
                position: CGPoint(x: CGFloat.random(in: 0...UIScreen.main.bounds.width), y: -size),
                color: Color(red: Double.random(in: 0.7...1), green: Double.random(in: 0.2...0.5), blue: Double.random(in: 0.4...0.7)),
                size: size
            )
            hearts.append(heart)
            
            DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
                if let index = hearts.firstIndex(where: { $0.id == heart.id }) {
                    hearts.remove(at: index)
                }
            }
            
            withAnimation(.linear(duration: 10)) {
                if let index = hearts.firstIndex(where: { $0.id == heart.id }) {
                    hearts[index].position.y = UIScreen.main.bounds.height + size
                }
            }
        }
    }
    
    private func explodeHearts() {
        for index in hearts.indices {
            let angle = Double.random(in: 0..<2 * .pi)
            let distance = CGFloat.random(in: 100...300)
            let newX = hearts[index].position.x + cos(angle) * distance
            let newY = hearts[index].position.y + sin(angle) * distance
            
            withAnimation(.easeOut(duration: 0.5)) {
                hearts[index].position = CGPoint(x: newX, y: newY)
                hearts[index].isFlying = true
            }
            
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                if let index = hearts.firstIndex(where: { $0.id == hearts[index].id }) {
                    hearts.remove(at: index)
                }
            }
        }
    }
}

@main
struct HeartAnimationApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}