処理を簡素化

diff --git a/KCD/CalculateDamageCommand.swift b/KCD/CalculateDamageCommand.swift
index 60d0b9e..e80dc10 100644 (file)
--- a/KCD/CalculateDamageCommand.swift
+++ b/KCD/CalculateDamageCommand.swift
@@ -178,53 +178,47 @@ extension CalculateDamageCommand {
     
     func removeFirstDamageControl(of ship: Ship) {
         
-        let equiped = ship.equippedItem
-        let newEquiped = equiped.array
         let store = ServerDataStore.default
-        var useDamageControl = false
         
-        equiped.forEach {
-            
-            if useDamageControl { return }
-            
-            guard let master = $0 as? SlotItem else { return }
-            
-            let masterSlotItemId = store.masterSlotItemID(by: master.id)
-            
-            guard let type = DamageControlID(rawValue: masterSlotItemId) else { return }
+        let (item, damageControl) = ship
+            .equippedItem
+            .lazy
+            .flatMap { $0 as? SlotItem }
+            .map { ($0, store.masterSlotItemID(by: $0.id)) }
+            .map { ($0.0, DamageControlID(rawValue: $0.1)) }
+            .filter { $0.1 != nil }
+            .first ?? (nil, nil)
+        
+        if let validDamageControl = damageControl {
             
-            switch type {
+            switch validDamageControl {
+            case .damageControl: break
+                
             case .goddes:
                 ship.fuel = ship.maxFuel
                 ship.bull = ship.maxBull
-                fallthrough
-                
-            case .damageControl:
-                if var equiped = newEquiped as? [SlotItem],
-                    let index = equiped.index(of: master) {
-                    
-                    equiped[index...index] = []
-                    ship.equippedItem = NSOrderedSet(array: equiped)
-                    useDamageControl = true
-                }
             }
+            
+            guard let equiped = ship.equippedItem.array as? [SlotItem] else { return }
+                
+            ship.equippedItem = NSOrderedSet(array: equiped.filter { $0 != item })
+            
+            return
         }
         
-        if useDamageControl { return }
-        
         // check extra slot
         let exItemId = store.masterSlotItemID(by: ship.slot_ex)
         
         guard let exType = DamageControlID(rawValue: exItemId) else { return }
         
         switch exType {
+        case .damageControl: break
+            
         case .goddes:
             ship.fuel = ship.maxFuel
             ship.bull = ship.maxBull
-            fallthrough
-            
-        case .damageControl:
-            ship.slot_ex = -1
         }
+        
+        ship.slot_ex = -1
     }
 }

diff --git a/KCD/DamageCalculator.swift b/KCD/DamageCalculator.swift
index c000699..c044275 100644 (file)
--- a/KCD/DamageCalculator.swift
+++ b/KCD/DamageCalculator.swift
@@ -464,54 +464,43 @@ extension DamageCalculator {
     }
 }
 
-
 // MARK: - Damage control
 extension DamageCalculator {
     
-    private func damageControlIfPossible(nowhp: Int, ship: Ship) -> Int {
+    private func damageControlIfPossible(ship: Ship) -> Int {
         
-        var nowHp = nowhp
-        if nowHp < 0 { nowHp = 0 }
-        let maxhp = ship.maxhp
         let store = ServerDataStore.default
-        var useDamageControl = false
         
-        ship.equippedItem.forEach {
-            
-            if useDamageControl { return }
-            
-            guard let master = $0 as? SlotItem else { return }
-            
-            let masterSlotItemId = store.masterSlotItemID(by: master.id)
-            
-            guard let type = DamageControlID(rawValue: masterSlotItemId) else { return }
+        let damageControl = ship
+            .equippedItem
+            .lazy
+            .flatMap { $0 as? SlotItem }
+            .map { store.masterSlotItemID(by: $0.id) }
+            .flatMap { DamageControlID(rawValue: $0) }
+            .first
+        
+        if let validDamageControl = damageControl {
             
-            switch type {
+            switch validDamageControl {
             case .damageControl:
-                nowHp = Int(Double(maxhp) * 0.2)
-                useDamageControl = true
+                return Int(Double(ship.maxhp) * 0.2)
                 
             case .goddes:
-                nowHp = maxhp
-                useDamageControl = true
+                return ship.maxhp
             }
         }
         
-        if useDamageControl { return nowHp }
-        
         // check extra slot
         let exItemId = store.masterSlotItemID(by: ship.slot_ex)
         
-        guard let exType = DamageControlID(rawValue: exItemId) else { return nowHp }
+        guard let exType = DamageControlID(rawValue: exItemId) else { return 0 }
         
         switch exType {
         case .damageControl:
-            nowHp = Int(Double(maxhp) * 0.2)
+            return Int(Double(ship.maxhp) * 0.2)
             
         case .goddes:
-            nowHp = maxhp
+            return ship.maxhp
         }
-        
-        return nowHp
     }
 }