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
  12 enum GuardEscapeAPI: String {
  13
  14     case goback = "/kcsapi/api_req_combined_battle/goback_port"
  15     case gobakAlone = "/kcsapi/api_req_sortie/goback_port"
  16 }
  17
  18 extension Notification.Name {
  19
  20     static let DidUpdateGuardEscape = Notification.Name("com.masakih.KCD.Notification.DidUpdateGuardEscape")
  21 }
  22
  23 final class GuardShelterCommand: JSONCommand {
  24
  25 //    static let infoName = InformationName<[Int]>(name: "Ensured")
  26
  27     override class func canExecuteAPI(_ api: String) -> Bool {
  28
  29         return GuardEscapeAPI(rawValue: api) != nil
  30     }
  31
  32     override func execute() {
  33
  34         if let b = BattleAPI(rawValue: api) {
  35
  36             switch b {
  37             case .battleResult, .combinedBattleResult:
  38                 registerReserve()
  39
  40             default:
  41                 break
  42             }
  43         }
  44         if let m = MapAPI(rawValue: api), m == .next {
  45
  46             removeInvalidEntry()
  47         }
  48         if let _ = GuardEscapeAPI(rawValue: api) {
  49
  50             ensureGuardShelter()
  51         }
  52         if let _ = PortAPI(rawValue: api) {
  53
  54             removeAllEntry()
  55         }
  56     }
  57
  58     private func damagedShipId(damagedPos: Int) -> Int? {
  59
  60         let firstDeckId = TemporaryDataStore.default.battle()?.deckId ?? 1
  61
  62         let store = ServerDataStore.default
  63
  64         switch firstDeckId {
  65         case 1:
  66             switch damagedPos {
  67             case 1...6: return store.deck(by: 1)?.shipId(of: damagedPos - 1)
  68             case 7...12: return store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1)
  69             default: return nil
  70             }
  71         case 3:
  72             return store.deck(by: 3)?.shipId(of: damagedPos - 1)
  73         default:
  74             return nil
  75         }
  76     }
  77
  78     private func registerReserve() {
  79
  80         let escape = data["api_escape"]
  81
  82         guard let escapeIdx = escape["api_escape_idx"][0].int else { return }
  83         guard let damagedId = damagedShipId(damagedPos: escapeIdx) else {
  84
  85             return  Logger.shared.log("damagedPos is wrong")
  86         }
  87
  88         let store = TemporaryDataStore.oneTimeEditor()
  89
  90         guard let damaged = store.createGuardEscaped() else {
  91
  92             return Logger.shared.log("Can not create GuardEscaped for damaged")
  93         }
  94
  95         damaged.shipID = damagedId
  96         damaged.ensured = false
  97
  98         // store guardian if needs
  99         guard let guardianPos = escape["api_tow_idx"][0].int else { return }
 100
 101         let fixedGuardianPos = guardianPos - 6 - 1
 102
 103         guard let guardianId = ServerDataStore.default.deck(by: 2)?.shipId(of: fixedGuardianPos) else {
 104
 105             return Logger.shared.log("guardianPos is wrong")
 106         }
 107
 108         guard let guardian = store.createGuardEscaped() else {
 109
 110             return Logger.shared.log("Can not create GuardEscaped for guardinan")
 111         }
 112
 113         guardian.shipID = guardianId
 114         guardian.ensured = false
 115     }
 116
 117     private func removeInvalidEntry() {
 118
 119         let store = TemporaryDataStore.oneTimeEditor()
 120
 121         store.notEnsuredGuardEscaped().forEach(store.delete)
 122         store.save(errorHandler: store.presentOnMainThread)
 123         Thread.sleep(forTimeInterval: 0.1)
 124         notify()
 125     }
 126
 127     private func removeAllEntry() {
 128
 129         let store = TemporaryDataStore.oneTimeEditor()
 130
 131         store.guardEscaped().forEach(store.delete)
 132         store.save(errorHandler: store.presentOnMainThread)
 133         Thread.sleep(forTimeInterval: 0.1)
 134         notify()
 135     }
 136
 137     private func ensureGuardShelter() {
 138
 139         let store = TemporaryDataStore.oneTimeEditor()
 140
 141         store.guardEscaped().forEach { $0.ensured = true }
 142         store.save(errorHandler: store.presentOnMainThread)
 143         Thread.sleep(forTimeInterval: 0.1)
 144         notify()
 145     }
 146
 147     private func notify() {
 148
 149         DispatchQueue.main.async {
 150
 151             NotificationCenter.default.post(name: .DidUpdateGuardEscape, object: self)
 152         }
 153     }
 154 }