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:
  40
  41             Logger.shared.log("Missing API: \(apiResponse.api)")
  42
  43             return
  44
  45         }
  46     }
  47
  48     private func damagedShipId(damagedPos: Int) -> Int? {
  49
  50         let tempStore = TemporaryDataStore.default
  51         let firstDeckId = tempStore.sync { tempStore.battle()?.deckId ?? 1 }
  52
  53         let store = ServerDataStore.default
  54
  55         switch firstDeckId {
  56
  57         case 1:
  58             switch damagedPos {
  59
  60             case 1...6: return store.sync { store.deck(by: 1)?.shipId(of: damagedPos - 1) }
  61
  62             case 7...12: return store.sync { store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1) }
  63
  64             default: return nil
  65
  66             }
  67
  68         case 3: return store.sync { store.deck(by: 3)?.shipId(of: damagedPos - 1) }
  69
  70         default: return nil
  71
  72         }
  73     }
  74
  75     private func reserveEscapeShips() {
  76
  77         let escape = data["api_escape"]
  78
  79         guard let escapeIdx = escape["api_escape_idx"][0].int else {
  80
  81             return
  82         }
  83         guard let damagedId = damagedShipId(damagedPos: escapeIdx) else {
  84
  85             Logger.shared.log("damagedPos is wrong")
  86
  87             return
  88         }
  89
  90         let store = TemporaryDataStore.oneTimeEditor()
  91         store.sync {
  92
  93             guard let damaged = store.createGuardEscaped() else {
  94
  95                 Logger.shared.log("Can not create GuardEscaped for damaged")
  96
  97                 return
  98             }
  99
 100             damaged.shipID = damagedId
 101             damaged.ensured = false
 102
 103             // store guardian if needs
 104             guard let guardianPos = escape["api_tow_idx"][0].int else {
 105
 106                 return
 107             }
 108
 109             let fixedGuardianPos = guardianPos - 6 - 1
 110
 111             let sStore = ServerDataStore.default
 112             guard let guardianId = sStore.sync(execute: { sStore.deck(by: 2)?.shipId(of: fixedGuardianPos) }) else {
 113
 114                 Logger.shared.log("guardianPos is wrong")
 115
 116                 return
 117             }
 118
 119             guard let guardian = store.createGuardEscaped() else {
 120
 121                 Logger.shared.log("Can not create GuardEscaped for guardinan")
 122
 123                 return
 124             }
 125
 126             guardian.shipID = guardianId
 127             guardian.ensured = false
 128         }
 129     }
 130
 131     private func removeInvalidEntry() {
 132
 133         let store = TemporaryDataStore.oneTimeEditor()
 134         store.sync {
 135
 136             store.notEnsuredGuardEscaped().forEach(store.delete)
 137             store.save()
 138         }
 139         Thread.sleep(forTimeInterval: 0.1)
 140         notify()
 141     }
 142
 143     private func removeAllEntry() {
 144
 145         let store = TemporaryDataStore.oneTimeEditor()
 146         store.sync {
 147
 148             store.guardEscaped().forEach(store.delete)
 149             store.save()
 150         }
 151         Thread.sleep(forTimeInterval: 0.1)
 152         notify()
 153     }
 154
 155     private func ensureGuardShelter() {
 156
 157         let store = TemporaryDataStore.oneTimeEditor()
 158         store.sync {
 159
 160             store.guardEscaped().forEach { $0.ensured = true }
 161             store.save()
 162         }
 163         Thread.sleep(forTimeInterval: 0.1)
 164         notify()
 165     }
 166
 167     private func notify() {
 168
 169         DispatchQueue.main.async {
 170
 171             NotificationCenter.default.post(name: .DidUpdateGuardEscape, object: self)
 172         }
 173     }
 174 }