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 @objc
  12 enum EquipmentType: Int {
  13     case unknown = -1
  14
  15     case smallCaliberMainGun = 1
  16     case mediumCaliberMainGun = 2
  17     case largeCaliberMainGun = 3
  18     case secondaryGun = 4
  19     case torpedo = 5
  20     case fighter = 6
  21     case bomber = 7
  22     case attacker = 8
  23     case searcher = 9
  24     case airplaneSearcher = 10
  25     case airplaneBomber = 11
  26     case smallRadar = 12
  27     case largeRadar = 13
  28     case sonar = 14
  29     case depthCharge = 15
  30     case armorPiercingShell = 16
  31     case EngineImprovement = 17
  32     case AAShell = 18
  33     case APShell = 19
  34     case vt = 20
  35     case antiAircraftGun = 21
  36     case specialSubmarine = 22
  37     case damageControl = 23
  38     case LandingCraft = 24
  39     case autoGyro = 25
  40     case antiSunmrinerSercher = 26
  41     case armorPiercingShellMiddle = 27
  42     case armorPiercingShellLarge = 28
  43     case searchlight = 29
  44     case caryer = 30
  45     case repiarer = 31
  46     case submarinTorpedo = 32
  47     case chaf = 33
  48     case headquaters = 34
  49     case pilot = 35
  50     case antiAircraftSystem = 36
  51     case antiLandSystem = 37
  52     case largeCaliberMainGunII = 38
  53     case shipPersonnel = 39
  54     case largeSonar = 40
  55     case largeAirplane = 41
  56     case largeSearchlight = 42
  57     case onigiri = 43
  58     case supply = 44
  59     case airplaneFighter = 45
  60     case tankShip = 46
  61     case landAttecker = 47
  62     case localFighter = 48
  63
  64     case blank01 = 49
  65     case TransportationMaterial = 50
  66     case SubmarineEquipment = 51
  67     case blank04 = 52
  68     case blank05 = 53
  69     case blank06 = 54
  70     case blank07 = 55
  71
  72     case jetFighter = 56
  73     case jetBomber = 57
  74     case jetAttacker = 58
  75     case jetSearcher = 59
  76
  77     case blank08 = 60
  78     case blank09 = 61
  79     case blank10 = 62
  80     case blank11 = 63
  81     case blank12 = 64
  82
  83     case largeLadarII = 93
  84     case searcherII = 94
  85
  86     case blank13 = 95
  87     case blank14 = 96
  88     case blank15 = 97
  89     case blank16 = 98
  90     case blank17 = 99
  91     case blank18 = 100
  92 }
  93
  94 class EnhancementListItem: NSObject, NSCoding, NSCopying {
  95     let identifier: String
  96     let weekday: Int
  97     let equipmentType: EquipmentType
  98     let targetEquipment: String
  99     let remodelEquipment: String?
 100     let requiredEquipments: RequiredEquipmentSet
 101     let secondsShipNames: [String]
 102
 103     init(identifier: String,
 104          weekday: Int,
 105          equipmentType: EquipmentType,
 106          targetEquipment: String,
 107          remodelEquipment: String?,
 108          requiredEquipments: RequiredEquipmentSet,
 109          secondsShipNames: [String]) {
 110         self.identifier = identifier
 111         self.weekday = weekday
 112         self.equipmentType = equipmentType
 113         self.targetEquipment = targetEquipment
 114         self.remodelEquipment = remodelEquipment
 115         self.requiredEquipments = requiredEquipments
 116         self.secondsShipNames = secondsShipNames
 117         super.init()
 118     }
 119     func replace(identifier: String? = nil,
 120                  weekday: Int? = nil,
 121                  equipmentType: EquipmentType? = nil,
 122                  targetEquipment: String? = nil,
 123                  remodelEquipment: String? = nil,
 124                  requiredEquipments: RequiredEquipmentSet? = nil,
 125                  secondsShipNames: [String]? = nil) -> EnhancementListItem {
 126         return EnhancementListItem(identifier: identifier ?? self.identifier,
 127                                      weekday: weekday ?? self.weekday,
 128                                      equipmentType: equipmentType ?? self.equipmentType,
 129                                      targetEquipment: targetEquipment ?? self.targetEquipment,
 130                                      remodelEquipment: remodelEquipment ?? self.remodelEquipment,
 131                                      requiredEquipments: requiredEquipments ?? self.requiredEquipments,
 132                                      secondsShipNames: secondsShipNames ?? self.secondsShipNames)
 133     }
 134
 135     struct CodeKey {
 136         static let identifier = "EnhancementListItemIdentifier"
 137         static let weekday = "weekday"
 138         static let equipmentType = "equipmentType"
 139         static let targetEquipment = "targetEquipment"
 140         static let remodelEquipment = "remodelEquipment"
 141         static let requiredEquipments = "requiredEquipments"
 142         static let secondsShipNames = "secondsShipNames"
 143     }
 144     required convenience init?(coder aDecoder: NSCoder) {
 145         guard let i = aDecoder.decodeObject(forKey: CodeKey.identifier) as? String,
 146             let e = EquipmentType(rawValue: aDecoder.decodeInteger(forKey: CodeKey.equipmentType)),
 147             let t = aDecoder.decodeObject(forKey: CodeKey.targetEquipment) as? String,
 148             let req = aDecoder.decodeObject(forKey: CodeKey.requiredEquipments) as? RequiredEquipmentSet,
 149             let s = aDecoder.decodeObject(forKey: CodeKey.secondsShipNames) as? [String]
 150             else { print("Can not decode EnhancementListItem"); return nil }
 151         let w = aDecoder.decodeInteger(forKey: CodeKey.weekday)
 152         let rem = aDecoder.decodeObject(forKey: CodeKey.remodelEquipment) as? String
 153         self.init(identifier: i,
 154                   weekday: w,
 155                   equipmentType: e,
 156                   targetEquipment: t,
 157                   remodelEquipment: rem,
 158                   requiredEquipments: req,
 159                   secondsShipNames: s)
 160     }
 161     func encode(with aCoder: NSCoder) {
 162         aCoder.encode(identifier, forKey: CodeKey.identifier)
 163         aCoder.encode(weekday, forKey: CodeKey.weekday)
 164         aCoder.encode(equipmentType.rawValue, forKey: CodeKey.equipmentType)
 165         aCoder.encode(targetEquipment, forKey: CodeKey.targetEquipment)
 166         aCoder.encode(remodelEquipment, forKey: CodeKey.remodelEquipment)
 167         aCoder.encode(requiredEquipments, forKey: CodeKey.requiredEquipments)
 168         aCoder.encode(secondsShipNames, forKey: CodeKey.secondsShipNames)
 169     }
 170     func copy(with zone: NSZone? = nil) -> Any {
 171         return EnhancementListItem(identifier: identifier,
 172                                    weekday: weekday,
 173                                    equipmentType: equipmentType,
 174                                    targetEquipment: targetEquipment,
 175                                    remodelEquipment: remodelEquipment,
 176                                    requiredEquipments: requiredEquipments,
 177                                    secondsShipNames: secondsShipNames)
 178     }
 179 }
 180
 181 class RequiredEquipmentSet: NSObject, NSCoding, NSCopying {
 182     let identifier: String
 183     let requiredEquipments: [RequiredEquipment]
 184
 185     init(identifier: String, requiredEquipments: [RequiredEquipment]) {
 186         self.identifier = identifier
 187         self.requiredEquipments = requiredEquipments
 188         super.init()
 189     }
 190
 191     struct CodeKey {
 192         static let identifier = "RequiredEquipmentSetIdentifier"
 193         static let requiredEquipments = "requiredEquipments"
 194     }
 195     required convenience init?(coder aDecoder: NSCoder) {
 196         guard let i = aDecoder.decodeObject(forKey: CodeKey.identifier) as? String,
 197             let r = aDecoder.decodeObject(forKey: CodeKey.requiredEquipments) as? [RequiredEquipment]
 198             else { print("Can not decode RequiredEquipmentSet"); return nil }
 199         self.init(identifier: i, requiredEquipments: r)
 200     }
 201     func encode(with aCoder: NSCoder) {
 202         aCoder.encode(identifier, forKey: CodeKey.identifier)
 203         aCoder.encode(requiredEquipments, forKey: CodeKey.requiredEquipments)
 204     }
 205     func copy(with zone: NSZone? = nil) -> Any {
 206         return RequiredEquipmentSet(identifier: identifier,
 207                                     requiredEquipments: requiredEquipments)
 208     }
 209 }
 210
 211 class RequiredEquipment: NSObject, NSCoding, NSCopying {
 212     let identifier: String
 213     let currentLevelString: String
 214     let name: String
 215     let number: Int
 216     let screw: Int
 217     let ensureScrew: Int
 218
 219     init(identifier: String, levelRange: String, name: String, number: Int, screw: Int, ensureScrew: Int) {
 220         self.identifier = identifier
 221         self.currentLevelString = levelRange
 222         self.name = name
 223         self.number = number
 224         self.screw = screw
 225         self.ensureScrew = ensureScrew
 226         super.init()
 227     }
 228
 229     // MARK: - NSCoding, NSCopying
 230     struct CodeKey {
 231         static let identifier = "RequiredEquipmentIdentifier"
 232         static let currentLevelString = "currentLevelString"
 233         static let name = "name"
 234         static let number = "number"
 235         static let screw = "screw"
 236         static let ensureScrew = "ensureScrew"
 237     }
 238     required convenience init?(coder aDecoder: NSCoder) {
 239         guard let i = aDecoder.decodeObject(forKey: CodeKey.identifier) as? String,
 240         let c = aDecoder.decodeObject(forKey: CodeKey.currentLevelString) as? String,
 241         let na = aDecoder.decodeObject(forKey: CodeKey.name) as? String
 242             else { print("Can not decode RequiredEquipment"); return nil }
 243         let nu = aDecoder.decodeInteger(forKey: CodeKey.number)
 244         let s = aDecoder.decodeInteger(forKey: CodeKey.screw)
 245         let e = aDecoder.decodeInteger(forKey: CodeKey.ensureScrew)
 246         self.init(identifier: i, levelRange: c, name: na, number: nu, screw: s, ensureScrew: e)
 247     }
 248     func encode(with aCoder: NSCoder) {
 249         aCoder.encode(identifier, forKey: CodeKey.identifier)
 250         aCoder.encode(currentLevelString, forKey: CodeKey.currentLevelString)
 251         aCoder.encode(name, forKey: CodeKey.name)
 252         aCoder.encode(number, forKey: CodeKey.number)
 253         aCoder.encode(screw, forKey: CodeKey.screw)
 254         aCoder.encode(ensureScrew, forKey: CodeKey.ensureScrew)
 255     }
 256     func copy(with zone: NSZone? = nil) -> Any {
 257         return RequiredEquipment(identifier: identifier,
 258                                  levelRange: currentLevelString,
 259                                  name: name,
 260                                  number: number,
 261                                  screw: screw,
 262                                  ensureScrew: ensureScrew)
 263     }
 264 }
 265
 266 extension RequiredEquipment {
 267     dynamic var numberString: String? {
 268         if number == 0 { return nil }
 269         if number == -1 { return "-" }
 270         return "\(number)"
 271     }
 272 }