extern crate web_wars_engine;

use web_wars_engine::combat;

#[test]
pub fn charge_bar_value() {
  assert_eq!(9000, combat::charge_bar_value(0));
  assert_eq!(10800, combat::charge_bar_value(1));
  assert_eq!(12600, combat::charge_bar_value(2));
  assert_eq!(27000, combat::charge_bar_value(10));
  assert_eq!(27000, combat::charge_bar_value(11));
}

// defmodule WebWars.CombatResultTest {
//   @moduledoc false

//   use WebWars.DataCase
//   alias WebWars.Engine.{
//     Ability,
//     AbilityData,
//     CombatData,
//     CombatResult,
//     Coord,
//     Tile,
//     TileData,
//     UnitData,
//     UserData,
//     Weapon,
//   }
//   alias Data.AWDS

//   fn unit_data(unit, attrs \\ %{}) {
//     UnitData
//     |> Kernel.struct(
//       Map.merge(%{unit: unit, weapon_data: unit.weapon_data}, attrs)
//     )
//   }

//   fn user_data(commander, attrs \\ %{}) {
//     UserData
//     |> Kernel.struct(
//       Map.merge(%{commander: commander, power_data: commander.passive}, attrs)
//     )
//   }

//   fn tile_data(tile) {
//     TileData {
//       tile_id: tile.id,
//       tile: tile
//     }
//   }

//   describe "calculate/1" {
//     setup {
//       data = %{
//         infantry: unit_data(AWDS.infantry),
//         mech: unit_data(AWDS.mech),
//         tank: unit_data(AWDS.tank),
//         artillery: unit_data(AWDS.artillery),
//         rocket: unit_data(AWDS.rocket),
//         apc: unit_data(AWDS.apc),
//         sub: unit_data(AWDS.sub),
//         cruiser: unit_data(AWDS.cruiser),
//         bomber: unit_data(AWDS.bomber),
//         antiair: unit_data(AWDS.antiair),
//         megatank: unit_data(AWDS.megatank),
//         battleship: unit_data(AWDS.battleship),

//         andy: user_data(AWDS.andy),
//         max: user_data(AWDS.max),
//         sami: user_data(AWDS.sami),
//         jake: user_data(AWDS.jake),
//         colin: user_data(AWDS.colin),
//         grit: user_data(AWDS.grit),
//         javier: user_data(AWDS.javier),
//         grimm: user_data(AWDS.grimm),
//         kanbei: user_data(AWDS.kanbei),
//         sonja: user_data(AWDS.sonja),
//         kindle: user_data(AWDS.kindle),
//         lash: user_data(AWDS.lash),
//         girder: user_data(AWDS.girder),

//         road: tile_data(Tile.Road.create()),
//         plains: tile_data(Tile.Plains.create()),
//         forest: tile_data(Tile.Forest.create()),
//         city: tile_data(Tile.City.create()),
//         mountain: tile_data(Tile.Mountain.create()),
//         ocean: tile_data(Tile.Ocean.create())
//       }
//       {:ok, data}
//     }

//     test "calculates infantry road vs road", %{
//       infantry: infantry,
//       andy: andy,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 45.0
//       assert defender.health >= 36.0
//       assert attacker.health <= 78.0
//       assert attacker.health >= 68.0
//     }

//     test "calculates infantry plains vs plains", %{
//       infantry: infantry,
//       andy: andy,
//       plains: plains
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 1}},
//           user_data: andy,
//           tile_data: plains
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: plains
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 51.0
//       assert defender.health >= 43.0
//       assert attacker.health <= 76.0
//       assert attacker.health >= 66.0
//     }

//     test "calculates infantry forest vs forest", %{
//       infantry: infantry,
//       andy: andy,
//       forest: forest
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: forest
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: andy,
//           tile_data: forest
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 56.0
//       assert defender.health >= 49.0
//       assert attacker.health <= 78.0
//       assert attacker.health >= 70.0
//     }

//     test "calculates infantry city vs city", %{
//       infantry: infantry,
//       andy: andy,
//       city: city
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: city
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 1}},
//           user_data: andy,
//           tile_data: city
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 62.0
//       assert defender.health >= 56.0
//       assert attacker.health <= 77.0
//       assert attacker.health >= 69.0
//     }

//     test "calculates infantry mountain vs mountain", %{
//       infantry: infantry,
//       andy: andy,
//       mountain: mountain
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 1}},
//           user_data: andy,
//           tile_data: mountain
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 1}},
//           user_data: andy,
//           tile_data: mountain
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 67.0
//       assert defender.health >= 62.0
//       assert attacker.health <= 77.0
//       assert attacker.health >= 74.0
//     }

