CoreData関連を変更

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

diff --git a/KCD/GuardShelterCommand.swift b/KCD/GuardShelterCommand.swift
index 7309112..207b96f 100644 (file)
--- a/KCD/GuardShelterCommand.swift
+++ b/KCD/GuardShelterCommand.swift
@@ -10,109 +10,136 @@ import Cocoa
 
 
 enum GuardEscapeAPI: String {
+    
     case goback = "/kcsapi/api_req_combined_battle/goback_port"
 }
 
 extension Notification.Name {
+    
     static let DidUpdateGuardEscape = Notification.Name("com.masakih.KCD.Notification.DidUpdateGuardEscape")
 }
 
-class GuardShelterCommand: JSONCommand {
+final class GuardShelterCommand: JSONCommand {
+    
     override class func canExecuteAPI(_ api: String) -> Bool {
+        
         return GuardEscapeAPI(rawValue: api) != nil ? true : false
     }
     
     override func execute() {
+        
         if let b = BattleAPI(rawValue: api) {
+            
             switch b {
             case .battleResult, .combinedBattleResult:
                 registerReserve()
+                
             default:
                 break
             }
         }
         if let m = MapAPI(rawValue: api), m == .next {
+            
             removeInvalidEntry()
         }
         if let _ = GuardEscapeAPI(rawValue: api) {
+            
             ensureGuardShelter()
         }
         if let _ = PortAPI(rawValue: api) {
+            
             removeAllEntry()
         }
     }
     
-    private func fleetMembers(fleetId: Int) -> [Int]? {
-        guard let deck = ServerDataStore.default.deck(byId: fleetId)
-            else { return nil }
-        return [deck.ship_0, deck.ship_1, deck.ship_2,
-                deck.ship_3, deck.ship_4, deck.ship_5]
-    }
-    private func damagedMemberPosition(escapeIdx: Any) -> Int? {
-        switch escapeIdx {
-        case let i as Int: return i
-        case let a as [Int] where !a.isEmpty: return a[0]
-        default: return nil
-        }
-    }
     private func damagedShipId(damagedPos: Int) -> Int? {
-        if damagedPos > 6, 0..<6 ~= damagedPos - 6 - 1 {
-            return fleetMembers(fleetId: 2)?[damagedPos - 6 - 1]
-        }
-        if 0..<6 ~= damagedPos - 1 {
-            return fleetMembers(fleetId: 1)?[damagedPos - 1]
+        
+        let store = ServerDataStore.default
+        
+        switch damagedPos {
+        case 1...6: return store.deck(by: 1)?.shipId(of:damagedPos - 1)
+        case 7...12: return store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1)
+        default: return nil
         }
-        return nil
     }
+    
     private func registerReserve() {
+        
         let escape = data["api_escape"]
-        let guardians = escape["api_tow_idx"]
-        guard let guardianPos = guardians[0].int
-            else { return }
+        
+        guard let guardianPos = escape["api_tow_idx"][0].int else { return }
+        
         let fixedGuardianPos = guardianPos - 6 - 1
-        guard 0..<6 ~= fixedGuardianPos,
-            let guardianId = fleetMembers(fleetId: 2)?[fixedGuardianPos]
-            else { return print("guardianPos is wrong") }
+                
+        guard let guardianId = ServerDataStore.default.deck(by: 2)?.shipId(of: fixedGuardianPos) else {
+                
+                print("guardianPos is wrong")
+                return
+        }
         
-        guard let escapeIdx = escape["api_escape_idx"].int,
-            let damagedPos = damagedMemberPosition(escapeIdx: escapeIdx),
-            let damagedId = damagedShipId(damagedPos: damagedPos)
-            else { return print("damagedPos is wrong") }
+        guard let escapeIdx = escape["api_escape_idx"][0].int,
+            let damagedId = damagedShipId(damagedPos: escapeIdx) else {
+                
+                print("damagedPos is wrong")
+                return
+        }
         
         let store = TemporaryDataStore.oneTimeEditor()
-        guard let guardian = store.createGuardEscaped()
-            else { return print("Can not create GuardEscaped for guardinan") }
+        
+        guard let guardian = store.createGuardEscaped() else {
+            
+            print("Can not create GuardEscaped for guardinan")
+            return
+        }
+        
         guardian.shipID = guardianId
         guardian.ensured = false
         
-        guard let damaged = store.createGuardEscaped()
-            else { return print("Can not create GuardEscaped for damaged") }
+        guard let damaged = store.createGuardEscaped() else {
+            
+            print("Can not create GuardEscaped for damaged")
+            return
+        }
+        
         damaged.shipID = damagedId
         damaged.ensured = false
     }
+    
     private func removeInvalidEntry() {
+        
         let store = TemporaryDataStore.oneTimeEditor()
-        store.notEnsuredGuardEscaped().forEach { store.delete($0) }
-        store.save()
+        
+        store.notEnsuredGuardEscaped().forEach(store.delete)
+        store.save(errorHandler: store.presentOnMainThread)
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }
+    
     private func removeAllEntry() {
+        
         let store = TemporaryDataStore.oneTimeEditor()
-        store.guardEscaped().forEach { store.delete($0) }
-        store.save()
+        
+        store.guardEscaped().forEach(store.delete)
+        store.save(errorHandler: store.presentOnMainThread)
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }
+    
     func ensureGuardShelter() {
+        
         let store = TemporaryDataStore.oneTimeEditor()
+        
         store.guardEscaped().forEach { $0.ensured = true }
-        store.save()
+        store.save(errorHandler: store.presentOnMainThread)
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }
     
     private func notify() {
-        NotificationCenter.default.post(name: .DidUpdateGuardEscape, object: self)
+        
+        DispatchQueue.main.async {
+            
+            NotificationCenter.default.post(name: .DidUpdateGuardEscape, object: self)
+        }
     }
 }