}
private func shipTypeId(shipId: Int) -> Int? {
return ServerDataStore.default
- .ship(byId: shipId)?.master_ship.stype.id
+ .ship(by: shipId)?.master_ship.stype.id
}
private func needsReset(info: HenseiDidChangeUserInfo) -> Bool {
// 変更のあった艦隊の旗艦は工作艦か?
data["api_ship"]
.forEach { (_, json) in
guard let i = json["api_id"].int,
- let ship = store.ship(byId: i),
+ let ship = store.ship(by: i),
let bull = json["api_bull"].int,
let fuel = json["api_fuel"].int,
let slots = json["api_onslot"].arrayObject as? [Int],
}
override func transformedValue(_ value: Any?) -> Any? {
guard let id = value as? Int else { return nil }
- return ServerDataStore.default.mapArea(byId: id)?.name
+ return ServerDataStore.default.mapArea(by: id)?.name
}
}
}
var flagShipID: Int = 0
var flagShipName: String? {
- return ServerDataStore.default.ship(byId: flagShipID)?.name
+ return ServerDataStore.default.ship(by: flagShipID)?.name
}
var changeMainTabHandler: ((Int) -> Void)?
dynamic var selectedMainTabIndex: Int = 0 {
else { return print("Damages count is invalid. count is \(totalDamages.count).") }
let aStore = ServerDataStore.oneTimeEditor()
totalDamages.forEach {
- guard let ship = aStore.ship(byId: $0.shipID)
+ guard let ship = aStore.ship(by: $0.shipID)
else { return }
if ship.nowhp != $0.hp {
var newHP = (hp as Int) - receicve
if newHP <= 0 {
let shipId = damage.shipID
- if let ship = ServerDataStore.default.ship(byId: shipId) {
+ if let ship = ServerDataStore.default.ship(by: shipId) {
let efectiveHP = damageControlIfPossible(nowhp: newHP, ship: ship)
if efectiveHP != 0, efectiveHP != newHP {
damage.useDamageControl = true
ship.equippedItem.forEach {
if useDamageControl { return }
guard let master = $0 as? SlotItem else { return }
- let masterSlotItemId = store.masterSlotItemID(bySlotItemId: master.id)
+ let masterSlotItemId = store.masterSlotItemID(by: master.id)
guard let type = DamageControlID(rawValue: masterSlotItemId)
else { return }
switch type {
}
if useDamageControl { return nowHp }
// check extra slot
- let exItemId = store.masterSlotItemID(bySlotItemId: ship.slot_ex)
+ let exItemId = store.masterSlotItemID(by: ship.slot_ex)
guard let exType = DamageControlID(rawValue: exItemId)
else { return nowHp }
switch exType {
equiped.forEach {
if useDamageControl { return }
guard let master = $0 as? SlotItem else { return }
- let masterSlotItemId = store.masterSlotItemID(bySlotItemId: master.id)
+ let masterSlotItemId = store.masterSlotItemID(by: master.id)
guard let type = DamageControlID(rawValue: masterSlotItemId)
else { return }
switch type {
}
if useDamageControl { return }
// check extra slot
- let exItemId = store.masterSlotItemID(bySlotItemId: ship.slot_ex)
+ let exItemId = store.masterSlotItemID(by: ship.slot_ex)
guard let exType = DamageControlID(rawValue: exItemId)
else { return }
switch exType {
private func excludeShipsWithoutFlagShip(deckNumber: Int) {
let store = ServerDataStore.oneTimeEditor()
- guard let deck = store.deck(byId: deckNumber)
+ guard let deck = store.deck(by: deckNumber)
else { return print("Deck not found") }
(1..<6).forEach { deck.setShip(id: -1, for: $0) }
}
guard let dockId = parameter["api_kdock_id"].int
else { return print("api_kdock_id is wrong") }
let store = ServerDataStore.default
- guard let kenzoDock = store.kenzoDock(byDockId: dockId),
- let flagShip = store.deck(byId: 1)
- .flatMap({ store.ship(byId: $0.ship_0) }),
+ guard let kenzoDock = store.kenzoDock(by: dockId),
+ let flagShip = store.deck(by: 1)
+ .flatMap({ store.ship(by: $0.ship_0) }),
let basic = store.basic()
else { return print("CreateShipCommand: CoreData is wrong") }
}
var fleetName: String? {
guard let deckId = battleContoller.value(forKeyPath: "content.deckId") as? Int else { return nil }
- return ServerDataStore.default.deck(byId: deckId)?.name
+ return ServerDataStore.default.deck(by: deckId)?.name
}
var areaNumber: String? {
let mapArea: String = {
let store = ServerDataStore.default
guard let mapInfo = store.mapInfo(area: mapAreaId, no: battle.mapInfo)
else { return print("KCMasterMapInfo is not found") }
- guard let mapArea = store.mapArea(byId: mapAreaId)
+ guard let mapArea = store.mapArea(by: mapAreaId)
else { return print("KCMasterMapArea is not found") }
let localStore = LocalDataStore.oneTimeEditor()
}
private func removeDummy() {
let store = ServerDataStore.oneTimeEditor()
- store.ships(byId: -2).forEach { store.delete($0) }
+ store.ships(by: -2).forEach { store.delete($0) }
DummyShipCommand.needsEnterDummy = false
}
}
// set
fleets.enumerated().forEach { (index, fleet) in
fleet.ships.forEach {
- store.ship(byId: $0.id)?.fleet = (index + 1) as NSNumber
+ store.ship(by: $0.id)?.fleet = (index + 1) as NSNumber
}
}
}
dynamic var fleetNumber: Int = 1 {
didSet {
ServerDataStore.default
- .deck(byId: fleetNumber)
+ .deck(by: fleetNumber)
.map { fleet = $0 }
}
}
}
private func fleetMembers(fleetId: Int) -> [Int]? {
- guard let deck = ServerDataStore.default.deck(byId: fleetId)
+ guard let deck = ServerDataStore.default.deck(by: fleetId)
else { return nil }
return [deck.ship_0, deck.ship_1, deck.ship_2,
deck.ship_3, deck.ship_4, deck.ship_5]
guard let locked = data["api_locked"].int
else { return print("api_locked is wrong") }
let store = ServerDataStore.oneTimeEditor()
- store.slotItem(byId: slotId)?.locked = locked != 0
+ store.slotItem(by: slotId)?.locked = locked != 0
}
}
else { return print("api_kdock_id is wrong") }
let store = ServerDataStore.default
- guard let kenzoDock = store.kenzoDock(byDockId: kdockId)
+ guard let kenzoDock = store.kenzoDock(by: kdockId)
else { return print("KenzoDock is not fount") }
let fuel = kenzoDock.item1
let bull = kenzoDock.item2
let kaihatu = kenzoDock.item5
let shipId = kenzoDock.created_ship_id
- guard let flagShip = store.masterShip(byId: shipId)
+ guard let flagShip = store.masterShip(by: shipId)
else { return print("MasterShip is not found") }
let localStore = LocalDataStore.oneTimeEditor()
guard let shipId = shipId as? Int,
shipId != 0
else { return }
- guard let ship = ServerDataStore.default.ship(byId: shipId)
+ guard let ship = ServerDataStore.default.ship(by: shipId)
else {
name = "Unknown"
DispatchQueue(label: "NyukyoDockStatus")
.flatMap { store.nyukyoDock(by: $0) }
nDock
.flatMap { $0.ship_id }
- .flatMap { store.ship(byId: $0) }
+ .flatMap { store.ship(by: $0) }
.map { $0.nowhp = $0.maxhp }
nDock?.ship_id = 0
nDock?.state = 0
let store = ServerDataStore.oneTimeEditor()
parameter["api_ship_id"]
.int
- .flatMap { store.ship(byId: $0) }
+ .flatMap { store.ship(by: $0) }
.map { $0.nowhp = $0.maxhp }
store.material()
let store = ServerDataStore.oneTimeEditor()
parameter["api_ship_id"]
.int
- .flatMap { store.ship(byId: $0) }
+ .flatMap { store.ship(by: $0) }
.flatMap { store.delete($0) }
}
}
.string?
.components(separatedBy: ",")
.flatMap { Int($0) }
- .flatMap { store.ship(byId: $0) }
+ .flatMap { store.ship(by: $0) }
.forEach { store.delete($0) }
}
}
let afterSlot = data["api_after_slot"]
let store = ServerDataStore.oneTimeEditor()
- guard let slotItem = store.slotItem(byId: slotItemId)
+ guard let slotItem = store.slotItem(by: slotItemId)
else { return print("SlotItem not found") }
if let locked = afterSlot["api_locked"].int {
else { return [] }
return decks
}
- func deck(byId id: Int) -> Deck? {
+ func deck(by id: Int) -> Deck? {
let p = NSPredicate(format: "id = %ld", id)
guard let decks = try? objects(with: Deck.entity, predicate: p)
else { return nil }
return decks.first
}
- func kenzoDock(byDockId dockId: Int) -> KenzoDock? {
+ func kenzoDock(by dockId: Int) -> KenzoDock? {
let dockPredicate = NSPredicate(format: "id = %ld", dockId)
guard let kenzoDocks = try? objects(with: KenzoDock.entity, predicate: dockPredicate)
else { return nil }
return kenzoDocks.first
}
- func mapArea(byId id: Int) -> MasterMapArea? {
+ func mapArea(by id: Int) -> MasterMapArea? {
let predicate = NSPredicate(format: "id = %ld", id)
guard let mapAreas = try? objects(with: MasterMapArea.entity, predicate: predicate)
else { return nil }
else { return [] }
return ships
}
- func masterShip(byId id: Int) -> MasterShip? {
+ func masterShip(by id: Int) -> MasterShip? {
let p = NSPredicate(format: "id = %ld", id)
guard let ships = try? objects(with: MasterShip.entity, predicate: p)
else { return nil }
else { return [] }
return (0..<6).flatMap { deck[$0] }
}
- func ship(byId shipId: Int) -> Ship? {
+ func ship(by shipId: Int) -> Ship? {
if shipId < 1 { return nil }
let predicate = NSPredicate(format: "id = %d", shipId)
guard let ships = try? objects(with: Ship.entity, predicate: predicate)
else { return nil }
return ships.first
}
- func ships(byId shipId: Int) -> [Ship] {
+ func ships(by shipId: Int) -> [Ship] {
let predicate = NSPredicate(format: "id = %d", shipId)
guard let ships = try? objects(with: Ship.entity, predicate: predicate)
else { return [] }
return insertNewObject(for: Ship.entity)
}
- func masterSlotItemID(bySlotItemId slotItemId: Int) -> Int {
+ func masterSlotItemID(by slotItemId: Int) -> Int {
if slotItemId < 1 { return 0 }
let predicate = NSPredicate(format: "id = %d", argumentArray: [slotItemId])
guard let slotItems = try? objects(with: SlotItem.entity, predicate: predicate),
return slotItem.master_slotItem.id
}
- func slotItem(byId itemId: Int) -> SlotItem? {
+ func slotItem(by itemId: Int) -> SlotItem? {
let p = NSPredicate(format: "id = %ld", itemId)
guard let slotItems = try? objects(with: SlotItem.entity, predicate: p)
else { return nil }
}
private func slotItem(_ index: Int) -> SlotItem? {
- return ServerDataStore.default.slotItem(byId: slotItemId(index))
+ return ServerDataStore.default.slotItem(by: slotItemId(index))
}
private func typeBonus(_ type: Int) -> [Double]? {
switch type {
window?.endEditing(for: nil)
let store = ServerDataStore.oneTimeEditor()
- guard let deck = store.deck(byId: missionFleetNumber),
+ guard let deck = store.deck(by: missionFleetNumber),
let t = missionTime as? Double
else { return }
let time = Date(timeIntervalSinceNow: t).timeIntervalSince1970 * 1_000
didSet {
slotItemController.content = nil
guard let itemId = slotItemID as? Int else { return }
- slotItemController.content = ServerDataStore.default.slotItem(byId: itemId)
+ slotItemController.content = ServerDataStore.default.slotItem(by: itemId)
needsDisplay = true
}
}
}
override func transformedValue(_ value: Any?) -> Any? {
guard let id = value as? Int, id != 0, id != -1 else { return nil }
- guard let item = ServerDataStore.default.slotItem(byId: id)
+ guard let item = ServerDataStore.default.slotItem(by: id)
else { return nil }
let itemId = item.master_slotItem.id
return SlotItemShortNameTransformer.slotItemShortName[itemId] ?? item.name
let store = ServerDataStore.oneTimeEditor()
guard let ship = parameter["api_id"]
.int
- .flatMap({ store.ship(byId: $0) })
+ .flatMap({ store.ship(by: $0) })
else { return print("api_id is wrong") }
guard let slotItems = data["api_slot"].arrayObject as? [Int]
else { return print("Can not parse api_data.api_slot") }
}
override func transformedValue(_ value: Any?) -> Any? {
guard let id = value as? Int, id != 0, id != -1 else { return nil }
- return ServerDataStore.default.slotItem(byId: id)?.name
+ return ServerDataStore.default.slotItem(by: id)?.name
}
}
let numberOfUsedKaihatuSizai = success != 0 ? 1 : 0
let store = ServerDataStore.default
- guard let flagShip = store.deck(byId: 1)
+ guard let flagShip = store.deck(by: 1)
.map({ $0.ship_0 })
- .flatMap({ store.ship(byId: $0) })
+ .flatMap({ store.ship(by: $0) })
else { return print("Flagship is not found") }
guard let basic = store.basic()