KCD/GuardShelterCommand.swift

   1 //
   2 //  GuardShelterCommand.swift
   3 //  KCD
   4 //
   5 //  Created by Hori,Masaki on 2017/01/15.
   6 //  Copyright © 2017年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import Cocoa
  10
  11 extension Notification.Name {
  12
  13     static let DidUpdateGuardEscape = Notification.Name("com.masakih.KCD.Notification.DidUpdateGuardEscape")
  14 }
  15
  16 final class GuardShelterCommand: JSONCommand {
  17
  18     override class func canExecuteAPI(_ api: API) -> Bool {
  19
  20         return api.type == .guardEscape
  21     }
  22
  23     override func execute() {
  24
  25         switch api.type {
  26
  27         case .battleResult:
  28             reserveEscapeShips()
  29
  30         case .map:
  31             removeInvalidEntry()
  32
  33         case .guardEscape:
  34             ensureGuardShelter()
  35
  36         case .port:
  37             removeAllEntry()
  38
  39         default: return Logger.shared.log("Missing API: \(apiResponse.api)")
  40         }
  41     }
  42
  43     private func damagedShipId(damagedPos: Int) -> Int? {
  44
  45         let tempStore = TemporaryDataStore.default
  46         let firstDeckId = tempStore.sync { tempStore.battle()?.deckId ?? 1 }
  47
  48         let store = ServerDataStore.default
  49
  50         switch firstDeckId {
  51         case 1:
  52             switch damagedPos {
  53             case 1...6: return store.sync { store.deck(by: 1)?.shipId(of: damagedPos - 1) }
  54             case 7...12: return store.sync { store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1) }
  55             default: return nil
  56             }
  57         case 3:
  58             return store.sync { store.deck(by: 3)?.shipId(of: damagedPos - 1) }
  59         default:
  60             return nil
  61         }
  62     }
  63
  64     private func reserveEscapeShips() {
  65
  66         let escape = data["api_escape"]
  67
  68         guard let escapeIdx = escape["api_escape_idx"][0].int else { return }
  69         guard let damagedId = damagedShipId(damagedPos: escapeIdx) else {
  70
  71             return  Logger.shared.log("damagedPos is wrong")
  72         }
  73
  74         let store = TemporaryDataStore.oneTimeEditor()
  75         store.sync {
  76
  77             guard let damaged = store.createGuardEscaped() else {
  78
  79                 return Logger.shared.log("Can not create GuardEscaped for damaged")
  80             }
  81
  82             damaged.shipID = damagedId
  83             damaged.ensured = false
  84
  85             // store guardian if needs
  86             guard let guardianPos = escape["api_tow_idx"][0].int else { return }
  87
  88             let fixedGuardianPos = guardianPos - 6 - 1
  89
  90             let sStore = ServerDataStore.default
  91             guard let guardianId = sStore.sync(execute: { sStore.deck(by: 2)?.shipId(of: fixedGuardianPos) }) else {
  92
  93                 return Logger.shared.log("guardianPos is wrong")
  94             }
  95
  96             guard let guardian = store.createGuardEscaped() else {
  97
  98                 return Logger.shared.log("Can not create GuardEscaped for guardinan")
  99             }
 100
 101             guardian.shipID = guardianId
 102             guardian.ensured = false
 103         }
 104     }
 105
 106     private func removeInvalidEntry() {
 107
 108         let store = TemporaryDataStore.oneTimeEditor()
 109         store.sync {
 110             store.notEnsuredGuardEscaped().forEach(store.delete)
 111             store.save(errorHandler: store.presentOnMainThread)
 112         }
 113         Thread.sleep(forTimeInterval: 0.1)
 114         notify()
 115     }
 116
 117     private func removeAllEntry() {
 118
 119         let store = TemporaryDataStore.oneTimeEditor()
 120         store.sync {
 121             store.guardEscaped().forEach(store.delete)
 122             store.save(errorHandler: store.presentOnMainThread)
 123         }
 124         Thread.sleep(forTimeInterval: 0.1)
 125         notify()
 126     }
 127
 128     private func ensureGuardShelter() {
 129
 130         let store = TemporaryDataStore.oneTimeEditor()
 131         store.sync {
 132             store.guardEscaped().forEach { $0.ensured = true }
 133             store.save(errorHandler: store.presentOnMainThread)
 134         }
 135         Thread.sleep(forTimeInterval: 0.1)
 136         notify()
 137     }
 138
 139     private func notify() {
 140
 141         DispatchQueue.main.async {
 142
 143             NotificationCenter.default.post(name: .DidUpdateGuardEscape, object: self)
 144         }
 145     }
 146 }