Swiftのクロージャを使ったゲームロジックの実装方法

{ (引数リスト) -> 戻り値の型 in
    実行されるコード
}

let additionClosure = { (a: Int, b: Int) -> Int in
    return a + b
}

let result = additionClosure(5, 10)
print(result) // 15

let additionClosure = { (a, b) in a + b }

class Character {
    var name: String
    var attackAction: (() -> Void)?

    init(name: String) {
        self.name = name
    }

    func attack() {
        attackAction?()
    }
}

let hero = Character(name: "Hero")
hero.attackAction = {
    print("\(hero.name) attacks with a sword!")
}

hero.attack()  // Hero attacks with a sword!

class Game {
    var onItemCollected: ((String) -> Void)?

    func collectItem(item: String) {
        onItemCollected?(item)
    }
}

let game = Game()
game.onItemCollected = { item in
    print("You have collected a \(item)!")
}

game.collectItem(item: "Magic Potion")  // You have collected a Magic Potion!

let enemy = Character(name: "Enemy")
enemy.attackAction = {
    print("\(enemy.name) attacks with claws!")
}

// Later in the game
enemy.attackAction = {
    print("\(enemy.name) attacks with fireballs!")
}

enemy.attack()  // Enemy attacks with fireballs!

enum GameState {
    case exploring
    case inBattle
    case paused
}

class Game {
    var currentState: GameState
    var onStateChange: ((GameState) -> Void)?

    init(state: GameState) {
        self.currentState = state
    }

    func changeState(to newState: GameState) {
        currentState = newState
        onStateChange?(newState)
    }
}

let game = Game(state: .exploring)
game.onStateChange = { state in
    switch state {
    case .exploring:
        print("Player is exploring the world.")
    case .inBattle:
        print("Player is in battle!")
    case .paused:
        print("Game is paused.")
    }
}

game.changeState(to: .inBattle)  // Player is in battle!

class Player {
    var health: Int {
        didSet {
            onHealthChange?(health)
        }
    }
    var onHealthChange: ((Int) -> Void)?

    init(health: Int) {
        self.health = health
    }
}

let player = Player(health: 100)
player.onHealthChange = { newHealth in
    if newHealth <= 0 {
        print("Player has been defeated.")
    } else {
        print("Player's health is now \(newHealth).")
    }
}

player.health = 50  // Player's health is now 50.
player.health = 0   // Player has been defeated.

class Enemy {
    var attackAction: (() -> Void)?

    func performAttack() {
        attackAction?()
    }
}

let easyEnemy = Enemy()
easyEnemy.attackAction = {
    print("Easy enemy attacks slowly.")
}

let hardEnemy = Enemy()
hardEnemy.attackAction = {
    print("Hard enemy attacks quickly!")
}

let currentDifficulty = "hard"
let enemy = (currentDifficulty == "easy") ? easyEnemy : hardEnemy
enemy.performAttack()  // Hard enemy attacks quickly!

func fetchGameData(completion: @escaping (String) -> Void) {
    // 非同期処理のシミュレーション（2秒後にデータを返す）
    DispatchQueue.global().asyncAfter(deadline: .now() + 2.0) {
        let gameData = "Game data loaded"
        completion(gameData)
    }
}

fetchGameData { data in
    print(data)  // "Game data loaded" が出力される
}

func startCountdown(duration: Int, onComplete: @escaping () -> Void) {
    var remainingTime = duration

    let timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
        if remainingTime > 0 {
            print("\(remainingTime) seconds left")
            remainingTime -= 1
        } else {
            timer.invalidate()
            onComplete()
        }
    }
    RunLoop.current.add(timer, forMode: .common)
}

startCountdown(duration: 5) {
    print("Time's up! The game is over.")
}

import UIKit

func animateCharacterMove(view: UIView, to position: CGPoint, completion: @escaping () -> Void) {
    UIView.animate(withDuration: 2.0, animations: {
        view.center = position
    }) { finished in
        if finished {
            completion()
        }
    }
}

let characterView = UIView(frame: CGRect(x: 0, y: 0, width: 50, height: 50))
animateCharacterMove(view: characterView, to: CGPoint(x: 100, y: 100)) {
    print("Character has reached the destination!")
}

func performParallelTasks(completion: @escaping () -> Void) {
    let dispatchGroup = DispatchGroup()

    dispatchGroup.enter()
    DispatchQueue.global().async {
        // 非同期タスク1（ネットワーク処理の模擬）
        sleep(2)
        print("Task 1 completed")
        dispatchGroup.leave()
    }

    dispatchGroup.enter()
    DispatchQueue.global().async {
        // 非同期タスク2（アニメーションの模擬）
        sleep(3)
        print("Task 2 completed")
        dispatchGroup.leave()
    }

    dispatchGroup.notify(queue: .main) {
        completion()
    }
}

performParallelTasks {
    print("Both tasks completed. Proceed to the next step.")
}

