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         case .ship2:
  77             // 特殊任務のクリア時にship2がapi_shipid付きでリクエストされ、その艦娘のデータしかない時があるため
  78             return !apiResponse.parameter["api_shipid"].valid
  79
  80         default:
  81             return true
  82         }
  83     }
  84
  85     private var store: ServerDataStore? {
  86
  87         return configuration.editorStore as? ServerDataStore
  88     }
  89
  90     func beginRegister(_ ship: Ship) {
  91
  92         ship.sally_area = nil
  93     }
  94
  95     func handleExtraValue(_ value: JSON, forKey key: String, to ship: Ship) -> Bool {
  96
  97         // 取得後破棄した装備のデータを削除するため保有IDを保存
  98         if key == "api_id" {
  99
 100             guard let id = value.int else { return false }
 101
 102             registerIds.append(id)
 103
 104             return false
 105         }
 106
 107         if key == "api_ship_id" {
 108
 109             guard let masterId = value.int else { return false }
 110
 111             if ship.ship_id == masterId { return true }
 112
 113             setMaster(masterId, to: ship)
 114
 115             return true
 116         }
 117
 118         if key == "api_exp" {
 119
 120             guard let exp = value[0].int else { return false }
 121
 122             if ship.exp == exp { return true }
 123
 124             ship.exp = exp
 125
 126             return true
 127         }
 128
 129         if key == "api_slot" {
 130
 131             setSlot(value, to: ship)
 132
 133             return false
 134         }
 135
 136         if key == "api_slot_ex" {
 137
 138             guard let ex = value.int else { return false }
 139
 140             if ship.slot_ex == ex { return true }
 141
 142             setExtraSlot(ex, to: ship)
 143             ship.slot_ex = ex
 144
 145             return true
 146         }
 147
 148         return false
 149     }
 150
 151     func finishOperating() {
 152
 153         if !needsDeleteUnregisteredShip { return }
 154
 155         store?.ships(exclude: registerIds).forEach { store?.delete($0) }
 156     }
 157
 158     private func setMaster(_ masterId: Int, to ship: Ship) {
 159
 160         guard let mShip = masterShips.binarySearch(comparator: { $0.id ==? masterId }),
 161             let masterShip = store?.object(of: MasterShip.entity, with: mShip.objectID) else {
 162
 163                 return Logger.shared.log("Can not convert to current moc object masterShip")
 164         }
 165
 166         ship.master_ship = masterShip
 167         ship.ship_id = masterId
 168     }
 169
 170     private func setSlot(_ slotItems: JSON, to ship: Ship) {
 171
 172         guard let convertedSlotItems = slotItems.arrayObject as? [Int] else { return }
 173         guard let store = store else { return }
 174
 175         let newItems: [SlotItem] = convertedSlotItems
 176             .filter { $0 != 0 && $0 != -1 }
 177             .flatMap { item in
 178
 179                 guard let found = self.slotItems.binarySearch(comparator: { $0.id ==? item }),
 180                     let slotItem = store.object(of: SlotItem.entity, with: found.objectID) else {
 181
 182                         let maxV = convertedSlotItems.last
 183                         if maxV != nil, maxV! < item {
 184
 185                             Debug.print("item is maybe unregistered, so it is new ship's equipment.")
 186                             return nil
 187                         }
 188                         Logger.shared.log("Can not convert to current moc object slotItem")
 189                         return nil
 190                 }
 191
 192                 return slotItem
 193         }
 194
 195         ship.equippedItem = NSOrderedSet(array: newItems)
 196     }
 197
 198     private func setExtraSlot(_ exSlotItem: Int, to ship: Ship) {
 199
 200         guard exSlotItem != -1, exSlotItem != 0 else {
 201             ship.extraItem = nil
 202             return
 203         }
 204         guard let found = slotItems.binarySearch(comparator: { $0.id ==? exSlotItem }),
 205             let ex = store?.object(of: SlotItem.entity, with: found.objectID) else {
 206
 207                 return Logger.shared.log("Can not convert to current moc object")
 208         }
 209
 210         ship.extraItem = ex
 211     }
 212 }