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