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); } }