public void SetActive(UniquePowerModifierData uniquePowerModifierData)
{
// save UPM data
this.uniquePowerModifierData = uniquePowerModifierData;
// update current duration left value
UpdateDurationLeftText();
// get UPM UI config
UniquePowerModifierConfig uniquePowerModifierConfig = uniquePowerModifierData.GetUniquePowerModifierConfig();
// update text button colors
textButton.NormalColor = uniquePowerModifierConfig.UniquePowerModifierStausIconUIConfig.statusIconTextNormalColor;
textButton.HighlightedColor = uniquePowerModifierConfig.UniquePowerModifierStausIconUIConfig.statusIconTextHighlightedColor;
textButton.PressedColor = uniquePowerModifierConfig.UniquePowerModifierStausIconUIConfig.statusIconTextPressedColor;
textButton.DisabledColor = uniquePowerModifierConfig.UniquePowerModifierStausIconUIConfig.statusIconTextDisabledColor;
// update text current color
symbolText.color = textButton.NormalColor;
// update text symbol
symbolText.text = uniquePowerModifierConfig.UniquePowerModifierStausIconUIConfig.symbol;
// update background image color
backgroundImage.color = uniquePowerModifierConfig.UniquePowerModifierStausIconUIConfig.statusIconBackgroundColor;
// activate game object
gameObject.SetActive(true);
// Start animation
CoroutineQueueManager.Run(FadeBackground());
}
void AdjustCellCavasTextColorBasedOnWhetherItIsAdvisedToUseUPM(UniquePowerModifierConfig uniquePowerModifierConfig)
{
// adjust cell color if it is not advised to use UPM
if (!uniquePowerModifierConfig.IsItAdvisedToActInContextOf(GameContext.Context))
{
Debug.Log("Not Advised");
// not advised
CanvasText.color = uniquePowerModifierConfig.UniquePowerModifierUIConfig.ValidationUIConfig.upmIsApplicableButNotAdvisedForUnitSlotColor;
}
}
//public override void Apply(InventoryItem inventoryItem, PartyUnit dstPartyUnit, UniquePowerModifierConfig uniquePowerModifierConfig, UniquePowerModifierID uniquePowerModifierID)
//{
// throw new System.NotImplementedException();
//}
void ValidateTriggerCondition(UniquePowerModifierData uniquePowerModifierData)
{
// get unique power modifier config
UniquePowerModifierConfig uniquePowerModifierConfig = uniquePowerModifierData.GetUniquePowerModifierConfig();
// validate if condition has been configured correctly
if (uniquePowerModifierConfig.TriggerCondition != TriggerCondition.NonePassive)
{
Debug.LogWarning("Trigger condition should be set to None Passive for this UPM");
}
}
void Apply(PartyUnit srcPartyUnit, PartyUnit dstPartyUnit, UniquePowerModifierConfig uniquePowerModifierConfig, UniquePowerModifierID uniquePowerModifierID)
{
Debug.Log("Applying " + uniquePowerModifierConfig.DisplayName + " DoT " + " from " + srcPartyUnit.UnitName + " to " + dstPartyUnit.UnitName + ", origin is " + uniquePowerModifierID.modifierOrigin);
// init upm data variable (this is required for game save / restore)
UniquePowerModifierData uniquePowerModifierData = new UniquePowerModifierData
{
// set UPM ID
UniquePowerModifierID = uniquePowerModifierID,
// rest upm duration left to max duration
DurationLeft = uniquePowerModifierConfig.UpmDurationMax,
// set upm current power based on source unit stats upgrades count
//CurrentPower = uniquePowerModifierConfig.GetUpmCurrentPower(srcPartyUnit.StatsUpgradesCount)
CurrentPower = uniquePowerModifierConfig.GetUpmEffectivePower(srcPartyUnit)
};
// Apply UPM to the unit
ApplyUPMData(uniquePowerModifierData, dstPartyUnit, uniquePowerModifierConfig, uniquePowerModifierID);
//// find upm with the same modifier in the list of upms on destination party unit
//UniquePowerModifierData sameUPM = dstPartyUnit.AppliedUniquePowerModifiersData.Find(e => (e.UniquePowerModifierID == uniquePowerModifierID));
//// verify if the same UPM has already been found or applied (not null)
//if (sameUPM != null)
//{
// // verify if duration is not max already
// if (sameUPM.DurationLeft != uniquePowerModifierConfig.UpmDurationMax)
// {
// // reset existing UPM duration to max
// sameUPM.DurationLeft = uniquePowerModifierConfig.UpmDurationMax;
// // raise an event
// //uniquePowerModifierDurationHasBeenResetToMaxEvent.Raise(sameUPM);
// Events.DurationHasBeenResetToMaxEvent.Raise(sameUPM);
// }
// // verify if power is different
// if (sameUPM.CurrentPower != upmData.CurrentPower)
// {
// // reset its power to current power (in case power of source party unit has changed over time)
// sameUPM.CurrentPower = upmData.CurrentPower;
// // raise an event
// //uniquePowerModifierPowerHasBeenChangedEvent.Raise(sameUPM);
// Events.PowerHasBeenChangedEvent.Raise(sameUPM);
// }
//}
//else
//{
// // add new upm data to the list of upms on the destination unit
// dstPartyUnit.AppliedUniquePowerModifiersData.Add(upmData);
// // raise an event
// //uniquePowerModifierDataHasBeenAddedEvent.Raise(dstPartyUnit.gameObject);
// Events.DataHasBeenAddedEvent.Raise(dstPartyUnit.gameObject);
//}
}
public override void Apply(System.Object context)
{
// verify if context doesn't match requirements of this UPM
if (!DoesContextMatch(context))
{
// context is not in scope of this UPM
// skip all actions
return;
}
if (context is BattleContext)
{
// verify if source context is PartyUnit
if (BattleContext.ActivePartyUnitUI != null)
{
// verify if item has been dragged (if we are here, then it means that Item has been dropped onto the unit slot)
if (BattleContext.ItemBeingUsed != null)
{
// apply item UPM from Battle Context
InventoryItem srcInventoryItem = BattleContext.ItemBeingUsed;
PartyUnit dstPartyUnit = BattleContext.DestinationUnitSlot.GetComponentInChildren <PartyUnitUI>().LPartyUnit;
UniquePowerModifierConfig uniquePowerModifierConfig = srcInventoryItem.InventoryItemConfig.UniquePowerModifierConfigsSortedByExecutionOrder[BattleContext.ActivatedUPMConfigIndex];
UniquePowerModifierID uniquePowerModifierID = BattleContext.UniquePowerModifierID;
Apply(srcInventoryItem, dstPartyUnit, uniquePowerModifierConfig, uniquePowerModifierID);
}
else
{
// apply unit ability UPM
PartyUnit srcPartyUnit = BattleContext.ActivePartyUnitUI.LPartyUnit;
PartyUnit dstPartyUnit = BattleContext.DestinationUnitSlot.GetComponentInChildren <PartyUnitUI>().LPartyUnit;
UniquePowerModifierConfig uniquePowerModifierConfig = srcPartyUnit.UnitAbilityConfig.UniquePowerModifierConfigsSortedByExecutionOrder[BattleContext.ActivatedUPMConfigIndex];
UniquePowerModifierID uniquePowerModifierID = BattleContext.UniquePowerModifierID;
Apply(srcPartyUnit, dstPartyUnit, uniquePowerModifierConfig, uniquePowerModifierID);
}
}
else
{
Debug.LogError("Unknown source context");
}
}
if (context is EditPartyScreenContext)
{
// apply item UPM from edit party screen context
InventoryItem srcInventoryItem = EditPartyScreenContext.ItemBeingUsed;
PartyUnit dstPartyUnit = EditPartyScreenContext.DestinationUnitSlot.GetComponentInChildren <PartyUnitUI>().LPartyUnit;
UniquePowerModifierConfig uniquePowerModifierConfig = srcInventoryItem.InventoryItemConfig.UniquePowerModifierConfigsSortedByExecutionOrder[EditPartyScreenContext.ActivatedUPMConfigIndex];
UniquePowerModifierID uniquePowerModifierID = EditPartyScreenContext.UniquePowerModifierID;
Apply(srcInventoryItem, dstPartyUnit, uniquePowerModifierConfig, uniquePowerModifierID);
}
}
public UniquePowerModifierInfoData GetInfo()
{
UniquePowerModifierConfig uniquePowerModifierConfig = uniquePowerModifierData.GetUniquePowerModifierConfig();
return(new UniquePowerModifierInfoData
{
name = uniquePowerModifierConfig.DisplayName,
description = uniquePowerModifierConfig.Description,
additionalInfo = new string[] {
"Power: " + Math.Abs(uniquePowerModifierData.CurrentPower),
"Duration: " + uniquePowerModifierData.DurationLeft + "/" + uniquePowerModifierConfig.UpmDurationMax,
"Origin: " + uniquePowerModifierData.GetOriginDisplayName() + " " + uniquePowerModifierData.UniquePowerModifierID.modifierOrigin
}
});
}
void AddUPMInfo(PartyUnit partyUnit, Transform upmsListGrid, UniquePowerModifierConfig uniquePowerModifierConfig, ModifierOrigin modifierOrigin)
{
Transform upmTransform = Instantiate(uniquePowerModifierUITemplate, upmsListGrid).transform;
upmTransform.Find("Name").GetComponent <Text>().text = uniquePowerModifierConfig.DisplayName;
// upmTransform.Find("Power").GetComponent<Text>().text = Math.Abs(uniquePowerModifierConfig.GetUpmCurrentPower(partyUnit.StatsUpgradesCount)).ToString();
upmTransform.Find("Power").GetComponent <Text>().text = Math.Abs(uniquePowerModifierConfig.GetUpmEffectivePower(partyUnit)).ToString();
upmTransform.Find("Duration").GetComponent <Text>().text = uniquePowerModifierConfig.UpmDurationMax.ToString();
//// verify if duration left if is at least 1 day (which normally means that it will expire after upmDurationLeft days)
//if (uniquePowerModifier.upmDurationLeft >= 1)
//{
// upmTransform.Find("Duration").GetComponent<Text>().text += " e" + uniquePowerModifier.upmDurationLeft.ToString() + "d";
//}
upmTransform.Find("Source").GetComponent <Text>().text = uniquePowerModifierConfig.UpmSource.ToString();
upmTransform.Find("Origin").GetComponent <Text>().text = modifierOrigin.ToString();
}
public override void Apply(System.Object context)
{
// verify if context doesn't match requirements of this UPM
if (!DoesContextMatch(context))
{
// context is not in scope of this UPM
// skip all actions
return;
}
if (context is BattleContext)
{
PartyUnit srcPartyUnit = BattleContext.ActivePartyUnitUI.LPartyUnit;
PartyUnit dstPartyUnit = BattleContext.DestinationUnitSlot.GetComponentInChildren <PartyUnitUI>().LPartyUnit;
UniquePowerModifierConfig uniquePowerModifierConfig = srcPartyUnit.UnitAbilityConfig.UniquePowerModifierConfigsSortedByExecutionOrder[BattleContext.ActivatedUPMConfigIndex];
UniquePowerModifierID uniquePowerModifierID = BattleContext.UniquePowerModifierID;
Apply(srcPartyUnit, dstPartyUnit, uniquePowerModifierConfig, uniquePowerModifierID);
}
}
void Apply(InventoryItem inventoryItem, PartyUnit dstPartyUnit, UniquePowerModifierConfig uniquePowerModifierConfig, UniquePowerModifierID uniquePowerModifierID)
{
Debug.LogWarning("Applying " + uniquePowerModifierConfig.DisplayName + " from " + inventoryItem.ItemName + " to " + dstPartyUnit.UnitName + ", origin is " + uniquePowerModifierID.modifierOrigin);
// init upm data variable (this is required for Trigger)
UniquePowerModifierData uniquePowerModifierData = new UniquePowerModifierData
{
// set UPM ID
UniquePowerModifierID = uniquePowerModifierID,
// rest upm duration left to max duration
DurationLeft = uniquePowerModifierConfig.UpmDurationMax,
// set upm current power based on source unit stats upgrades count
//CurrentPower = uniquePowerModifierConfig.GetUpmCurrentPower(srcPartyUnit.StatsUpgradesCount)
CurrentPower = uniquePowerModifierConfig.GetUpmEffectivePower(inventoryItem)
};
// Apply UPM to the unit
ApplyUPMData(uniquePowerModifierData, dstPartyUnit, uniquePowerModifierConfig, uniquePowerModifierID);
}
public override void Apply(System.Object context)
{
// verify if context doesn't match requirements of this UPM
if (!DoesContextMatch(context))
{
// context is not in scope of this UPM
// skip all actions
return;
}
if (context is BattleContext)
{
// get active unit
PartyUnit activePartyUnit = BattleContext.ActivePartyUnitUI.LPartyUnit;
// get target unit
PartyUnit targetPartyUnit = BattleContext.TargetedUnitSlot.GetComponentInChildren <PartyUnitUI>().LPartyUnit;
UniquePowerModifierConfig uniquePowerModifierConfig = activePartyUnit.UnitAbilityConfig.UniquePowerModifierConfigsSortedByExecutionOrder[BattleContext.ActivatedUPMConfigIndex];
Debug.LogWarning("Applying " + uniquePowerModifierConfig.DisplayName + " from " + activePartyUnit.UnitName + " to " + targetPartyUnit.UnitName + ", origin is " + BattleContext.UniquePowerModifierID.modifierOrigin);
// validate if it is really instant UPM (max duration) is 0
// .. idea: do it in editor with warning highlight
if (uniquePowerModifierConfig.UpmDurationMax != 0)
{
Debug.LogWarning("UpmDurationMax should be 0");
}
// instantly trigger UPM, but apply it to src unit as heal
// Get UPM effective power
int upmEffectiPower = uniquePowerModifierConfig.GetUpmEffectivePower(activePartyUnit);
// init damage dealt variable
int damageDealt = upmEffectiPower; // current power is negative if it is damage dealing ability
// verify if damage dealt is not higher than current unit health
if (Math.Abs(damageDealt) > targetPartyUnit.UnitHealthCurr)
{
// reset damage dealt to the current unit health
damageDealt = targetPartyUnit.UnitHealthCurr;
}
// Heal active unit to amout of damage dealt
Debug.Log("Heal " + activePartyUnit.UnitName + " for " + Math.Abs(damageDealt) + " health");
activePartyUnit.UnitHealthCurr += Math.Abs(damageDealt);
// Damage target unit
targetPartyUnit.UnitHealthCurr += upmEffectiPower;
}
}
public void OnBattleNewUnitHasBeenActivatedEvent(System.Object context)
{
// verify if context is wrong
if (!(context is PartyUnitUI))
{
// exit
return;
}
// init error message (if cell is not targetable)
// .. set it dynamically based on limiter triggered
//string errorMessage = "Cannot target this cell";
// init is targetable
//bool isTargetable = false;
//// init and cache newly activated party unit UI from context
//activePartyUnitUI = (PartyUnitUI)context;
// reset battle context values (we don't want to have previously cached targeted party unit slot and upm index)
//BattleContext.Reset();
// cache active unit in battle context
//BattleContext.ActivePartyUnitUI = activePartyUnitUI;
// cache this unit slot as destination unit slot for battle context
BattleContext.DestinationUnitSlot = GetComponentInChildren <UnitSlot>();
// get UPM config
UniquePowerModifierConfig uniquePowerModifierConfig = BattleContext.ActivePartyUnitUI.LPartyUnit.UnitAbilityConfig.PrimaryUniquePowerModifierConfig;
// Highlight unit canvas based on whether UPM is applicable to this unit or not
// isTargetable = GetIsTargetableAndHighlightUnitCanvasBasedOnUPMConfigApplicability(uniquePowerModifierConfig);
ModifierLimiter.ValidationResult validationResult = uniquePowerModifierConfig.AreRequirementsMetInContextOf(GameContext.Context);
// set UnitSlot in cell as targetable or not
//GetComponentInChildren<UnitSlot>().SetOnClickAction(isTargetable, errorMessage);
GetComponentInChildren <UnitSlot>().SetOnClickAction(validationResult);
// set unit cell color based on validation result
SetCanvasTextColorBasedOnUPMValidationResult(validationResult, uniquePowerModifierConfig);
// adjust cell color if it is not advised to use UPM
AdjustCellCavasTextColorBasedOnWhetherItIsAdvisedToUseUPM(uniquePowerModifierConfig);
// verify and set canvas highlight
SetCellCavastTextHighlight();
}
void Apply(PartyUnit srcPartyUnit, PartyUnit dstPartyUnit, UniquePowerModifierConfig uniquePowerModifierConfig, UniquePowerModifierID uniquePowerModifierID)
{
Debug.LogWarning("Applying " + uniquePowerModifierConfig.DisplayName + " from " + srcPartyUnit.UnitName + " to " + dstPartyUnit.UnitName + ", origin is " + uniquePowerModifierID.modifierOrigin);
// init upm data variable (this is required for Trigger)
UniquePowerModifierData uniquePowerModifierData = new UniquePowerModifierData
{
// set UPM ID
UniquePowerModifierID = uniquePowerModifierID,
// rest upm duration left to max duration
DurationLeft = uniquePowerModifierConfig.UpmDurationMax,
// set upm current power based on source unit stats upgrades count
//CurrentPower = uniquePowerModifierConfig.GetUpmCurrentPower(srcPartyUnit.StatsUpgradesCount)
CurrentPower = uniquePowerModifierConfig.GetUpmEffectivePower(srcPartyUnit)
};
// validate if it is really instant UPM (max duration) is 0
// .. idea: do it in editor with warning highlight
if (uniquePowerModifierConfig.UpmDurationMax != 0)
{
Debug.LogWarning("UpmDurationMax should be 0");
}
// instantly trigger UPM
Trigger(dstPartyUnit, uniquePowerModifierData);
}
//bool GetIsTargetableAndHighlightUnitCanvasBasedOnUPMConfigApplicability(UniquePowerModifierConfig uniquePowerModifierConfig)
//{
// // verify if active party unit ability is applicable to this cell (example: summon) and party unit (if it is present)
// //if (uniquePowerModifierConfig.AreRequirementsMetInContextOf(activePartyUnitUI.GetComponentInParent<PartyPanelCell>(), this))
// //if (uniquePowerModifierConfig.AreRequirementsMetInContextOf(BattleContext.Instance))
// if (uniquePowerModifierConfig.AreRequirementsMetInContextOf(GameContext.Context))
// {
// Debug.Log("Cell Requirements are met");
// // verify if party unit is not present, because if it is present, then we need to give it a possibility to override "applicability"
// // it maybe already overritten, because PartyUnitUI could possibly react earlier on event
// // get party unit UI
// PartyUnitUI partyUnitUI = GetComponentInChildren<PartyUnitUI>();
// // verify if its not null
// if (partyUnitUI != null)
// {
// // let party unit override highlights and react on begin item drag event
// return partyUnitUI.ActOnBattleNewUnitHasBeenActivatedEvent();
// }
// else
// {
// // highlight with applicable color
// CanvasText.color = uniquePowerModifierConfig.UniquePowerModifierUIConfig.ValidationUIConfig.upmIsApplicableForUnitSlotColor;
// // targetable
// return true;
// }
// }
// else
// {
// Debug.Log("Cell Requirements are not met");
// // highlight with not applicable color
// CanvasText.color = uniquePowerModifierConfig.UniquePowerModifierUIConfig.ValidationUIConfig.upmIsNotApplicableForUnitSlotColor;
// // not targetable
// return false;
// }
//}
public void SetCanvasTextColorBasedOnUPMValidationResult(ModifierLimiter.ValidationResult validationResult, UniquePowerModifierConfig uniquePowerModifierConfig)
{
if (validationResult.doDiscardModifier)
{
// highlight with not applicable color
CanvasText.color = uniquePowerModifierConfig.UniquePowerModifierUIConfig.ValidationUIConfig.upmIsNotApplicableForUnitSlotColor;
}
else
{
CanvasText.color = uniquePowerModifierConfig.UniquePowerModifierUIConfig.ValidationUIConfig.upmIsApplicableForUnitSlotColor;
}
}
public void OnBeginItemDrag()
{
// Debug.LogWarning("OnBeginItemDrag");
// save original color
// Debug.LogWarning("Save original color");
beforeItemDragColor = CanvasText.color;
// set battle item context
//BattleContext.ItemBeingUsed = InventoryItemDragHandler.itemBeingDragged.LInventoryItem;
// cache this unit slot as destination unit slot for battle context
GameContext.SetDestinationUnitSlot(GetComponentInChildren <UnitSlot>());
// get UPM config
UniquePowerModifierConfig uniquePowerModifierConfig = GameContext.GetItemBeingUsed().InventoryItemConfig.PrimaryUniquePowerModifierConfig;
// Highlight unit canvas based on whether UPM is applicable to this unit or not
// isTargetable = GetIsTargetableAndHighlightUnitCanvasBasedOnUPMConfigApplicability(uniquePowerModifierConfig);
ModifierLimiter.ValidationResult validationResult = uniquePowerModifierConfig.AreRequirementsMetInContextOf(GameContext.Context);
// set UnitSlot in cell as targetable or not
//GetComponentInChildren<UnitSlot>().SetOnClickAction(isTargetable, errorMessage);
GetComponentInChildren <UnitSlot>().SetOnClickAction(validationResult);
// set unit cell color based on validation result
SetCanvasTextColorBasedOnUPMValidationResult(validationResult, uniquePowerModifierConfig);
// adjust cell color if it is not advised to use UPM
AdjustCellCavasTextColorBasedOnWhetherItIsAdvisedToUseUPM(uniquePowerModifierConfig);
//// verify if item is usable
//if (uniquePowerModifierConfig.AreRequirementsMetInContextOf(BattleContext.ItemBeingUsed, this))
//{
// Debug.Log("Cell Requirements are met");
// // verify if party unit is not present, because if it is present, then we need to give it a possibility to override "applicability"
// // it maybe already overritten, because PartyUnitUI could possibly react earlier on event
// // get party unit UI
// PartyUnitUI partyUnitUI = GetComponentInChildren<PartyUnitUI>();
// // verify if its not null
// if (partyUnitUI != null)
// {
// // let party unit override highlights and react on begin item drag event
// partyUnitUI.ActOnBeginItemDrag();
// }
// else
// {
// // highlight with applicable color
// // CanvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsApplicableForUnitSlotColor;
// CanvasText.color = uniquePowerModifierConfig.UniquePowerModifierUIConfig.ValidationUIConfig.upmIsApplicableForUnitSlotColor;
// }
//}
//else
//{
// Debug.Log("Cell Requirements are not met");
// // highlight with not applicable color
// // CanvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsNotApplicableForUnitSlotColor;
// CanvasText.color = uniquePowerModifierConfig.UniquePowerModifierUIConfig.ValidationUIConfig.upmIsNotApplicableForUnitSlotColor;
//}
//// verify if item has active modifiers or usages
//if (InventoryItemDragHandler.itemBeingDragged.LInventoryItem.HasActiveModifiers())
//{
// Debug.Log("Item has active modifiers");
// // get party unit UI
// PartyUnitUI partyUnitUI = GetComponentInChildren<PartyUnitUI>();
// // verify if its not null
// if (partyUnitUI != null)
// {
// Debug.Log("Found partyUnitUI");
// // activate highlight
// // get source context
// // try to get party unit (assume that during battle unit can only use items which are located in (childs of) this unit game object)
// // if outside of the battle or if item is dragged from inventiry, then this will result in null
// System.Object srcContext = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.GetComponentInParent<PartyUnit>();
// // verify if srcPartyUnit is null
// if (srcContext == null)
// {
// // context is hero party (item is dragged from inventory)
// // get party
// HeroParty heroParty = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.GetComponentInParent<HeroParty>();
// // verify if party is garnizon type
// if (heroParty.PartyMode == PartyMode.Garnizon)
// {
// // set context to the city
// srcContext = heroParty.GetComponentInParent<City>();
// }
// else
// {
// // party mode = normal party
// // set context to the party leader
// srcContext = heroParty.GetPartyLeader();
// }
// }
// // verify if UPM can be applied to destination unit
// if (InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.uniquePowerModifierConfigs[0].AreRequirementsMetInContextOf(srcContext, partyUnitUI.LPartyUnit) )
// {
// Debug.Log("Requirements are met");
// // verify if it is advised to use this item in this context
// if (InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.uniquePowerModifierConfigs[0].IsItAdvisedToActInContextOf(srcContext, partyUnitUI.LPartyUnit))
// {
// Debug.Log("Advised");
// // advised
// // item can be applied to this hero, highlight with applicable color
// canvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsApplicableForUnitSlotColor;
// }
// else
// {
// Debug.Log("Not Advised");
// // not advised
// // item can be applied to this hero, highlight with applicable color
// canvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsApplicableButNotAdvisedForUnitSlotColor;
// }
// }
// else
// {
// Debug.Log("Requirements are not met");
// // item cannot be applied to this hero, highlight with not applicable color
// canvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsNotApplicableForUnitSlotColor;
// }
// //// try to consume item in preview mode without actually doing anything
// //if (partyUnitUI.LPartyUnit.UseItem(InventoryItemDragHandler.itemBeingDragged.LInventoryItem, true))
// //{
// // // item can be applied to this hero, highlight with applicable color
// // canvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsApplicableForUnitSlotColor;
// //}
// //else
// //{
// // // item cannot be applied to this hero, highlight with not applicable color
// // canvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsNotApplicableForUnitSlotColor;
// //}
// }
// else
// {
// Debug.Log("no party unit UI");
// // there is no hero in this slot, highlight with not applicable color
// canvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsNotApplicableForUnitSlotColor;
// }
//}
//else
//{
// Debug.Log("Item has no active modifiers");
// // item is not consumable, highlight with not applicable color
// canvasText.color = InventoryItemDragHandler.itemBeingDragged.LInventoryItem.InventoryItemConfig.inventoryItemUIConfig.itemIsNotApplicableForUnitSlotColor;
//}
}
//public void DeactivateExpiredBuffs()
//{
// // Deactivate expired buffs in UI
// // PartyUnit unit = GetComponent<PartyUnit>();
// UnitBuffIndicator[] buffsUI = GetUnitBuffsPanel().GetComponentsInChildren<UnitBuffIndicator>();
// foreach (UnitBuffIndicator buffUI in buffsUI)
// {
// // First decrement buff current duration
// buffUI.DecrementCurrentDuration();
// // Verify if it has timed out;
// if (buffUI.GetCurrentDuration() == 0)
// {
// // buff has timed out
// // deactivate it (it will be destroyed at the end of animation)
// buffUI.SetActiveAdvance(false);
// // deactivate it in unit properties too
// LPartyUnit.UnitBuffs[(int)buffUI.GetUnitBuff()] = UnitBuff.None;
// }
// }
//}
public void TriggerAppliedUniquePowerModifiers()
{
//Debug.Log("TriggerAppliedDebuffs");
//UnitDebuffIndicator[] debuffsIndicators = GetUnitDebuffsPanel().GetComponentsInChildren<UnitDebuffIndicator>();
////UnitDebuffsUI unitDebuffsUI = unit.GetUnitDebuffsPanel().GetComponent<UnitDebuffsUI>();
//foreach (UnitDebuffIndicator debuffIndicator in debuffsIndicators)
//{
// Debug.Log(name);
// // as long as we cannot initiate all debuffs at the same time
// // we add debuffs to the queue and they will be triggered one after another
// // CoroutineQueue queue = unitDebuffsUI.GetQueue();
// // CoroutineQueue queue = transform.root.GetComponentInChildren<UIManager>().GetComponentInChildren<BattleScreen>(true).Queue;
// //if (queue == null)
// //{
// // Debug.LogError("No queue");
// //}
// //if (debuffIndicator == null)
// //{
// // Debug.LogError("No debuffIndicator");
// //}
// IEnumerator coroutine = debuffIndicator.TriggerDebuff(this);
// //if (coroutine == null)
// //{
// // Debug.LogError("No coroutine");
// //}
// CoroutineQueueManager.Run(coroutine);
// // Trigger debuff against player
// // Decrement buff current duration
// debuffIndicator.DecrementCurrentDuration();
//}
// Loop through all UPMs on this party unit in backwards order (so we can remove items in a loop)
for (int i = LPartyUnit.AppliedUniquePowerModifiersData.Count - 1; i >= 0; i--)
{
// get UPM config
UniquePowerModifierConfig uniquePowerModifierConfig = LPartyUnit.AppliedUniquePowerModifiersData[i].GetUniquePowerModifierConfig();
// verify if trigger condition matches
if (uniquePowerModifierConfig.TriggerCondition == TriggerCondition.AtTurnStart)
{
// Gget UPM text animation config upfront, because UPMdata may be removed if unit is dead after Trigger
TextAnimation upmTextAnimation = uniquePowerModifierConfig.UniquePowerModifierStausIconUIConfig.onTriggerTextAnimation;
// Trigger UPM
LPartyUnit.AppliedUniquePowerModifiersData[i].GetUniquePowerModifierConfig().Trigger(LPartyUnit, LPartyUnit.AppliedUniquePowerModifiersData[i]);
// trigger animation to display damage done
upmTextAnimation.Run(UnitInfoPanelText);
// verify if unit is still alive
if (LPartyUnit.UnitStatus != UnitStatus.Dead)
{
// verify if UPM duration left is 0
if (LPartyUnit.AppliedUniquePowerModifiersData[i].DurationLeft == 0)
{
// UPM has expired
// trigger UPM removed event
//LPartyUnit.UnitEvents.uniquePowerModifierHasBeenRemovedEvent.Raise(LPartyUnit.UniquePowerModifiersData[i]);
LPartyUnit.AppliedUniquePowerModifiersData[i].GetUniquePowerModifierConfig().UniquePowerModifier.Events.DataHasBeenRemovedEvent.Raise(LPartyUnit.AppliedUniquePowerModifiersData[i]);
// remove it from the list
LPartyUnit.AppliedUniquePowerModifiersData.RemoveAt(i);
}
}
else
{
// all UPMs data already should be removed in party unit UnitHealthCurr property
// exit this loop
break;
}
}
}
}
void ApplyUPMData(UniquePowerModifierData uniquePowerModifierData, PartyUnit dstPartyUnit, UniquePowerModifierConfig uniquePowerModifierConfig, UniquePowerModifierID uniquePowerModifierID)
{
// .. just in case
ValidateTriggerCondition(uniquePowerModifierData);
// find upm with the same modifier in the list of upms on destination party unit
UniquePowerModifierData sameUPM = dstPartyUnit.AppliedUniquePowerModifiersData.Find(e => (e.UniquePowerModifierID == uniquePowerModifierID));
// verify if the same UPM has already been found or applied (not null)
if (sameUPM != null)
{
// verify if duration is not max already
if (sameUPM.DurationLeft != uniquePowerModifierConfig.UpmDurationMax)
{
// reset existing UPM duration to max
sameUPM.DurationLeft = uniquePowerModifierConfig.UpmDurationMax;
// raise an event
//uniquePowerModifierDurationHasBeenResetToMaxEvent.Raise(sameUPM);
Events.DurationHasBeenResetToMaxEvent.Raise(sameUPM);
}
// verify if power is different
if (sameUPM.CurrentPower != uniquePowerModifierData.CurrentPower)
{
// reset its power to current power (in case power of source party unit has changed over time)
sameUPM.CurrentPower = uniquePowerModifierData.CurrentPower;
// raise an event
//uniquePowerModifierPowerHasBeenChangedEvent.Raise(sameUPM);
Events.PowerHasBeenChangedEvent.Raise(sameUPM);
}
}
else
{
// add new upm data to the list of upms on the destination unit
dstPartyUnit.AppliedUniquePowerModifiersData.Add(uniquePowerModifierData);
// raise an event
//uniquePowerModifierDataHasBeenAddedEvent.Raise(dstPartyUnit.gameObject);
Events.DataHasBeenAddedEvent.Raise(dstPartyUnit.gameObject);
}
}