//     test "calculates infantry mountain vs road", %{
//       infantry: infantry,
//       andy: andy,
//       road: road,
//       mountain: mountain
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: andy,
//           tile_data: mountain
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 1}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 45.0
//       assert defender.health >= 36.0
//       assert attacker.health <= 87.0
//       assert attacker.health >= 81.0
//     }

//     test "calculates infantry road vs mountain", %{
//       infantry: infantry,
//       andy: andy,
//       road: road,
//       mountain: mountain
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 1}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 1}},
//           user_data: andy,
//           tile_data: mountain
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 67.0
//       assert defender.health >= 62.0
//       assert attacker.health <= 62.0
//       assert attacker.health >= 56.0
//     }

//     test "calculates mech plains vs tank plains", %{
//       mech: mech,
//       tank: tank,
//       andy: andy,
//       plains: plains
//     } {
//       assert Enum.map(mech.weapon_data, &(&1.ammo)) == [nil, 3]
//       assert Enum.map(tank.weapon_data, &(&1.ammo)) == [nil, 9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {mech | coord: Coord {x: 1, y: 1}},
//           user_data: andy,
//           tile_data: plains
//         },
//         defender: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 1, y: 0}},
//           user_data: andy,
//           tile_data: plains
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 51.0
//       assert defender.health >= 43.0
//       assert attacker.health <= 69.0
//       assert attacker.health >= 58.0
//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [2, nil]
//       assert Enum.at(attacker.weapon_data, 0).weapon_id == Weapon.Bazooka.id()
//     }

//     test "calculates tank plains vs mech plains", %{
//       mech: mech,
//       tank: tank,
//       andy: andy,
//       plains: plains
//     } {
//       assert Enum.map(tank.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(mech.weapon_data, &(&1.ammo)) == [nil, 3]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 2, y: 1}},
//           user_data: andy,
//           tile_data: plains
//         },
//         defender: CombatData {
//           unit_data: UnitData {mech | coord: Coord {x: 1, y: 1}},
//           user_data: andy,
//           tile_data: plains
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 37.0
//       assert defender.health >= 29.0
//       assert attacker.health <= 86.0
//       assert attacker.health >= 77.0
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [2, nil]
//       assert Enum.at(defender.weapon_data, 0).weapon_id == Weapon.Bazooka.id()
//     }

//     test "calculates tank road vs apc road", %{
//       apc: apc,
//       tank: tank,
//       andy: andy,
//       road: road
//     } {
//       assert Enum.map(tank.weapon_data, &(&1.ammo)) == [nil, 9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 2, y: 1}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {apc | coord: Coord {x: 2, y: 2}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 25.0
//       assert defender.health >= 16.0
//       assert attacker.health == 100
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [8, nil]
//       assert Enum.at(attacker.weapon_data, 0).weapon_id == Weapon.TankCannon.id()
//     }

//     test "calculates tank road vs artillery road", %{
//       tank: tank,
//       artillery: artillery,
//       andy: andy,
//       road: road
//     } {
//       assert Enum.map(tank.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(artillery.weapon_data, &(&1.ammo)) == [9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 2, y: 2}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {artillery | coord: Coord {x: 1, y: 2}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 30.0
//       assert defender.health >= 21.0
//       assert attacker.health == 100

//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [8, nil]
//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [9]
//       assert Enum.at(attacker.weapon_data, 0).weapon_id == Weapon.TankCannon.id()
//     }

//     test "calculates artillery road vs tank road, can't counterattack indirect", %{
//       tank: tank,
//       artillery: artillery,
//       andy: andy,
//       road: road
//     } {
//       assert Enum.map(tank.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(artillery.weapon_data, &(&1.ammo)) == [9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {artillery | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 1, y: 2}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 30.0
//       assert defender.health >= 21.0
//       assert attacker.health == 100

//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [8]
//       assert Enum.at(attacker.weapon_data, 0).weapon_id == Weapon.ArtilleryCannon.id()
//     }

//     test "calculates artillery road vs tank road, out of range", %{
//       tank: tank,
//       artillery: artillery,
//       andy: andy,
//       road: road
//     } {
//       assert Enum.map(tank.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(artillery.weapon_data, &(&1.ammo)) == [9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {artillery | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 0, y: 4}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health == 100
//       assert attacker.health == 100

//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [9]
//     }

//     test "calculates artillery road vs tank road, out of range with max_range_bonus", %{
//       tank: tank,
//       artillery: artillery,
//       grit: grit,
//       road: road
//     } {
//       assert Enum.map(tank.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(artillery.weapon_data, &(&1.ammo)) == [9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {artillery | coord: Coord {x: 0, y: 0}},
//           user_data: grit,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 0, y: 4}},
//           user_data: grit,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 16.0
//       assert defender.health >= 7.0
//       assert attacker.health == 100

