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