import UIKit

class GameViewController: UIViewController {
    var onTap: (() -> Void)?

    override func viewDidLoad() {
        super.viewDidLoad()

        let tapGesture = UITapGestureRecognizer(target: self, action: #selector(handleTap))
        view.addGestureRecognizer(tapGesture)
    }

    @objc func handleTap() {
        onTap?()
    }
}

let gameVC = GameViewController()
gameVC.onTap = {
    print("The screen was tapped. Character jumps!")
}

// 実際のアプリでは、ここでジャンプ処理などを行う

let attackButton = UIButton()

attackButton.addTarget(nil, action: #selector(buttonPressed), for: .touchUpInside)

@objc func buttonPressed() {
    onAttack?()
}

var onAttack: (() -> Void)?

onAttack = {
    print("Player attacks the enemy!")
}

// 攻撃ボタンが押されたとき、onAttackクロージャが実行される

var spawnEnemy: (() -> Void)?

let enemySpawnTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
    spawnEnemy?()
}

spawnEnemy = {
    print("An enemy has spawned!")
}

enum GameState {
    case exploring
    case inBattle
}

var currentState: GameState = .exploring

var handleEvent: (() -> Void)?

func updateState(to newState: GameState) {
    currentState = newState

    switch newState {
    case .exploring:
        handleEvent = {
            print("Player is exploring the map.")
        }
    case .inBattle:
        handleEvent = {
            print("Player is in battle mode!")
        }
    }
}

// 状態を戦闘中に変更
updateState(to: .inBattle)
handleEvent?()  // "Player is in battle mode!" と出力される

class Character {
    var name: String
    var health: Int
    var attackAction: (() -> Void)?

    init(name: String, health: Int) {
        self.name = name
        self.health = health
    }

    func attack() {
        attackAction?()
    }

    func takeDamage(damage: Int) {
        health -= damage
        print("\(name) takes \(damage) damage. Health is now \(health).")
    }
}

class Game {
    var player: Character
    var enemy: Character
    var onEnemyDefeated: (() -> Void)?

    init(player: Character, enemy: Character) {
        self.player = player
        self.enemy = enemy
    }

    func startBattle() {
        print("Battle starts between \(player.name) and \(enemy.name).")

        // プレイヤーの攻撃アクションをクロージャで定義
        player.attackAction = {
            let damage = 20
            print("\(self.player.name) attacks \(self.enemy.name)!")
            self.enemy.takeDamage(damage: damage)

            if self.enemy.health <= 0 {
                self.onEnemyDefeated?()
            }
        }

        // 敵の攻撃アクションもクロージャで定義
        enemy.attackAction = {
            let damage = 15
            print("\(self.enemy.name) counterattacks \(self.player.name)!")
            self.player.takeDamage(damage: damage)
        }
    }
}

let player = Character(name: "Hero", health: 100)
let enemy = Character(name: "Goblin", health: 50)
let game = Game(player: player, enemy: enemy)

game.onEnemyDefeated = {
    print("The enemy has been defeated! \(player.name) wins the battle!")
}

// バトルの開始
game.startBattle()

// プレイヤーの攻撃
game.player.attack()

// 敵がまだ生きている場合、敵が反撃する
if enemy.health > 0 {
    game.enemy.attack()
}

func usePowerUp() {
    print("\(player.name) uses a power-up!")
    player.attackAction = {
        let increasedDamage = 40
        print("\(self.player.name) attacks with increased power!")
        self.enemy.takeDamage(damage: increasedDamage)

        if self.enemy.health <= 0 {
            self.onEnemyDefeated?()
        }
    }
}

// パワーアップアイテムを使用して攻撃力を変更
usePowerUp()
game.player.attack()

class Enemy {
    var health: Int
    var onAttack: (() -> Void)?

    init(health: Int) {
        self.health = health
    }

    func setAttackAction() {
        onAttack = { [weak self] in
            guard let self = self else { return }
            print("Enemy attacks!")
            self.health -= 10
        }
    }
}

let enemy = Enemy(health: 100)
enemy.setAttackAction()
enemy.onAttack?()

class GameLoop {
    var updateAction: (() -> Void)?

    func start() {
        while true {
            updateAction?()
            // 60フレーム/秒で処理を繰り返す
            usleep(16667)  // 約16msのスリープ（1秒÷60）
        }
    }
}

let gameLoop = GameLoop()

gameLoop.updateAction = {
    // ゲームの状態更新や描画処理
    print("Game is updating...")
}

gameLoop.start()

func loadGameData(completion: @escaping () -> Void) {
    DispatchQueue.global(qos: .background).async {
        // データのロード処理
        print("Loading game data...")
        sleep(2)  // 重い処理のシミュレーション
        DispatchQueue.main.async {
            completion()
        }
    }
}

loadGameData {
    print("Game data loaded, proceed to the next step.")
}

// デリゲートパターンの例
protocol GameDelegate: AnyObject {
    func onGameEvent()
}

class Game {
    weak var delegate: GameDelegate?