//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [8]
//     }

//     test "calculates bomber mountain vs infantry road, health goes negative", %{
//       infantry: infantry,
//       bomber: bomber,
//       andy: andy,
//       road: road,
//       mountain: mountain
//     } {
//       assert Enum.map(bomber.weapon_data, &(&1.ammo)) == [9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {bomber | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: mountain
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 1}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health == 0
//       assert attacker.health == 100

//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [8]
//     }

//     test "calculates antiair city vs bomber mountain, air doesn't gain tile defense", %{
//       bomber: bomber,
//       andy: andy,
//       mountain: mountain,
//       city: city,
//       antiair: antiair
//     } {
//       assert Enum.map(bomber.weapon_data, &(&1.ammo)) == [9]
//       assert Enum.map(antiair.weapon_data, &(&1.ammo)) == [9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {antiair | coord: Coord {x: 1, y: 0}},
//           user_data: andy,
//           tile_data: city
//         },
//         defender: CombatData {
//           unit_data: UnitData {bomber | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: mountain
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 25.0
//       assert defender.health >= 16.0
//       assert attacker.health <= 87.0
//       assert attacker.health >= 79.0

//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [8]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [8]
//     }

//     test "calculates megatank road vs mech road, dead unit doesn't counterattack", %{
//       megatank: megatank,
//       mech: mech,
//       andy: andy,
//       road: road
//     } {
//       assert Enum.map(megatank.weapon_data, &(&1.ammo)) == [nil, 3]
//       assert Enum.map(mech.weapon_data, &(&1.ammo)) == [nil, 3]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {megatank | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {mech | coord: Coord {x: 0, y: 1}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health == 0
//       assert attacker.health == 100

//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [nil, 3]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [nil, 3]
//     }

//     test "calculates submerged sub ocean vs cruiser ocean", %{
//       cruiser: cruiser,
//       sub: sub,
//       andy: andy,
//       ocean: ocean
//     } {
//       assert Enum.map(cruiser.weapon_data, &(&1.ammo)) == [nil, 9]
//       assert Enum.map(sub.weapon_data, &(&1.ammo)) == [6]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {
//             sub |
//             coord: Coord {x: 0, y: 0},
//             ability_data: [
//               AbilityData {ability_id: Ability.Stealth.id(), active: true}
//             ]
//           },
//           user_data: andy,
//           tile_data: ocean
//         },
//         defender: CombatData {
//           unit_data: UnitData {cruiser | coord: Coord {x: 0, y: 1}},
//           user_data: andy,
//           tile_data: ocean
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 75.0
//       assert defender.health >= 66.0
//       assert attacker.health <= 38.0 #todo: should be 37.0
//       assert attacker.health >= 21.0

//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [8, nil]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [5]
//       assert Enum.at(defender.weapon_data, 0).weapon_id == Weapon.CruiserMissiles.id()
//     }

