KCD/EnhancementListItem.swift

   1 //
   2 //  EnhancementListItem.swift
   3 //  KCD
   4 //
   5 //  Created by Hori,Masaki on 2017/01/25.
   6 //  Copyright © 2017年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import Cocoa
  10
  11 final class EnhancementListItem: NSObject, NSCoding, NSCopying {
  12
  13     let identifier: String
  14     let weekday: Int
  15     let equipmentType: EquipmentType
  16     let targetEquipment: String
  17     let remodelEquipment: String?
  18     let requiredEquipments: RequiredEquipmentSet
  19     let secondsShipNames: [String]
  20
  21     init(identifier: String,
  22          weekday: Int,
  23          equipmentType: EquipmentType,
  24          targetEquipment: String,
  25          remodelEquipment: String?,
  26          requiredEquipments: RequiredEquipmentSet,
  27          secondsShipNames: [String]) {
  28
  29         self.identifier = identifier
  30         self.weekday = weekday
  31         self.equipmentType = equipmentType
  32         self.targetEquipment = targetEquipment
  33         self.remodelEquipment = remodelEquipment
  34         self.requiredEquipments = requiredEquipments
  35         self.secondsShipNames = secondsShipNames
  36
  37         super.init()
  38     }
  39
  40     func replace(identifier: String? = nil,
  41                  weekday: Int? = nil,
  42                  equipmentType: EquipmentType? = nil,
  43                  targetEquipment: String? = nil,
  44                  remodelEquipment: String? = nil,
  45                  requiredEquipments: RequiredEquipmentSet? = nil,
  46                  secondsShipNames: [String]? = nil) -> EnhancementListItem {
  47
  48         return EnhancementListItem(identifier: identifier ?? self.identifier,
  49                                      weekday: weekday ?? self.weekday,
  50                                      equipmentType: equipmentType ?? self.equipmentType,
  51                                      targetEquipment: targetEquipment ?? self.targetEquipment,
  52                                      remodelEquipment: remodelEquipment ?? self.remodelEquipment,
  53                                      requiredEquipments: requiredEquipments ?? self.requiredEquipments,
  54                                      secondsShipNames: secondsShipNames ?? self.secondsShipNames)
  55     }
  56
  57     struct CodeKey {
  58
  59         static let identifier = "EnhancementListItemIdentifier"
  60         static let weekday = "weekday"
  61         static let equipmentType = "equipmentType"
  62         static let targetEquipment = "targetEquipment"
  63         static let remodelEquipment = "remodelEquipment"
  64         static let requiredEquipments = "requiredEquipments"
  65         static let secondsShipNames = "secondsShipNames"
  66     }
  67
  68     required convenience init?(coder aDecoder: NSCoder) {
  69
  70         guard let i = aDecoder.decodeObject(forKey: CodeKey.identifier) as? String,
  71             let e = EquipmentType(rawValue: aDecoder.decodeInteger(forKey: CodeKey.equipmentType)),
  72             let t = aDecoder.decodeObject(forKey: CodeKey.targetEquipment) as? String,
  73             let req = aDecoder.decodeObject(forKey: CodeKey.requiredEquipments) as? RequiredEquipmentSet,
  74             let s = aDecoder.decodeObject(forKey: CodeKey.secondsShipNames) as? [String] else {
  75
  76                 Logger.shared.log("Can not decode EnhancementListItem")
  77
  78                 return nil
  79         }
  80
  81         let w = aDecoder.decodeInteger(forKey: CodeKey.weekday)
  82         let rem = aDecoder.decodeObject(forKey: CodeKey.remodelEquipment) as? String
  83
  84         self.init(identifier: i,
  85                   weekday: w,
  86                   equipmentType: e,
  87                   targetEquipment: t,
  88                   remodelEquipment: rem,
  89                   requiredEquipments: req,
  90                   secondsShipNames: s)
  91     }
  92
  93     func encode(with aCoder: NSCoder) {
  94
  95         aCoder.encode(identifier, forKey: CodeKey.identifier)
  96         aCoder.encode(weekday, forKey: CodeKey.weekday)
  97         aCoder.encode(equipmentType.rawValue, forKey: CodeKey.equipmentType)
  98         aCoder.encode(targetEquipment, forKey: CodeKey.targetEquipment)
  99         aCoder.encode(remodelEquipment, forKey: CodeKey.remodelEquipment)
 100         aCoder.encode(requiredEquipments, forKey: CodeKey.requiredEquipments)
 101         aCoder.encode(secondsShipNames, forKey: CodeKey.secondsShipNames)
 102     }
 103
 104     func copy(with zone: NSZone? = nil) -> Any {
 105
 106         return EnhancementListItem(identifier: identifier,
 107                                    weekday: weekday,
 108                                    equipmentType: equipmentType,
 109                                    targetEquipment: targetEquipment,
 110                                    remodelEquipment: remodelEquipment,
 111                                    requiredEquipments: requiredEquipments,
 112                                    secondsShipNames: secondsShipNames)
 113     }
 114 }
 115
 116 final class RequiredEquipmentSet: NSObject, NSCoding, NSCopying {
 117
 118     let identifier: String
 119     let requiredEquipments: [RequiredEquipment]
 120
 121     init(identifier: String, requiredEquipments: [RequiredEquipment]) {
 122
 123         self.identifier = identifier
 124         self.requiredEquipments = requiredEquipments
 125
 126         super.init()
 127     }
 128
 129     struct CodeKey {
 130
 131         static let identifier = "RequiredEquipmentSetIdentifier"
 132         static let requiredEquipments = "requiredEquipments"
 133     }
 134
 135     required convenience init?(coder aDecoder: NSCoder) {
 136
 137         guard let i = aDecoder.decodeObject(forKey: CodeKey.identifier) as? String,
 138             let r = aDecoder.decodeObject(forKey: CodeKey.requiredEquipments) as? [RequiredEquipment] else {
 139
 140                 Logger.shared.log("Can not decode RequiredEquipmentSet")
 141
 142                 return nil
 143         }
 144
 145         self.init(identifier: i, requiredEquipments: r)
 146     }
 147
 148     func encode(with aCoder: NSCoder) {
 149
 150         aCoder.encode(identifier, forKey: CodeKey.identifier)
 151         aCoder.encode(requiredEquipments, forKey: CodeKey.requiredEquipments)
 152     }
 153
 154     func copy(with zone: NSZone? = nil) -> Any {
 155
 156         return RequiredEquipmentSet(identifier: identifier,
 157                                     requiredEquipments: requiredEquipments)
 158     }
 159 }
 160
 161 final class RequiredEquipment: NSObject, NSCoding, NSCopying {
 162
 163     let identifier: String
 164     let currentLevelString: String
 165     @objc let name: String
 166     let number: Int
 167     let screw: Int
 168     let ensureScrew: Int
 169
 170     init(identifier: String, levelRange: String, name: String, number: Int, screw: Int, ensureScrew: Int) {
 171
 172         self.identifier = identifier
 173         self.currentLevelString = levelRange
 174         self.name = name
 175         self.number = number
 176         self.screw = screw
 177         self.ensureScrew = ensureScrew
 178
 179         super.init()
 180     }
 181
 182     // MARK: - NSCoding, NSCopying
 183     struct CodeKey {
 184
 185         static let identifier = "RequiredEquipmentIdentifier"
 186         static let currentLevelString = "currentLevelString"
 187         static let name = "name"
 188         static let number = "number"
 189         static let screw = "screw"
 190         static let ensureScrew = "ensureScrew"
 191     }
 192
 193     required convenience init?(coder aDecoder: NSCoder) {
 194
 195         guard let i = aDecoder.decodeObject(forKey: CodeKey.identifier) as? String,
 196             let c = aDecoder.decodeObject(forKey: CodeKey.currentLevelString) as? String,
 197             let na = aDecoder.decodeObject(forKey: CodeKey.name) as? String else {
 198
 199                 Logger.shared.log("Can not decode RequiredEquipment")
 200
 201                 return nil
 202         }
 203
 204         let nu = aDecoder.decodeInteger(forKey: CodeKey.number)
 205         let s = aDecoder.decodeInteger(forKey: CodeKey.screw)
 206         let e = aDecoder.decodeInteger(forKey: CodeKey.ensureScrew)
 207
 208         self.init(identifier: i, levelRange: c, name: na, number: nu, screw: s, ensureScrew: e)
 209     }
 210
 211     func encode(with aCoder: NSCoder) {
 212
 213         aCoder.encode(identifier, forKey: CodeKey.identifier)
 214         aCoder.encode(currentLevelString, forKey: CodeKey.currentLevelString)
 215         aCoder.encode(name, forKey: CodeKey.name)
 216         aCoder.encode(number, forKey: CodeKey.number)
 217         aCoder.encode(screw, forKey: CodeKey.screw)
 218         aCoder.encode(ensureScrew, forKey: CodeKey.ensureScrew)
 219     }
 220
 221     func copy(with zone: NSZone? = nil) -> Any {
 222
 223         return RequiredEquipment(identifier: identifier,
 224                                  levelRange: currentLevelString,
 225                                  name: name,
 226                                  number: number,
 227                                  screw: screw,
 228                                  ensureScrew: ensureScrew)
 229     }
 230 }
 231
 232 extension RequiredEquipment {
 233
 234     @objc dynamic var numberString: String? {
 235
 236         if number == 0 {
 237
 238             return nil
 239         }
 240         if number == -1 {
 241
 242             return "-"
 243         }
 244
 245         return "\(number)"
 246     }
 247 }