被ダメ計算を連合艦隊に対応

[kcd/KCD.git] / KCD / CalculateDamageCommand.swift

diff --git a/KCD/CalculateDamageCommand.swift b/KCD/CalculateDamageCommand.swift
index 010097c..28eca76 100644 (file)
--- a/KCD/CalculateDamageCommand.swift
+++ b/KCD/CalculateDamageCommand.swift
@@ -29,8 +29,7 @@ final class CalculateDamageCommand: JSONCommand {
     
     override func execute() {
         
-        guard let battleApi = BattleAPI(rawValue: api)
-            else { return }
+        guard let battleApi = BattleAPI(rawValue: api) else { return }
         
         switch battleApi {
         case .battle, .airBattle, .ldAirBattle:
@@ -102,7 +101,7 @@ extension CalculateDamageCommand {
         
         let store = TemporaryDataStore.oneTimeEditor()
         
-        store.damages().forEach { store.delete($0) }
+        store.damages().forEach(store.delete)
     }
     
     func applyDamage() {
@@ -111,35 +110,43 @@ extension CalculateDamageCommand {
         
         let totalDamages = store.sortedDamagesById()
         
-        guard totalDamages.count == 12
-            else { return print("Damages count is invalid. count is \(totalDamages.count).") }
-        
         let aStore = ServerDataStore.oneTimeEditor()
         
-        totalDamages.forEach {
+        Debug.excute(level: .debug) {
             
-            guard let ship = aStore.ship(by: $0.shipID)
-                else { return }
+            print("-------")
             
-            if ship.nowhp != $0.hp {
+            totalDamages.forEach {
                 
-                Debug.print("\(ship.name)(\(ship.id)),HP \(ship.nowhp) -> \($0.hp)", level: .debug)
+                guard let ship = aStore.ship(by: $0.shipID) else { return }
+                
+                if ship.nowhp != $0.hp {
+                    
+                    print("\(ship.name)(\(ship.id)),HP \(ship.nowhp) -> \($0.hp)")
+                }
             }
             
+            
+            print("------- End Battle")
+        }
+        
+        // 第二艦隊単独出撃で正しくデータが反映されるように逆順にして計算
+        totalDamages.reversed().forEach {
+            
+            guard let ship = aStore.ship(by: $0.shipID) else { return }
+            
             ship.nowhp = $0.hp
             
             if $0.useDamageControl { removeFirstDamageControl(of: ship) }
         }
         
-        Debug.print("------- End Battle", level: .debug)
     }
     
     func updateBattleCell() {
         
         let store = TemporaryDataStore.default
         
-        guard let battle = store.battle()
-            else { return print("Battle is invalid.") }
+        guard let battle = store.battle() else { return Logger.shared.log("Battle is invalid.") }
         
         battle.battleCell = (battle.no == 0 ? nil : battle.no as NSNumber)
         
@@ -174,56 +181,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 }
+        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
     }
 }