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