private void GenericDiceModification(
Action callback,
DiceModificationType modificationType,
Func <int> getCount,
List <DieSide> sidesCanBeSelected,
DieSide newSide,
DiceModificationTimingType timing,
bool isTrueReroll = true,
bool isForcedFullReroll = false
)
{
switch (modificationType)
{
case DiceModificationType.Reroll:
DiceModificationReroll(callback, getCount, sidesCanBeSelected, timing, isTrueReroll, isForcedFullReroll);
break;
case DiceModificationType.Change:
DiceModificationChange(callback, getCount, sidesCanBeSelected, newSide);
break;
case DiceModificationType.Cancel:
DiceModificationCancel(callback, sidesCanBeSelected, timing);
break;
case DiceModificationType.Add:
DiceModificationAdd(callback, getCount, newSide);
break;
default:
break;
}
}
public override void UseDiceModifications(DiceModificationTimingType type)
{
base.UseDiceModifications(type);
Combat.ShowDiceModificationButtons(type);
GameController.CheckExistingCommands();
}
/// <summary>
/// Adds available dice modification
/// </summary>
protected void AddDiceModification(
string name,
Func <bool> isAvailable,
Func <int> aiPriority,
DiceModificationType modificationType,
int count,
List <DieSide> sidesCanBeSelected = null,
DieSide sideCanBeChangedTo = DieSide.Unknown,
DiceModificationTimingType timing = DiceModificationTimingType.Normal,
bool isGlobal = false,
Action <Action <bool> > payAbilityCost = null,
Action payAbilityPostCost = null,
bool isTrueReroll = true,
bool isForcedFullReroll = false
)
{
AddDiceModification(
name,
isAvailable,
aiPriority,
modificationType,
delegate { return(count); },
sidesCanBeSelected,
sideCanBeChangedTo,
timing,
isGlobal,
payAbilityCost,
payAbilityPostCost,
isTrueReroll,
isForcedFullReroll
);
}
public virtual void UseDiceModifications(DiceModificationTimingType type)
{
Phases.CurrentSubPhase.IsReadyForCommands = true;
Roster.HighlightPlayer(PlayerNo);
Combat.ShowDiceModificationButtons(type);
GameController.CheckExistingCommands();
}
public DiceModificationStep(CombatStep combatStep, PlayerRole stepOwner, DiceModificationTimingType timing, Type subphaseType)
{
CombatStep = combatStep;
StepOwner = stepOwner;
SubphaseType = subphaseType;
DiceModificationTiming = timing;
IsVital = IsVitalStep();
}
private static void ReGenerateListOfButtons(DiceModificationTimingType timingType)
{
HideDiceModificationButtons();
switch (timingType)
{
case DiceModificationTimingType.Normal:
ShowDiceModificationButtons();
break;
case DiceModificationTimingType.Opposite:
ShowOppositeDiceModificationButtons(true);
break;
case DiceModificationTimingType.CompareResults:
ShowCompareResultsButtons(true);
break;
default:
break;
}
}
// DICE MODIFICATIONS
// GENERATE LIST OF AVAILABLE DICE MODIFICATIONS
public void GenerateDiceModifications(DiceModificationTimingType type)
{
switch (type)
{
case DiceModificationTimingType.Normal:
GenerateDiceModificationsNormal();
break;
case DiceModificationTimingType.AfterRolled:
GenerateDiceModificationsAfterRolled();
break;
case DiceModificationTimingType.Opposite:
GenerateDiceModificationsOpposite();
break;
case DiceModificationTimingType.CompareResults:
GenerateDiceModificationsCompareResults();
break;
default:
break;
}
}
public virtual void UseDiceModifications(DiceModificationTimingType type)
{
Roster.HighlightPlayer(PlayerNo);
}
private void DiceModificationReroll(Action callback, Func <int> getCount, List <DieSide> sidesCanBeSelected, DiceModificationTimingType timing)
{
int diceCount = getCount();
if (diceCount > 0)
{
DiceRerollManager diceRerollManager = new DiceRerollManager
{
NumberOfDiceCanBeRerolled = diceCount,
SidesCanBeRerolled = sidesCanBeSelected,
IsOpposite = timing == DiceModificationTimingType.Opposite,
CallBack = callback
};
diceRerollManager.Start();
}
else
{
Messages.ShowErrorToHuman("0 dice can be rerolled");
callback();
}
}
private void GenericDiceModification(Action callback, DiceModificationType modificationType, Func <int> getCount, List <DieSide> sidesCanBeSelected, DieSide newSide, DiceModificationTimingType timing)
{
switch (modificationType)
{
case DiceModificationType.Reroll:
DiceModificationReroll(callback, getCount, sidesCanBeSelected, timing);
break;
case DiceModificationType.Change:
DiceModificationChange(callback, getCount, sidesCanBeSelected, newSide);
break;
default:
break;
}
}
/// <summary>
/// Adds available dice modification
/// </summary>
protected void AddDiceModification(string name, Func <bool> isAvailable, Func <int> aiPriority, DiceModificationType modificationType, Func <int> getCount, List <DieSide> sidesCanBeSelected = null, DieSide sideCanBeChangedTo = DieSide.Unknown, DiceModificationTimingType timing = DiceModificationTimingType.Normal, bool isGlobal = false, Action <Action <bool> > payAbilityCost = null)
{
if (sidesCanBeSelected == null)
{
sidesCanBeSelected = new List <DieSide>()
{
DieSide.Blank, DieSide.Focus, DieSide.Success, DieSide.Crit
}
}
;
DiceModification = (ship) =>
{
CustomDiceModification diceModification = new CustomDiceModification()
{
Name = name,
DiceModificationName = name,
ImageUrl = HostImageUrl,
DiceModificationTiming = timing,
Host = HostShip,
Source = HostUpgrade,
CheckDiceModificationAvailable = isAvailable,
GenerateDiceModificationAiPriority = aiPriority,
DoDiceModification = (Action callback) =>
{
if (payAbilityCost == null)
{
payAbilityCost = payCallback => payCallback(true);
}
payAbilityCost(success =>
{
if (success)
{
GenericDiceModification(callback, modificationType, getCount, sidesCanBeSelected, sideCanBeChangedTo, timing);
}
else
{
callback();
}
});
},
IsReroll = modificationType == DiceModificationType.Reroll,
};
ship.AddAvailableDiceModification(diceModification);
};
if (!isGlobal)
{
switch (timing)
{
case DiceModificationTimingType.AfterRolled:
HostShip.OnGenerateDiceModificationsAfterRolled += DiceModification;
break;
case DiceModificationTimingType.Normal:
HostShip.OnGenerateDiceModifications += DiceModification;
break;
case DiceModificationTimingType.Opposite:
HostShip.OnGenerateDiceModificationsOpposite += DiceModification;
break;
case DiceModificationTimingType.CompareResults:
HostShip.OnGenerateDiceModificationsCompareResults += DiceModification;
break;
default:
break;
}
}
else
{
switch (timing)
{
case DiceModificationTimingType.AfterRolled:
GenericShip.OnGenerateDiceModificationsAfterRolledGlobal += DiceModification;
break;
case DiceModificationTimingType.Normal:
GenericShip.OnGenerateDiceModificationsGlobal += DiceModification;
break;
case DiceModificationTimingType.Opposite:
GenericShip.OnGenerateDiceModificationsOppositeGlobal += DiceModification;
break;
case DiceModificationTimingType.CompareResults:
GenericShip.OnGenerateDiceModificationsCompareResultsGlobal += DiceModification;
break;
default:
break;
}
}
}
public override void UseDiceModifications(DiceModificationTimingType type)
{
base.UseDiceModifications(type);
Combat.ShowDiceModificationButtons(type);
}
private void DiceModificationCancel(Action callback, Func <int> getCount, List <DieSide> sidesCanBeSelected, DiceModificationTimingType timing)
{
int diceCount = getCount();
for (int i = 0; i < diceCount; i++)
{
Die die = DiceRoll.CurrentDiceRoll.DiceList.Where(d => sidesCanBeSelected.Contains(d.Side)).FirstOrDefault();
if (die != null)
{
DiceRoll.CurrentDiceRoll.DiceList.Remove(die);
die.RemoveModel();
}
else
{
break;
}
}
//DiceRoll.CurrentDiceRoll.OrganizeDicePositions();
callback();
}
public static void ShowDiceModificationButtons(DiceModificationTimingType type, bool isForced = false)
{
HideDiceModificationButtons();
UnityAction CloseButtonEffect = null;
switch (type)
{
case DiceModificationTimingType.Opposite:
Selection.ActiveShip = (AttackStep == CombatStep.Attack) ? Defender : Attacker;
CloseButtonEffect = SwitchToAfterRolledDiceModifications;
break;
case DiceModificationTimingType.AfterRolled:
Selection.ActiveShip = (AttackStep == CombatStep.Attack) ? Attacker : Defender;
CloseButtonEffect = SwitchToRegularDiceModifications;
break;
case DiceModificationTimingType.Normal:
Selection.ActiveShip = (AttackStep == CombatStep.Attack) ? Attacker : Defender;
CloseButtonEffect = Combat.ConfirmDiceResults;
break;
case DiceModificationTimingType.CompareResults:
Selection.ActiveShip = Attacker;
CloseButtonEffect = CompareResultsAndDealDamageClient;
break;
default:
break;
}
Phases.CurrentSubPhase.RequiredPlayer = Selection.ActiveShip.Owner.PlayerNo;
AvailableDecisions = new Dictionary <string, GenericAction>();
Selection.ActiveShip.GenerateDiceModifications(type);
if (Selection.ActiveShip.GetDiceModificationsGenerated().Count > 0 || isForced)
{
float offset = 0;
Vector3 defaultPosition = GameObject.Find("UI/CombatDiceResultsPanel").transform.Find("DiceModificationsPanel").position;
foreach (var actionEffect in Selection.ActiveShip.GetDiceModificationsGenerated())
{
AvailableDecisions.Add(actionEffect.Name, actionEffect);
Vector3 position = defaultPosition + new Vector3(0, -offset, 0);
CreateDiceModificationsButton(actionEffect, position);
offset += 40;
}
ShowCloseButton(CloseButtonEffect);
ShowDiceResultsPanel();
}
else
{
if (type != DiceModificationTimingType.Normal)
{
CloseButtonEffect.Invoke();
}
else
{
ShowCloseButton(CloseButtonEffect);
ShowDiceResultsPanel();
}
}
}
public override void UseDiceModifications(DiceModificationTimingType type)
{
base.UseDiceModifications(type);
Action FinalEffect = null;
switch (type)
{
case DiceModificationTimingType.Normal:
Selection.ActiveShip = (Combat.AttackStep == CombatStep.Attack) ? Combat.Attacker : Combat.Defender;
FinalEffect = Phases.CurrentSubPhase.CallBack;
break;
case DiceModificationTimingType.AfterRolled:
Selection.ActiveShip = (Combat.AttackStep == CombatStep.Attack) ? Combat.Attacker : Combat.Defender;
FinalEffect = Combat.SwitchToRegularDiceModifications;
break;
case DiceModificationTimingType.Opposite:
Selection.ActiveShip = (Combat.AttackStep == CombatStep.Attack) ? Combat.Defender : Combat.Attacker;
FinalEffect = Combat.SwitchToAfterRolledDiceModifications;
break;
case DiceModificationTimingType.CompareResults:
Selection.ActiveShip = Combat.Attacker;
FinalEffect = Combat.CompareResultsAndDealDamage;
break;
default:
break;
}
Selection.ActiveShip.GenerateDiceModifications(type);
List <GenericAction> availableDiceModifications = Selection.ActiveShip.GetDiceModificationsGenerated();
Dictionary <GenericAction, int> actionsPriority = new Dictionary <GenericAction, int>();
foreach (var diceModification in availableDiceModifications)
{
int priority = diceModification.GetDiceModificationPriority();
Selection.ActiveShip.CallOnAiGetDiceModificationPriority(diceModification, ref priority);
actionsPriority.Add(diceModification, priority);
}
actionsPriority = actionsPriority.OrderByDescending(n => n.Value).ToDictionary(n => n.Key, n => n.Value);
bool isActionEffectTaken = false;
if (actionsPriority.Count > 0)
{
KeyValuePair <GenericAction, int> prioritizedActionEffect = actionsPriority.First();
if (prioritizedActionEffect.Value > 0)
{
isActionEffectTaken = true;
Messages.ShowInfo("AI uses \"" + prioritizedActionEffect.Key.Name + "\"");
GameManagerScript.Wait(1, delegate {
GameCommand command = Combat.GenerateDiceModificationCommand(prioritizedActionEffect.Key.Name);
GameMode.CurrentGameMode.ExecuteCommand(command);
});
}
}
if (!isActionEffectTaken)
{
if (type == DiceModificationTimingType.Normal)
{
GameManagerScript.Wait(1, delegate {
GameCommand command = Combat.GenerateDiceModificationCommand("OK");
GameMode.CurrentGameMode.ExecuteCommand(command);
});
}
else
{
FinalEffect.Invoke();
}
}
}
public virtual void UseDiceModifications(DiceModificationTimingType type)
{
Roster.HighlightPlayer(PlayerNo);
Combat.ShowDiceModificationButtons(type);
GameController.CheckExistingCommands();
}
public override void UseDiceModifications(DiceModificationTimingType type)
{
base.UseDiceModifications(type);
switch (type)
{
case DiceModificationTimingType.Normal:
Selection.ActiveShip = (Combat.AttackStep == CombatStep.Attack) ? Combat.Attacker : Combat.Defender;
break;
case DiceModificationTimingType.AfterRolled:
Selection.ActiveShip = (Combat.AttackStep == CombatStep.Attack) ? Combat.Attacker : Combat.Defender;
break;
case DiceModificationTimingType.Opposite:
Selection.ActiveShip = (Combat.AttackStep == CombatStep.Attack) ? Combat.Defender : Combat.Attacker;
break;
case DiceModificationTimingType.CompareResults:
Selection.ActiveShip = Combat.Attacker;
break;
default:
break;
}
Dictionary <GenericAction, int> actionsPriority = new Dictionary <GenericAction, int>();
foreach (var diceModification in Combat.DiceModifications.AvailableDiceModifications.Values)
{
int priority = diceModification.GetDiceModificationPriority();
Selection.ActiveShip.CallOnAiGetDiceModificationPriority(diceModification, ref priority);
actionsPriority.Add(diceModification, priority);
}
actionsPriority = actionsPriority.OrderByDescending(n => n.Value).ToDictionary(n => n.Key, n => n.Value);
bool isActionEffectTaken = false;
if (actionsPriority.Count > 0)
{
KeyValuePair <GenericAction, int> prioritizedActionEffect = actionsPriority.First();
if (prioritizedActionEffect.Value > 0)
{
isActionEffectTaken = true;
GameManagerScript.Wait(1, delegate {
GameCommand command = DiceModificationsManager.GenerateDiceModificationCommand(prioritizedActionEffect.Key.Name);
GameMode.CurrentGameMode.ExecuteCommand(command);
});
}
}
if (!isActionEffectTaken)
{
GameManagerScript.Wait(1, delegate {
GameCommand command = DiceModificationsManager.GenerateDiceModificationCommand("OK");
GameMode.CurrentGameMode.ExecuteCommand(command);
});
}
}
private static void ReGenerateListOfButtons(DiceModificationTimingType timingType)
{
ShowDiceModificationButtons(timingType, true);
Roster.GetPlayer(Phases.CurrentSubPhase.RequiredPlayer).UseDiceModifications(timingType);
}
private void DiceModificationReroll(Action callback, Func <int> getCount, List <DieSide> sidesCanBeSelected, DiceModificationTimingType timing, bool isTrueReroll = true, bool isForcedFullReroll = false)
{
int diceCount = getCount();
if (diceCount > 0)
{
DiceRerollManager diceRerollManager = new DiceRerollManager
{
NumberOfDiceCanBeRerolled = diceCount,
SidesCanBeRerolled = sidesCanBeSelected,
IsOpposite = timing == DiceModificationTimingType.Opposite,
IsTrueReroll = isTrueReroll,
IsForcedFullReroll = isForcedFullReroll,
CallBack = callback
};
diceRerollManager.Start();
}
else
{
Messages.ShowErrorToHuman("No dice are eligible to be rerolled");
callback();
}
}
private static void ReGenerateListOfButtons(DiceModificationTimingType timingType)
{
ShowDiceModificationButtons(timingType, true);
}
private void DiceModificationCancel(Action callback, List <DieSide> sidesCanBeSelected, DiceModificationTimingType timing)
{
List <Die> diceToCancel = DiceRoll.CurrentDiceRoll.DiceList.Where(d => sidesCanBeSelected.Contains(d.Side)).ToList();
foreach (Die die in diceToCancel)
{
DiceRoll.CurrentDiceRoll.DiceList.Remove(die);
die.RemoveModel();
}
//DiceRoll.CurrentDiceRoll.OrganizeDicePositions();
callback();
}
