private void DoPseudoBoost(object sender, System.EventArgs e)
{
Messages.ShowInfo(HostShip.PilotInfo.PilotName + " is resolving Boost as a maneuver");
SavedManeuver = HostShip.AssignedManeuver;
SavedManeuverColors = new Dictionary <string, MovementComplexity>();
foreach (var changedManeuver in ChangedManeuversCodes)
{
KeyValuePair <ManeuverHolder, MovementComplexity> existingManeuver = (HostShip.DialInfo.PrintedDial.FirstOrDefault(n => n.Key.ToString() == changedManeuver));
SavedManeuverColors.Add(changedManeuver, (existingManeuver.Equals(default(KeyValuePair <ManeuverHolder, MovementComplexity>))) ? MovementComplexity.None : existingManeuver.Value);
HostShip.Maneuvers[changedManeuver] = MovementComplexity.Normal;
}
// Direction from action
HostShip.SetAssignedManeuver(
ShipMovementScript.MovementFromString(
ManeuverFromBoostTemplate(
(ActionToRevert as BoostAction).SelectedBoostTemplate
)
)
);
HostShip.AssignedManeuver.IsRevealDial = false;
HostShip.AssignedManeuver.GrantedBy = HostShip.PilotInfo.PilotName;
ShipMovementScript.LaunchMovement(FinishAbility);
}
private static IEnumerator CheckNextTurnRecursive(List <string> turnManeuvers)
{
NextTurnNavigationResults = new List <NavigationResult>();
VirtualBoard.RemoveCollisionsExcept(CurrentShip);
foreach (string turnManeuver in turnManeuvers)
{
GenericMovement movement = ShipMovementScript.MovementFromString(turnManeuver);
if (movement.Bearing == ManeuverBearing.Stationary)
{
continue;
}
CurrentShip.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
movement.IsSimple = true;
CurrentTurnMovementPrediction = new MovementPrediction(movement);
yield return(CurrentTurnMovementPrediction.CalculateMovementPredicition());
NextTurnNavigationResults.Add(new NavigationResult()
{
isOffTheBoard = CurrentTurnMovementPrediction.IsOffTheBoard,
obstaclesHit = CurrentMovementPrediction.AsteroidsHit.Count
});
}
VirtualBoard.ReturnCollisionsExcept(CurrentShip);
}
private static IEnumerator CheckNextTurnRecursive(GenericShip ship)
{
VirtualBoard.RemoveCollisionsExcept(ship);
bool HasAnyManeuverWithoutOffBoardFinish = false;
bool HasAnyManeuverWithoutAsteroidCollision = false;
foreach (string turnManeuver in GetShortestTurnManeuvers(ship))
{
GenericMovement movement = ShipMovementScript.MovementFromString(turnManeuver);
ship.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
movement.IsSimple = true;
MovementPrediction prediction = new MovementPrediction(ship, movement);
yield return(prediction.CalculateMovementPredicition());
if (!CurrentNavigationResult.isOffTheBoard)
{
HasAnyManeuverWithoutOffBoardFinish = true;
}
if (CurrentNavigationResult.obstaclesHit == 0)
{
HasAnyManeuverWithoutAsteroidCollision = true;
}
}
CurrentNavigationResult.isOffTheBoardNextTurn = !HasAnyManeuverWithoutOffBoardFinish;
CurrentNavigationResult.isHitAsteroidNextTurn = !HasAnyManeuverWithoutAsteroidCollision;
VirtualBoard.ReturnCollisionsExcept(ship);
}
private static IEnumerator PredictManeuversOfThisShip()
{
Selection.ChangeActiveShip(CurrentShip);
NavigationResults = new Dictionary <string, NavigationResult>();
foreach (var maneuver in CurrentShip.GetManeuvers())
{
GenericMovement movement = ShipMovementScript.MovementFromString(maneuver.Key);
CurrentShip.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
movement.IsSimple = true;
CurrentMovementPrediction = new MovementPrediction(movement);
yield return(CurrentMovementPrediction.CalculateMovementPredicition());
VirtualBoard.SetVirtualPositionInfo(CurrentShip, CurrentMovementPrediction.FinalPositionInfo);
VirtualBoard.SwitchToVirtualPosition(CurrentShip);
yield return(CheckNextTurnRecursive(GetShortestTurnManeuvers()));
yield return(ProcessMovementPredicition());
VirtualBoard.SwitchToRealPosition(CurrentShip);
}
}
private static IEnumerator PredictCurrentManeuver()
{
string maneuverCode = Ship.AssignedManeuver.ToString();
GenericMovement movement = ShipMovementScript.MovementFromString(maneuverCode);
Ship.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
MovementPrediction = new MovementPrediction(Ship, movement);
yield return(MovementPrediction.CalculateMovementPredicition());
}
private static IEnumerator PredictFinalPosionsOfOwnShip(GenericShip ship)
{
Selection.ChangeActiveShip(ship);
VirtualBoard.SwitchToRealPosition(ship);
Dictionary <string, NavigationResult> navigationResults = new Dictionary <string, NavigationResult>();
foreach (var maneuver in ship.GetManeuvers())
{
GenericMovement movement = ShipMovementScript.MovementFromString(maneuver.Key);
ship.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
movement.IsSimple = true;
MovementPrediction prediction = new MovementPrediction(ship, movement);
prediction.CalculateOnlyFinalPositionIgnoringCollisions();
VirtualBoard.SetVirtualPositionInfo(ship, prediction.FinalPositionInfo, prediction.CurrentMovement.ToString());
VirtualBoard.SwitchToVirtualPosition(ship);
float minDistanceToEnemyShip, minDistanceToNearestEnemyInShotRange, minAngle;
int enemiesInShotRange;
ProcessHeavyGeometryCalculations(ship, out minDistanceToEnemyShip, out minDistanceToNearestEnemyInShotRange, out minAngle, out enemiesInShotRange);
NavigationResult result = new NavigationResult()
{
movement = prediction.CurrentMovement,
distanceToNearestEnemy = minDistanceToEnemyShip,
distanceToNearestEnemyInShotRange = minDistanceToNearestEnemyInShotRange,
angleToNearestEnemy = minAngle,
enemiesInShotRange = enemiesInShotRange,
isBumped = prediction.IsBumped,
isLandedOnObstacle = prediction.IsLandedOnAsteroid,
isOffTheBoard = prediction.IsOffTheBoard,
FinalPositionInfo = prediction.FinalPositionInfo
};
result.CalculatePriority();
if (DebugManager.DebugAiNavigation)
{
Console.Write("", LogTypes.AI);
}
navigationResults.Add(maneuver.Key, result);
VirtualBoard.SwitchToRealPosition(ship);
yield return(true);
}
ship.ClearAssignedManeuver();
VirtualBoard.UpdateNavigationResults(ship, navigationResults);
}
private bool FilterOnlyForward(string maneuverCode)
{
bool result = true;
GenericMovement maneuver = ShipMovementScript.MovementFromString(maneuverCode);
if (maneuver.Bearing == ManeuverBearing.Stationary ||
maneuver.Bearing == ManeuverBearing.ReverseStraight ||
maneuver.Bearing == ManeuverBearing.ReverseBank)
{
result = false;
}
return(result);
}
private bool AdaptiveAileronsFilter(string maneuverString)
{
GenericMovement movement = ShipMovementScript.MovementFromString(maneuverString, HostShip);
if (movement.ManeuverSpeed != ManeuverSpeed.Speed1)
{
return(false);
}
if (movement.Bearing == ManeuverBearing.Straight || movement.Bearing == ManeuverBearing.Bank)
{
return(true);
}
return(false);
}
private bool IsSpeedPlusMinus1(string maneuverString)
{
GenericMovement maneuver = ShipMovementScript.MovementFromString(maneuverString);
if (maneuver.Bearing == HostShip.AssignedManeuver.Bearing &&
maneuver.Direction == HostShip.AssignedManeuver.Direction)
{
if (maneuver.Speed == HostShip.AssignedManeuver.Speed ||
maneuver.Speed == HostShip.AssignedManeuver.Speed - 1 ||
maneuver.Speed == HostShip.AssignedManeuver.Speed + 1)
{
return(true);
}
}
return(false);
}
public static void SetManeuver(string maneuverCode)
{
foreach (var shipHolder in Roster.GetPlayer(Phases.CurrentSubPhase.RequiredPlayer).Ships)
{
if (shipHolder.Value.HasManeuver(maneuverCode) && !RulesList.IonizationRule.IsIonized(shipHolder.Value))
{
shipHolder.Value.SetAssignedManeuver(ShipMovementScript.MovementFromString(maneuverCode, shipHolder.Value));
Roster.HighlightShipOff(shipHolder.Value);
}
}
if (Roster.AllManuversAreAssigned(Phases.CurrentPhasePlayer))
{
UI.ShowNextButton();
UI.HighlightNextButton();
}
}
public Movement.GenericMovement RandomManeuverFromTable(List <string> table)
{
string result = "";
int random = Random.Range(0, 6);
if (inDebug)
{
Debug.Log("Random is: " + random);
}
result = table[random];
if (inDebug)
{
Debug.Log("Result is: " + result);
}
return(ShipMovementScript.MovementFromString(result));
}
private static void PredictSimpleFinalPositionOfEnemyShip(GenericShip ship)
{
Selection.ThisShip = ship;
GenericMovement savedMovement = ship.AssignedManeuver;
// Decide what maneuvers to use as temporary
string temporyManeuver = (ship.State.IsIonized) ? "1.F.S" : "2.F.S";
bool isTemporaryManeuverAdded = false;
if (!ship.HasManeuver(temporyManeuver))
{
isTemporaryManeuverAdded = true;
ship.Maneuvers.Add(temporyManeuver, MovementComplexity.Easy);
}
GenericMovement movement = ShipMovementScript.MovementFromString(temporyManeuver);
// Check maneuver
ship.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
movement.IsSimple = true;
MovementPrediction prediction = new MovementPrediction(ship, movement);
prediction.CalculateOnlyFinalPositionIgnoringCollisions();
if (isTemporaryManeuverAdded)
{
ship.Maneuvers.Remove(temporyManeuver);
}
if (savedMovement != null)
{
ship.SetAssignedManeuver(savedMovement, isSilent: true);
}
else
{
ship.ClearAssignedManeuver();
}
VirtualBoard.SetVirtualPositionInfo(ship, prediction.FinalPositionInfo, temporyManeuver);
}
public void CallManeuverIsRevealed(Action callBack, Action whenSkippedCallback)
{
if (AssignedManeuver != null)
{
Roster.ToggleManeuverVisibility(Selection.ThisShip, true);
}
if (AssignedManeuver != null && AssignedManeuver.IsRevealDial)
{
// Make a new copy of AssignedManeuver, so changes to it doesn't affect RevealedManeuver
RevealedManeuver = ShipMovementScript.MovementFromString(AssignedManeuver.ToString());
OnManeuverIsRevealed?.Invoke(this);
OnManeuverIsRevealedGlobal?.Invoke(this);
Triggers.ResolveTriggers(
TriggerTypes.OnManeuverIsRevealed,
delegate
{
if (!IsManeuverSkipped)
{
callBack();
}
else
{
whenSkippedCallback();
}
}
);
}
else // For ionized ships
{
OnNoManeuverWasRevealedGlobal?.Invoke(this);
callBack();
}
}
private void ChangeBearing(ManeuverBearing bearing)
{
int speed = HostShip.AssignedManeuver.Speed;
ManeuverDirection direction = HostShip.AssignedManeuver.Direction;
string newManeuverString = "";
switch (bearing)
{
case ManeuverBearing.KoiogranTurn:
newManeuverString = speed + ".F.R";
break;
case ManeuverBearing.SegnorsLoopUsingTurnTemplate:
newManeuverString = speed + "." + ((direction == ManeuverDirection.Left) ? "L" : "R") + ".r";
break;
}
AddTemporaryManeuvers(newManeuverString);
HostShip.OnMovementExecuted += RemoveTemporaryManeuvers;
HostShip.SetAssignedManeuver(ShipMovementScript.MovementFromString(newManeuverString));
DecisionSubPhase.ConfirmDecision();
}
private static IEnumerator PredictSimpleManeuver(GenericShip ship)
{
Selection.ThisShip = ship;
GenericMovement savedMovement = ship.AssignedManeuver;
string temporyManeuver = (ship.State.IsIonized) ? "1.F.S" : "2.F.S";
bool isTemporaryManeuverAdded = false;
if (!ship.HasManeuver(temporyManeuver))
{
isTemporaryManeuverAdded = true;
ship.Maneuvers.Add(temporyManeuver, MovementComplexity.Easy);
}
GenericMovement movement = ShipMovementScript.MovementFromString(temporyManeuver);
ship.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
movement.IsSimple = true;
CurrentSimpleMovementPrediction = new MovementPrediction(movement);
yield return(CurrentSimpleMovementPrediction.CalculateMovementPredicition());
if (isTemporaryManeuverAdded)
{
ship.Maneuvers.Remove(temporyManeuver);
}
if (savedMovement != null)
{
ship.SetAssignedManeuver(savedMovement, isSilent: true);
}
else
{
ship.ClearAssignedManeuver();
}
}
private static IEnumerator FindBestManeuver(GenericShip ship)
{
Selection.ChangeActiveShip(ship);
if (DebugManager.DebugAiNavigation)
{
Console.Write("", LogTypes.AI);
Console.Write("Best maneuver calculations for " + ship.ShipId, LogTypes.AI, isBold: true);
}
int bestPriority = int.MinValue;
KeyValuePair <string, NavigationResult> maneuverToCheck = new KeyValuePair <string, NavigationResult>();
do
{
VirtualBoard.SwitchToRealPosition(ship);
bestPriority = VirtualBoard.Ships[ship].NavigationResults.Max(n => n.Value.Priority);
maneuverToCheck = VirtualBoard.Ships[ship].NavigationResults.Where(n => n.Value.Priority == bestPriority).First();
if (DebugManager.DebugAiNavigation)
{
Console.Write("Current best maneuver is " + maneuverToCheck.Key + " with priority " + maneuverToCheck.Value.ToString(), LogTypes.AI);
}
GenericMovement movement = ShipMovementScript.MovementFromString(maneuverToCheck.Key);
ship.SetAssignedManeuver(movement, isSilent: true);
movement.Initialize();
movement.IsSimple = true;
MovementPrediction prediction = new MovementPrediction(ship, movement);
yield return(prediction.CalculateMovementPredicition());
VirtualBoard.SetVirtualPositionInfo(ship, prediction.FinalPositionInfo, prediction.CurrentMovement.ToString());
VirtualBoard.SwitchToVirtualPosition(ship);
CurrentNavigationResult = new NavigationResult()
{
movement = prediction.CurrentMovement,
isBumped = prediction.IsBumped,
isLandedOnObstacle = prediction.IsLandedOnAsteroid,
obstaclesHit = prediction.AsteroidsHit.Count,
isOffTheBoard = prediction.IsOffTheBoard,
minesHit = prediction.MinesHit.Count,
isOffTheBoardNextTurn = false, //!NextTurnNavigationResults.Any(n => !n.isOffTheBoard),
isHitAsteroidNextTurn = false, //!NextTurnNavigationResults.Any(n => n.obstaclesHit == 0),
FinalPositionInfo = prediction.FinalPositionInfo
};
foreach (GenericShip enemyShip in CurrentPlayer.EnemyShips.Values)
{
VirtualBoard.SwitchToVirtualPosition(enemyShip);
}
if (!prediction.IsOffTheBoard)
{
yield return(CheckNextTurnRecursive(ship));
float minDistanceToEnemyShip, minDistanceToNearestEnemyInShotRange, minAngle;
int enemiesInShotRange;
ProcessHeavyGeometryCalculations(ship, out minDistanceToEnemyShip, out minDistanceToNearestEnemyInShotRange, out minAngle, out enemiesInShotRange);
CurrentNavigationResult.distanceToNearestEnemy = minDistanceToEnemyShip;
CurrentNavigationResult.distanceToNearestEnemyInShotRange = minDistanceToNearestEnemyInShotRange;
CurrentNavigationResult.angleToNearestEnemy = minAngle;
CurrentNavigationResult.enemiesInShotRange = enemiesInShotRange;
}
CurrentNavigationResult.CalculatePriority();
if (DebugManager.DebugAiNavigation)
{
Console.Write("After reevaluation priority is changed to " + CurrentNavigationResult.ToString(), LogTypes.AI);
}
VirtualBoard.Ships[ship].NavigationResults[maneuverToCheck.Key] = CurrentNavigationResult;
bestPriority = VirtualBoard.Ships[ship].NavigationResults.Max(n => n.Value.Priority);
if (DebugManager.DebugAiNavigation)
{
Console.Write("Highest priority of all maneuvers is " + bestPriority, LogTypes.AI);
}
VirtualBoard.SwitchToRealPosition(ship);
maneuverToCheck = VirtualBoard.Ships[ship].NavigationResults.First(n => n.Key == maneuverToCheck.Key);
foreach (GenericShip enemyShip in CurrentPlayer.EnemyShips.Values)
{
VirtualBoard.SwitchToRealPosition(enemyShip);
}
} while (maneuverToCheck.Value.Priority != bestPriority);
if (DebugManager.DebugAiNavigation)
{
Console.Write("Maneuver is chosen: " + maneuverToCheck.Key, LogTypes.AI);
}
VirtualBoard.Ships[ship].SetPlannedManeuverCode(maneuverToCheck.Key, ++OrderOfActivation);
ship.ClearAssignedManeuver();
}
private void AfterManeuverIsChanged(string maneuverString)
{
HostShip.SetAssignedManeuver(ShipMovementScript.MovementFromString(maneuverString));
Triggers.FinishTrigger();
}
