KCDTests/CombinedBattleTest.swift

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