KCD/ShipMapper.swift

   1 //
   2 //  ShipMapper.swift
   3 //  KCD
   4 //
   5 //  Created by Hori,Masaki on 2017/02/23.
   6 //  Copyright © 2017年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import Cocoa
  10 import SwiftyJSON
  11
  12 final class ShipMapper: JSONMapper {
  13
  14     private static let ignoreKeys = ["api_gomes", "api_gomes2", "api_broken", "api_powup",
  15                                      "api_voicef", "api_afterlv", "api_aftershipid", "api_backs",
  16                                      "api_slotnum", "api_stype", "api_name", "api_yomi",
  17                                      "api_raig", "api_luck", "api_saku", "api_raim", "api_baku",
  18                                      "api_taik", "api_houg", "api_houm", "api_tyku",
  19                                      "api_ndock_item", "api_star",
  20                                      "api_ndock_time_str", "api_member_id",
  21                                      "api_fuel_max", "api_bull_max"]
  22
  23     let apiResponse: APIResponse
  24     let configuration: MappingConfiguration<Ship>
  25
  26     required init(_ apiResponse: APIResponse) {
  27
  28         self.apiResponse = apiResponse
  29         self.configuration = MappingConfiguration(entity: Ship.entity,
  30                                                   dataKeys: ShipMapper.dataKeys(apiResponse),
  31                                                   editorStore: ServerDataStore.oneTimeEditor(),
  32                                                   ignoreKeys: ShipMapper.ignoreKeys)
  33     }
  34
  35     // slotDepriveの時に２種類のデータが来るため
  36     init(forSlotDepriveUnset apiResponse: APIResponse) {
  37
  38         self.apiResponse = apiResponse
  39         self.configuration = MappingConfiguration(entity: Ship.entity,
  40                                                   dataKeys: ["api_data", "api_ship_data", "api_unset_ship"],
  41                                                   editorStore: ServerDataStore.oneTimeEditor(),
  42                                                   ignoreKeys: ShipMapper.ignoreKeys)
  43     }
  44
  45     private class func dataKeys(_ apiResponse: APIResponse) -> [String] {
  46
  47         switch apiResponse.api.endpoint {
  48
  49         case .port, .getShip, .powerup: return ["api_data", "api_ship"]
  50
  51         case .ship3, .shipDeck: return ["api_data", "api_ship_data"]
  52
  53         case .slotDeprive: return ["api_data", "api_ship_data", "api_set_ship"]
  54
  55         case .ship, .ship2: return ["api_data"]
  56
  57         default: return Logger.shared.log("Missing API: \(apiResponse.api)", value: ["api_data"])
  58         }
  59     }
  60
  61     private var registerIds: [Int] = []
  62     private lazy var masterShips: [MasterShip] = {
  63
  64         return ServerDataStore.default.sortedMasterShipsById()
  65     }()
  66     private lazy var slotItems: [SlotItem] = {
  67
  68         return ServerDataStore.default.sortedSlotItemsById()
  69     }()
  70     private var needsDeleteUnregisteredShip: Bool {
  71
  72         switch apiResponse.api.endpoint {
  73         case .ship3, .getShip, .shipDeck, .powerup, .slotDeprive:
  74             return false
  75
  76         default:
  77             return true
  78         }
  79     }
  80
  81     private var store: ServerDataStore? {
  82
  83         return configuration.editorStore as? ServerDataStore
  84     }
  85
  86     func beginRegister(_ ship: Ship) {
  87
  88         ship.sally_area = nil
  89     }
  90
  91     func handleExtraValue(_ value: JSON, forKey key: String, to ship: Ship) -> Bool {
  92
  93         // 取得後破棄した装備のデータを削除するため保有IDを保存
  94         if key == "api_id" {
  95
  96             guard let id = value.int else { return false }
  97
  98             registerIds.append(id)
  99
 100             return false
 101         }
 102
 103         if key == "api_ship_id" {
 104
 105             guard let masterId = value.int else { return false }
 106
 107             if ship.ship_id == masterId { return true }
 108
 109             setMaster(masterId, to: ship)
 110
 111             return true
 112         }
 113
 114         if key == "api_exp" {
 115
 116             guard let exp = value[0].int else { return false }
 117
 118             if ship.exp == exp { return true }
 119
 120             ship.exp = exp
 121
 122             return true
 123         }
 124
 125         if key == "api_slot" {
 126
 127             setSlot(value, to: ship)
 128
 129             return false
 130         }
 131
 132         if key == "api_slot_ex" {
 133
 134             guard let ex = value.int else { return false }
 135
 136             if ship.slot_ex == ex { return true }
 137
 138             setExtraSlot(ex, to: ship)
 139
 140             return true
 141         }
 142
 143         return false
 144     }
 145
 146     func finishOperating() {
 147
 148         if !needsDeleteUnregisteredShip { return }
 149
 150         store?.ships(exclude: registerIds).forEach { store?.delete($0) }
 151     }
 152
 153     private func setMaster(_ masterId: Int, to ship: Ship) {
 154
 155         guard let mShip = masterShips.binarySearch(comparator: { $0.id ==? masterId }),
 156             let masterShip = store?.object(of: MasterShip.entity, with: mShip.objectID) else {
 157
 158                 return Logger.shared.log("Can not convert to current moc object masterShip")
 159         }
 160
 161         ship.master_ship = masterShip
 162         ship.ship_id = masterId
 163     }
 164
 165     private func setSlot(_ slotItems: JSON, to ship: Ship) {
 166
 167         guard let convertedSlotItems = slotItems.arrayObject as? [Int] else { return }
 168         guard let store = store else { return }
 169
 170         let newItems: [SlotItem] = convertedSlotItems
 171             .filter { $0 != 0 && $0 != -1 }
 172             .flatMap { item in
 173
 174                 guard let found = self.slotItems.binarySearch(comparator: { $0.id ==? item }),
 175                     let slotItem = store.object(of: SlotItem.entity, with: found.objectID) else {
 176
 177                         let maxV = convertedSlotItems.last
 178                         if maxV != nil, maxV! < item {
 179
 180                             Debug.print("item is maybe unregistered, so it is new ship's equipment.")
 181                             return nil
 182                         }
 183                         Logger.shared.log("Can not convert to current moc object slotItem")
 184                         return nil
 185                 }
 186
 187                 return slotItem
 188         }
 189
 190         ship.equippedItem = NSOrderedSet(array: newItems)
 191     }
 192
 193     private func setExtraSlot(_ exSlotItem: Int, to ship: Ship) {
 194
 195         guard exSlotItem != -1, exSlotItem != 0 else { return }
 196         guard let found = slotItems.binarySearch(comparator: { $0.id ==? exSlotItem }),
 197             let ex = store?.object(of: SlotItem.entity, with: found.objectID) else {
 198
 199                 return Logger.shared.log("Can not convert to current moc object")
 200         }
 201
 202         ship.extraItem = ex
 203         ship.slot_ex = exSlotItem
 204     }
 205 }