    func triggerEvent() {
        delegate?.onGameEvent()
    }
}

// クロージャを使った例
class GameWithClosure {
    var onEvent: (() -> Void)?

    func triggerEvent() {
        onEvent?()
    }
}

let gameWithClosure = GameWithClosure()
gameWithClosure.onEvent = {
    print("Game event triggered using closure.")
}
gameWithClosure.triggerEvent()

gameWithClosure.onEvent = nil  // クロージャを解放

class EnemyAI {
    var attackStrategy: (() -> Void)?

    func performAction(playerDistance: Int) {
        if playerDistance < 10 {
            attackStrategy = {
                print("Enemy performs a close-range attack!")
            }
        } else {
            attackStrategy = {
                print("Enemy performs a long-range attack!")
            }
        }

        attackStrategy?()
    }
}

let enemyAI = EnemyAI()
enemyAI.performAction(playerDistance: 5)   // "Enemy performs a close-range attack!"
enemyAI.performAction(playerDistance: 20)  // "Enemy performs a long-range attack!"

class GameLevel {
    var onLevelStart: (() -> Void)?
    var onLevelComplete: (() -> Void)?

    func startLevel() {
        onLevelStart?()
    }

    func completeLevel() {
        onLevelComplete?()
    }
}

let level1 = GameLevel()
level1.onLevelStart = {
    print("Level 1 has started. Initializing enemies and obstacles.")
}
level1.onLevelComplete = {
    print("Level 1 completed. Preparing for the next level.")
}

let level2 = GameLevel()
level2.onLevelStart = {
    print("Level 2 has started. More enemies and tougher challenges!")
}
level2.onLevelComplete = {
    print("Level 2 completed. Great job!")
}

// ステージ1を開始
level1.startLevel()
// ステージ1をクリア
level1.completeLevel()

// ステージ2を開始
level2.startLevel()

enum PlayerState {
    case normal
    case attacking
    case defending
    case dodging
}

class Player {
    var currentState: PlayerState = .normal
    var onStateChange: ((PlayerState) -> Void)?

    func changeState(to newState: PlayerState) {
        currentState = newState
        onStateChange?(newState)
    }
}

let player = Player()
player.onStateChange = { state in
    switch state {
    case .normal:
        print("Player is in normal state, ready for any action.")
    case .attacking:
        print("Player is attacking the enemy!")
    case .defending:
        print("Player is defending against attacks.")
    case .dodging:
        print("Player is dodging!")
    }
}

// プレイヤーが攻撃状態に遷移
player.changeState(to: .attacking)
// プレイヤーが防御状態に遷移
player.changeState(to: .defending)

func eventChain() {
    let event1 = {
        print("Event 1: Player enters the dungeon.")
    }

    let event2 = {
        print("Event 2: Enemy appears.")
    }

    let event3 = {
        print("Event 3: Player defeats the enemy.")
    }

    // イベントチェーンの実行
    event1()
    event2()
    event3()
}

eventChain()

class Player {
    var attackAction: (() -> Void)?

    func attack() {
        attackAction?()
    }
}

let player = Player()

// 剣を使用
player.attackAction = {
    print("プレイヤーが剣で攻撃しました！")
}
player.attack()

// 弓を使用
player.attackAction = {
    print("プレイヤーが弓で攻撃しました！")
}
player.attack()

import Foundation

var spawnCount = 0

let enemySpawnTimer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { timer in
    spawnCount += 1
    print("敵が出現しました！")

    if spawnCount >= 3 {
        timer.invalidate()
        print("敵の出現が終了しました。")
    }
}

RunLoop.current.run()  // 実行を続けるために必要

func eventChain() {
    let event1 = {
        print("プレイヤーがダンジョンに入ります")
    }

    let event2 = {
        print("敵が現れました")
    }

    let event3 = {
        print("プレイヤーが敵を倒しました")
    }

    // イベントのチェーンを作成
    event1()
    event2()
    event3()
}

eventChain()

enum PlayerState {
    case normal
    case attacking
    case defending
    case dodging
}

class Player {
    var currentState: PlayerState = .normal
    var onStateChange: ((PlayerState) -> Void)?

    func changeState(to newState: PlayerState) {
        currentState = newState
        onStateChange?(newState)
    }
}

let player = Player()

player.onStateChange = { state in
    switch state {
    case .normal:
        print("プレイヤーは通常状態です")
    case .attacking:
        print("プレイヤーが攻撃中です")
    case .defending:
        print("プレイヤーが防御中です")
    case .dodging:
        print("プレイヤーが回避中です")
    }
}

// 状態を攻撃に遷移
player.changeState(to: .attacking)

// 状態を防御に遷移
player.changeState(to: .defending)