KCDTests/NormalBattleTest.swift

   1 //
   2 //  NormalBattleTest.swift
   3 //  KCDTests
   4 //
   5 //  Created by Hori,Masaki on 2017/10/19.
   6 //  Copyright © 2017年 Hori,Masaki. All rights reserved.
   7 //
   8
   9 import XCTest
  10
  11 @testable import KCD
  12
  13 import SwiftyJSON
  14 import Doutaku
  15
  16 class NormalBattleTest: XCTestCase {
  17
  18     var savedShips: [Ship] = []
  19     var shipsHp: [Int] = []
  20     var shipEquipments: [NSOrderedSet] = []
  21     var shipExSlot: [Int] = []
  22
  23     func initBattleFleet(_ fleet: Int, seventh: Bool = false) {
  24
  25         savedShips = []
  26         shipsHp = []
  27         shipEquipments = []
  28         shipExSlot = []
  29
  30         // 艦隊を設定
  31         do {
  32
  33             let store = ServerDataStore.oneTimeEditor()
  34
  35             guard let deck = store.deck(by: fleet) else {
  36
  37                 XCTFail("Can not get Deck.")
  38
  39                 return
  40             }
  41
  42             let max = seventh ? 6 : 5
  43             (0...6).forEach { deck.setShip(id: -1, for: $0) }
  44             (0...max).forEach { deck.setShip(id: $0 + 1, for: $0) }
  45
  46             store.ships(byDeckId: fleet).forEach {
  47                 $0.nowhp = $0.maxhp
  48
  49                 savedShips += [$0]
  50                 shipsHp += [$0.nowhp]
  51                 shipEquipments += [$0.equippedItem]
  52                 shipExSlot += [$0.slot_ex]
  53             }
  54         }
  55
  56         // 出撃艦隊を設定
  57         do {
  58
  59             let rawValue: [String: Any] = [
  60                 "api_result": 1,
  61                 "api_data": [
  62                     "api_no": 1
  63                 ]
  64             ]
  65             guard let json = JSON(rawValue: rawValue) else {
  66
  67                 XCTFail("json is nil")
  68
  69                 return
  70             }
  71             XCTAssertNotNil(json["api_result"])
  72
  73             let paramValue: [String: String] = [
  74                 "api_deck_id": "\(fleet)",
  75                 "api_maparea_id": "1",
  76                 "api_mapinfo_no": "1"
  77             ]
  78             let param = Parameter(paramValue)
  79             XCTAssertEqual(param["api_deck_id"].string, "\(fleet)")
  80
  81             let api = APIResponse(api: API(endpointPath: Endpoint.start.rawValue), parameter: param, json: json)
  82             XCTAssertEqual(api.json, json)
  83             XCTAssertEqual(api.parameter, param)
  84
  85             let command = MapStartCommand(apiResponse: api)
  86
  87             command.execute()
  88         }
  89
  90         // battleの生成確認
  91         do {
  92
  93             let store = TemporaryDataStore.default
  94             let battle = store.battle()
  95             XCTAssertNotNil(battle)
  96             XCTAssertEqual(battle?.deckId, fleet)
  97         }
  98     }
  99
 100     func clear(_ fleet: Int) {
 101
 102         do {
 103
 104             ResetSortie().reset()
 105         }
 106
 107         do {
 108
 109             let store = ServerDataStore.oneTimeEditor()
 110
 111             let ships = store.ships(byDeckId: fleet)
 112
 113             zip(ships, shipsHp).forEach { $0.nowhp = $1 }
 114             zip(ships, shipEquipments).forEach { $0.equippedItem = $1 }
 115             zip(ships, shipExSlot).forEach { $0.slot_ex = $1 }
 116
 117             guard let deck = store.deck(by: fleet) else {
 118
 119                 XCTFail("Can not get Deck.")
 120
 121                 return
 122             }
 123             savedShips.enumerated().forEach { deck.setShip(id: $0.element.id, for: $0.offset) }
 124             (0...6).forEach { deck.setShip(id: -1, for: $0) }
 125         }
 126
 127         do {
 128
 129             let store = TemporaryDataStore.default
 130             let battle = store.battle()
 131             XCTAssertNil(battle)
 132         }
 133     }
 134
 135     func normalBattle(_ fleet: Int, seventh: Bool = false) {
 136
 137         // 戦闘（昼戦）
 138         do {
 139
 140             let dfList = seventh ? [[2, 2], [6, 6]] : [[2, 2]]
 141             let damages = seventh ? [[0, 3], [0, 7]] : [[0, 3]]
 142             let fdam = seventh ? [0, 0, 0, 4, 0, 6, 7] : [0, 0, 0, 4, 0, 6]
 143             let rawValue: [String: Any] = [
 144                 "api_result": 1,
 145                 "api_data": [
 146                     "api_kouku": [
 147                         "api_stage3": [
 148                             "api_fdam": [
 149                                 1, 0, 0
 150                             ]
 151                         ]
 152                     ],
 153                     "api_opening_atack": [
 154                         "api_fdam": [
 155                             0, 2
 156                         ]
 157                     ],
 158                     "api_hougeki1": [
 159                         "api_df_list": dfList,
 160                         "api_damage": damages,
 161                         "api_at_eflag": [
 162                             1,
 163                             1
 164                         ]
 165                     ],
 166                     "api_raigeki": [
 167                         "api_fdam": fdam
 168                     ]
 169                 ]
 170             ]
 171             guard let json = JSON(rawValue: rawValue) else {
 172
 173                 XCTFail("json is nil")
 174
 175                 return
 176             }
 177             let param = Parameter(["Test": "Test"])
 178             let api = APIResponse(api: API(endpointPath: Endpoint.battle.rawValue), parameter: param, json: json)
 179
 180             let command = BattleCommand(apiResponse: api)
 181             command.execute()
 182         }
 183
 184         // 戦闘（夜戦）
 185         do {
 186
 187             let rawValue: [String: Any] = [
 188                 "api_result": 1,
 189                 "api_data": [
 190                     "api_hougeki": [
 191                         "api_df_list": [
 192                             [4],
 193                             [5]
 194                         ],
 195                         "api_damage": [
 196                             [5],
 197                             [7]
 198                         ],
 199                         "api_at_eflag": [
 200                             1,
 201                             1
 202                         ]
 203                     ]
 204                 ]
 205             ]
 206             guard let json = JSON(rawValue: rawValue) else {
 207
 208                 XCTFail("json is nil")
 209
 210                 return
 211             }
 212             let param = Parameter(["Test": "Test"])
 213             let api = APIResponse(api: API(endpointPath: Endpoint.midnightBattle.rawValue), parameter: param, json: json)
 214
 215             let command = BattleCommand(apiResponse: api)
 216             command.execute()
 217         }
 218
 219         // 艦娘HP更新
 220         do {
 221
 222             let rawValue: [String: Any] = [
 223                 "api_result": 1
 224             ]
 225             guard let json = JSON(rawValue: rawValue) else {
 226
 227                 XCTFail("json is nil")
 228
 229                 return
 230             }
 231             let param = Parameter(["Test": "Test"])
 232             let api = APIResponse(api: API(endpointPath: Endpoint.battleResult.rawValue), parameter: param, json: json)
 233
 234             let command = BattleCommand(apiResponse: api)
 235             command.execute()
 236         }
 237
 238         // HPチェック
 239         do {
 240
 241             let store = ServerDataStore.oneTimeEditor()
 242             let ships = store.ships(byDeckId: fleet)
 243
 244             XCTAssertEqual(ships.count, seventh ? 7 : 6)
 245
 246             XCTAssertEqual(ships[0].nowhp, shipsHp[0] - 1)
 247             XCTAssertEqual(ships[1].nowhp, shipsHp[1] - 2)
 248             XCTAssertEqual(ships[2].nowhp, shipsHp[2] - 3)
 249             XCTAssertEqual(ships[3].nowhp, shipsHp[3] - 4)
 250             XCTAssertEqual(ships[4].nowhp, shipsHp[4] - 5)
 251             XCTAssertEqual(ships[5].nowhp, shipsHp[5] - 6 - 7)
 252             if seventh {
 253                 XCTAssertEqual(ships[6].nowhp, shipsHp[6] - 7 - 7)
 254             }
 255         }
 256     }
 257
 258     func damageControl(_ fleet: Int) {
 259
 260         // ダメコンを設定
 261         do {
 262
 263             let store = ServerDataStore.oneTimeEditor()
 264
 265             store.ship(by: 4).flatMap {
 266                 $0.nowhp = $0.maxhp
 267                 $0.slot_ex = 63_765  // 女神
 268             }
 269             store.ship(by: 5).flatMap {
 270                 $0.nowhp = $0.maxhp
 271                 // ダメコン
 272                 $0.equippedItem = store.slotItem(by: 8_175).map { NSOrderedSet(array: [$0]) } ?? []
 273             }
 274         }
 275
 276         // 戦闘（夜戦）
 277         do {
 278
 279             let rawValue: [String: Any] = [
 280                 "api_result": 1,
 281                 "api_data": [
 282                     "api_hougeki": [
 283                         "api_df_list": [
 284                             [2],
 285                             [3],
 286                             [4],
 287                             [10]
 288                         ],
 289                         "api_damage": [
 290                             [50],
 291                             [50],
 292                             [50],
 293                             [20]
 294                         ],
 295                         "api_at_eflag": [
 296                             1,
 297                             1,
 298                             1,
 299                             0
 300                         ]
 301                     ]
 302                 ]
 303             ]
 304             guard let json = JSON(rawValue: rawValue) else {
 305
 306                 XCTFail("json is nil")
 307
 308                 return
 309             }
 310             let param = Parameter(["Test": "Test"])
 311             let api = APIResponse(api: API(endpointPath: Endpoint.midnightBattle.rawValue), parameter: param, json: json)
 312
 313             let command = BattleCommand(apiResponse: api)
 314             command.execute()
 315         }
 316
 317         // 艦娘HP更新
 318         do {
 319
 320             let rawValue: [String: Any] = [
 321                 "api_result": 1
 322             ]
 323             guard let json = JSON(rawValue: rawValue) else {
 324
 325                 XCTFail("json is nil")
 326
 327                 return
 328             }
 329             let param = Parameter(["Test": "Test"])
 330             let api = APIResponse(api: API(endpointPath: Endpoint.battleResult.rawValue), parameter: param, json: json)
 331
 332             let command = BattleCommand(apiResponse: api)
 333             command.execute()
 334         }
 335
 336         // HPチェック
 337         do {
 338
 339             let store = ServerDataStore.oneTimeEditor()
 340             let ships = store.ships(byDeckId: fleet)
 341
 342             XCTAssertEqual(ships.count, 6)
 343
 344             XCTAssertEqual(ships[0].nowhp, shipsHp[0])
 345             XCTAssertEqual(ships[1].nowhp, shipsHp[1])
 346             XCTAssertEqual(ships[2].nowhp, 0)
 347             XCTAssertEqual(ships[3].nowhp, shipsHp[3])
 348             XCTAssertEqual(ships[4].nowhp, Int(Double(shipsHp[4]) * 0.2))
 349         }
 350     }
 351
 352     func testFirstFleet() {
 353
 354         initBattleFleet(1)
 355         normalBattle(1)
 356         initBattleFleet(1)
 357         damageControl(1)
 358         clear(1)
 359     }
 360     func testSecondFleet() {
 361
 362         initBattleFleet(2)
 363         normalBattle(2)
 364         initBattleFleet(2)
 365         damageControl(2)
 366         clear(2)
 367     }
 368     func testThiredFleet() {
 369
 370         initBattleFleet(3)
 371         normalBattle(3)
 372         initBattleFleet(3)
 373         damageControl(3)
 374
 375         initBattleFleet(3, seventh: true)
 376         normalBattle(3, seventh: true)
 377         clear(3)
 378     }
 379     func testFourthFleet() {
 380
 381         initBattleFleet(4)
 382         normalBattle(4)
 383         initBattleFleet(4)
 384         damageControl(4)
 385         clear(4)
 386     }
 387 }