public override void ProcessExternalInputWhileHeld(Vector3 inputPosition)
{
base.ProcessExternalInputWhileHeld(inputPosition);
TorpedoAttack.Target target = new TorpedoAttack.Target();
Board board = Battle.main.defender.board;
Vector3Int flatTileCoordinate = grid.GetFlatTileCoordinateAtPosition(inputPosition);
if (!grid.GetTileAtPosition(inputPosition))
{
if (flatTileCoordinate.x >= 0 && flatTileCoordinate.x < board.tiles.GetLength(0))
{
target.torpedoDropPoint = board.tiles[flatTileCoordinate.x, flatTileCoordinate.z > 0 ? board.tiles.GetLength(1) - 1 : 0];
target.torpedoHeading = Vector2Int.up * (flatTileCoordinate.z > 0 ? -1 : 1);
}
else if (flatTileCoordinate.z >= 0 && flatTileCoordinate.z < board.tiles.GetLength(1))
{
target.torpedoDropPoint = board.tiles[flatTileCoordinate.x > 0 ? board.tiles.GetLength(0) - 1 : 0, flatTileCoordinate.z];
target.torpedoHeading = Vector2Int.right * (flatTileCoordinate.x > 0 ? -1 : 1);
}
}
if (effect == null)
{
if (target.torpedoDropPoint != null && target.torpedoHeading != Vector2Int.zero)
{
effect = Effect.CreateEffect(typeof(TorpedoAttack));
effect.visibleTo = Battle.main.attacker;
effect.targetedPlayer = Battle.main.defender;
}
else
{
hookedPosition = Utilities.GetPositionOnElevationFromPerspective(inputPosition, Camera.main.transform.position, pickupPosition.y).projectedPosition;
}
}
if (effect != null)
{
TorpedoAttack attack = effect as TorpedoAttack;
if (target.torpedoDropPoint != null && target.torpedoHeading != Vector2Int.zero)
{
if (target != attack.target)
{
attack.target = target;
RefreshEffectRepresentation();
}
}
else
{
Destroy(attack.gameObject);
effect = null;
}
}
}
protected override void RefreshEffectRepresentation()
{
base.RefreshEffectRepresentation();
TorpedoAttack attack = effect as TorpedoAttack;
if (indicator == null)
{
indicator = RequestLineMarker(1, false, new Vector3[] { Vector3.zero, Vector3.forward * Battle.main.defender.board.tiles.GetLength(0) * 2.05f }, new int[][] { new int[] { 1 }, new int[0] }, 0, linesMaterial);
indicator.Delinker += () => { indicator = null; };
indicator.transform.SetParent(transform, false);
}
bool horizontal = attack.target.torpedoHeading.x != 0;
bool directionPositive = attack.target.torpedoHeading.x + attack.target.torpedoHeading.y > 0;
indicator.transform.rotation = Quaternion.Euler(0, horizontal ? (directionPositive ? 90 : 270) : (directionPositive ? 0 : 180), 0);
hookedPosition = attack.target.torpedoDropPoint.transform.position + new Vector3(-attack.target.torpedoHeading.x, MiscellaneousVariables.it.boardUIRenderHeight + height, -attack.target.torpedoHeading.y);
}
static void FightFor(Player player)
{
Player attacked_player = Battle.main.attacker == player ? Battle.main.defender : Battle.main.attacker;
Map map = new Map(attacked_player.board);
float[,] priority_map = map.ratings.Normalize();
float advantage = player.board.ships.Sum(x => x.health) / (float)attacked_player.board.ships.Sum(x => x.health > 0 ? x.maxHealth : 0);
int prefered_torpedocount = Mathf.FloorToInt(Mathf.Clamp(player.arsenal.torpedoes, 0, player.arsenal.loadedTorpedoCap) * ((Mathf.Cos(advantage * Mathf.PI) + 1.0f) / 2.0f));
int gun_targetcount = player.arsenal.guns;
int torpedo_targetcount = player.arsenal.loadedTorpedoes >= prefered_torpedocount || player.arsenal.loadedTorpedoes == player.arsenal.torpedoes ? prefered_torpedocount : 0;
int aircraft_targetcount = Mathf.CeilToInt(Mathf.Clamp(player.arsenal.aircraft - Battle.main.effects.Count(x => x is AircraftRecon && x.visibleTo == player), 0, int.MaxValue) * priority_map.Average());
int cyclone_size = Battle.main.effects.Exists(x => x is Cyclone) ? (Battle.main.effects.Find(x => x is Cyclone) as Cyclone).maximumTileSpacingToTakeEffect * 2 : 0;
for (int ti = 0; ti < gun_targetcount; ti++)
{
Vector2Int target = priority_map.Max();
ArtilleryAttack attack = Effect.CreateEffect(typeof(ArtilleryAttack)) as ArtilleryAttack;
attack.target = attacked_player.board.tiles[target.x, target.y];
attack.visibleTo = player;
attack.targetedPlayer = attacked_player;
Effect.AddToStack(attack);
if (cyclone_size > 0)
{
priority_map = priority_map.AddHeat(target, dist => dist <= cyclone_size ? 0.1f : 1.0f, (original, function) => original * function);
}
else
{
priority_map = priority_map.AddHeat(target, dist => 1 - Mathf.Pow(0.5f, dist), (original, function) => original * function);
}
}
for (int ti = 0; ti < torpedo_targetcount; ti++)
{
float best_lane_rating = Mathf.NegativeInfinity;
TorpedoAttack.Target best_target = new TorpedoAttack.Target();
for (int i = 0; i < 4; i++)
{
for (int a = 0; a < priority_map.GetLength(i % 2); a++)
{
float rating = 0;
for (int b = 0; b < priority_map.GetLength((i + 1) % 2) / 2; b++)
{
int x = i % 2 == 0 ? a : (i == 1 ? b : priority_map.GetLength(0) - b - 1);
int y = i % 2 == 1 ? a : (i == 0 ? b : priority_map.GetLength(1) - b - 1);
rating += priority_map[x, y];
}
if (rating > best_lane_rating)
{
best_lane_rating = rating;
best_target.torpedoDropPoint = attacked_player.board.tiles[i % 2 == 0 ? a : (i == 1 ? 0 : (priority_map.GetLength(0) - 1)), i % 2 == 1 ? a : (i == 0 ? 0 : (priority_map.GetLength(1) - 1))];
best_target.torpedoHeading = new Vector2Int((2 - i) % 2, (1 - i) % 2);
}
}
}
TorpedoAttack attack = Effect.CreateEffect(typeof(TorpedoAttack)) as TorpedoAttack;
attack.target = best_target;
attack.visibleTo = player;
attack.targetedPlayer = attacked_player;
Effect.AddToStack(attack);
float average = priority_map.Average();
priority_map = priority_map.AddHeat(best_target.torpedoDropPoint.coordinates, dist => 1 - Mathf.Pow(0.5f, dist), (original, function) => original * function);
}
for (int ti = 0; ti < aircraft_targetcount; ti++)
{
float best_line_rating = Mathf.NegativeInfinity;
int best_line = 0;
int line_count = attacked_player.board.tiles.GetLength(0) + attacked_player.board.tiles.GetLength(1) - 2;
for (int line = 0; line < line_count; line++)
{
int line_position = line % (attacked_player.board.tiles.GetLength(0) - 1);
bool lineVertical = line_position == line;
float line_rating = 0;
for (int a = 0; a < 2; a++)
{
for (int b = 0; b < attacked_player.board.tiles.GetLength(lineVertical ? 1 : 0); b++)
{
int x = lineVertical ? a + line_position : b;
int y = lineVertical ? b : a + line_position;
line_rating += priority_map[x, y];
}
}
if (line_rating > best_line_rating)
{
best_line = line;
best_line_rating = line_rating;
}
}
AircraftRecon recon = Effect.CreateEffect(typeof(AircraftRecon)) as AircraftRecon;
recon.target = best_line;
recon.visibleTo = player;
recon.targetedPlayer = attacked_player;
Effect.AddToStack(recon);
bool line_vertical = best_line < attacked_player.board.tiles.GetLength(0);
best_line %= attacked_player.board.tiles.GetLength(0) - 1;
for (int a = 0; a < 2; a++)
{
for (int b = 0; b < attacked_player.board.tiles.GetLength(line_vertical ? 1 : 0); b++)
{
int x = line_vertical ? a + best_line : b;
int y = line_vertical ? b : a + best_line;
priority_map[x, y] = 0;
}
}
}
}