//     test "calculates battleship ocean vs submerged sub ocean", %{
//       battleship: battleship,
//       sub: sub,
//       andy: andy,
//       ocean: ocean
//     } {
//       assert Enum.map(battleship.weapon_data, &(&1.ammo)) == [9]
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {battleship | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: ocean
//         },
//         defender: CombatData {
//           unit_data: UnitData {
//             sub |
//             coord: Coord {x: 0, y: 4},
//             ability_data: [
//               AbilityData {ability_id: Ability.Stealth.id(), active: false}
//             ]
//           },
//           user_data: andy,
//           tile_data: ocean
//         }
//       }
//       |> CombatResult.calculate()

//       assert defender.health <= 5.0
//       assert defender.health >= 0
//       assert attacker.health == 100

//       assert Enum.map(defender.weapon_data, &(&1.ammo)) == [6]
//       assert Enum.map(attacker.weapon_data, &(&1.ammo)) == [8]
//     }


//     test "calculates infantry road vs road, with attack_bonus power", %{
//       infantry: infantry,
//       sami: sami,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: sami,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: sami,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 29.0
//       assert defender.health >= 20.0
//       assert attacker.health <= 86.0
//       assert attacker.health >= 76.0
//     }

//     test "calculates infantry road vs road, with negative attack_bonus power", %{
//       infantry: infantry,
//       colin: colin,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: colin,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: colin,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 51.0
//       assert defender.health >= 42.0
//       assert attacker.health <= 76.0
//       assert attacker.health >= 62.0
//     }

//     test "calculates tank road vs road, with attack_bonus power", %{
//       tank: tank,
//       sami: sami,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 1, y: 0}},
//           user_data: sami,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 0, y: 0}},
//           user_data: sami,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 51.0
//       assert defender.health >= 42.0
//       assert attacker.health <= 76.0
//       assert attacker.health >= 65.0
//     }

//     test "calculates tank road vs road, with tile_attack_bonus power", %{
//       infantry: infantry,
//       kindle: kindle,
//       road: road,
//       city: city
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: kindle,
//           tile_data: city
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: kindle,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 23.0
//       assert defender.health >= 14.0
//       assert attacker.health <= 93.0
//       assert attacker.health >= 87.0
//     }

//     test "calculates infantry city vs road, with tile_attack_bonus power", %{
//       infantry: infantry,
//       grimm: grimm,
//       andy: andy,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: grimm,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 34.0
//       assert defender.health >= 24.0
//       assert attacker.health <= 79.0
//       assert attacker.health >= 68.0
//     }

//     test "calculates infantry road vs road, with defense_bonus power", %{
//       infantry: infantry,
//       grimm: grimm,
//       andy: andy,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: grimm,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 34.0
//       assert defender.health >= 24.0
//       assert attacker.health <= 79.0
//       assert attacker.health >= 68.0
//     }

//     test "calculates rocket road vs road, with indirect_defense_bonus power", %{
//       rocket: rocket,
//       javier: javier,
//       andy: andy,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {rocket | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {rocket | coord: Coord {x: 1, y: 2}},
//           user_data: javier,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 32.0
//       assert defender.health >= 25.0
//       assert attacker.health == 100
//     }

//     test "calculates tank road vs road, with direct_defense_bonus power", %{
//       tank: tank,
//       girder: girder,
//       road: road
//     } {

//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 0, y: 0}},
//           user_data: girder,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {tank | coord: Coord {x: 0, y: 1}},
//           user_data: girder,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 56.0
//       assert defender.health >= 49.0
//       assert attacker.health <= 78.0
//       assert attacker.health >= 70.0
//     }

//     test "calculates infantry plains vs road, with attack_bonus_per_tile_defense power", %{
//       infantry: infantry,
//       lash: lash,
//       andy: andy,
//       road: road,
//       plains: plains
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: lash,
//           tile_data: plains
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 40.0
//       assert defender.health >= 31.0
//       assert attacker.health <= 81.0
//       assert attacker.health >= 72.0 #todo: should be 77
//     }

//     test "calculates infantry mountain vs road, with attack_bonus_per_tile_defense power", %{
//       infantry: infantry,
//       lash: lash,
//       andy: andy,
//       road: road,
//       mountain: mountain
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: lash,
//           tile_data: mountain
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 23.0
//       assert defender.health >= 14.0
//       assert attacker.health <= 94.0
//       assert attacker.health >= 89.0
//     }

//     test "calculates infantry road vs road, with counterattack_bonus power", %{
//       infantry: infantry,
//       sonja: sonja,
//       road: road
//     } {
//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: sonja,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: sonja,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 55.0
//       assert defender.health >= 35.0
//       assert attacker.health <= 71.0
//       assert attacker.health >= 46.0
//     }

//     test "calculates infantry road vs road, with attack_bonus_per_funds power with 5k", %{
//       infantry: infantry,
//       colin: colin,
//       andy: andy,
//       road: road
//     } {
//       # setting ultra as active
//       colin = UserData {
//         colin |
//         funds: 5_000,
//         power_data: colin.power_data ++ colin.commander.ultra
//       }

//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: colin,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: andy,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 36.0 #todo: should be 32.0
//       assert defender.health >= 27.0 #todo: should be 23.0
//       assert attacker.health <= 86.0
//       assert attacker.health >= 75.0 #todo: should be 77.0
//     }

//     test "calculates infantry road vs road, with attack_bonus_per_funds power with 15k", %{
//       infantry: infantry,
//       colin: colin,
//       road: road
//     } {
//       # setting ultra as active
//       colin = UserData {
//         colin |
//         funds: 15_000,
//         power_data: colin.power_data ++ colin.commander.ultra
//       }

//       %{
//         attacker: %{unit_data: attacker},
//         defender: %{unit_data: defender}
//       } = CombatResult {
//         attacker: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 1, y: 0}},
//           user_data: colin,
//           tile_data: road
//         },
//         defender: CombatData {
//           unit_data: UnitData {infantry | coord: Coord {x: 0, y: 0}},
//           user_data: colin,
//           tile_data: road
//         }
//       }
//       |> CombatResult.calculate()
  
//       assert defender.health <= 18.0 #todo: should be 15.0
//       assert defender.health >= 6.0
//       assert attacker.health <= 95.0
//       assert attacker.health >= 82.0 #todo: should be 89.0
//     }
//   }
// }