// Add Item Logic
#region
public void AddItemToInventory(ItemDataSO itemAdded, bool playCardRewardOverlayEffect = false)
{
Debug.Log("InventoryController.AddItemToInventory() called for " + itemAdded.Name);
// Enable char roster sparkle
UIManager.Instance.SetCharacterRosterButtonParticleViewState(true);
// Play screen overlay VFX
if (playCardRewardOverlayEffect)
{
CardRewardScreenManager.Instance.CreateItemCardRewardEffect(itemAdded);
}
// Modify player score
ScoreManager.Instance.itemsCollected++;
if (itemAdded.itemRarity == ItemDataSO.ItemRarity.Epic)
{
ScoreManager.Instance.epicItemsCollected++;
}
// Create item
GameObject newInventoryItem = Instantiate(PrefabHolder.Instance.InventoryItem, itemsParent.transform);
InventoryItemCard itemCard = newInventoryItem.GetComponent <InventoryItemCard>();
// Place item in inventory
PlaceItemOnInventorySlot(itemCard, GetNextAvailableSlot());
ItemManager.Instance.SetUpInventoryItemCardFromData(itemCard, itemAdded, inventoryItemCardSortingOrder);
}
public Action CreateItemCardRewardEffect(ItemDataSO itemData)
{
Action action = new Action();
StartCoroutine(CreateItemCardRewardEffectCoroutine(itemData, action));
return(action);
}
public void SetUpItemSlot(ItemDataSO.ItemRarity rarity)
{
EnableItemSlotView();
ItemDataSO itemData = null;
int randomGoldCost = 0;
if (rarity == ItemDataSO.ItemRarity.Common)
{
itemData = ItemLibrary.Instance.GetRandomCommonItem();
randomGoldCost = Random.Range(40, 60);
}
else if (rarity == ItemDataSO.ItemRarity.Rare)
{
itemData = ItemLibrary.Instance.GetRandomRareItem();
randomGoldCost = Random.Range(60, 100);
}
else if (rarity == ItemDataSO.ItemRarity.Epic)
{
itemData = ItemLibrary.Instance.GetRandomEpicItem();
randomGoldCost = Random.Range(100, 200);
}
myItemCard.RunSetupFromItemData(itemData);
myItemCard.myItemSlot = this;
myItemCard.inShop = true;
SetGoldCost(randomGoldCost);
}
// Initialization + Setup
#region
public void SetUpItemSlot(ItemDataSO.ItemRarity rarity)
{
EnableItemSlotView();
ItemDataSO itemData = null;
int randomGoldCost = 0;
if (rarity == ItemDataSO.ItemRarity.Common)
{
itemData = ItemLibrary.Instance.GetRandomCommonItem();
randomGoldCost = Random.Range(4, 8);
}
else if (rarity == ItemDataSO.ItemRarity.Rare)
{
itemData = ItemLibrary.Instance.GetRandomRareItem();
randomGoldCost = Random.Range(8, 12);
}
else if (rarity == ItemDataSO.ItemRarity.Epic)
{
itemData = ItemLibrary.Instance.GetRandomEpicItem();
randomGoldCost = Random.Range(14, 18);
}
myItemCard.RunSetupFromItemData(itemData, ShopScreenManager.Instance.itemSlotSortingLayer);
myItemCard.myItemSlot = this;
myItemCard.location = ItemCard.Location.Shop;
SetGoldCost(randomGoldCost);
}
// Get Data
#region
public string GetDamageTypeFromWeapon(ItemDataSO weapon)
{
Debug.Log("ItemManager.GetDamageTypeFromWeapon() called...");
string damageTypeStringReturned = weapon.weaponDamageType.ToString();
Debug.Log("ItemManager.GetDamageTypeFromWeapon() detected that " + weapon.Name + " has a damage type of " + damageTypeStringReturned);
return(damageTypeStringReturned);
}
// Get Item Data Logic
#region
public List <ItemDataSO> GetAllOtherItemSlots(ItemDataSO itemToExclude)
{
List <ItemDataSO> allOtherItems = new List <ItemDataSO>();
allOtherItems.AddRange(itemsInShopData);
if (allOtherItems.Contains(itemToExclude))
{
allOtherItems.Remove(itemToExclude);
}
return(allOtherItems);
}
public void CreateAndAddItemDirectlyToCharacter(ItemDataSO itemAdded, CharacterItemSlot weaponSlot)
{
// Method used to set characters up with default items. Will be used later again when character presets are set up
Debug.Log("InventoryController.AddItemToInventory() called for " + itemAdded.Name);
GameObject newInventoryItem = Instantiate(PrefabHolder.Instance.InventoryItem, itemsParent.transform);
InventoryItemCard itemCard = newInventoryItem.GetComponent <InventoryItemCard>();
itemCard.transform.localScale = new Vector3(1, 1, 1);
ItemManager.Instance.SetUpInventoryItemCardFromData(itemCard, itemAdded, inventoryItemCardSortingOrder);
PlaceItemOnCharacterSlot(itemCard, weaponSlot);
}
public void SetUpInventoryItemCardFromData(InventoryItemCard itemCard, ItemDataSO data, int sortingOrder)
{
Debug.Log("InventoryController.AddItemToInventory() called for " + data.Name);
itemCard.myItemData = data;
itemCard.itemImage.sprite = data.sprite;
itemCard.myInfoItemCard.RunSetupFromItemData(data, sortingOrder);
itemCard.myInfoItemCard.location = ItemCard.Location.Inventory;
itemCard.myInfoItemCard.mainCanvas.sortingOrder = 3100;
}
// Initialization + Setup
#region
public void BuildWeaponTabElements(ItemDataSO item)
{
Debug.Log("ItemCardPanelHover.BuildWeaponTabElements() called...");
// Set sprite first
if (item.weaponDamageType == ItemDataSO.WeaponDamageType.Physical)
{
//weaponInfoTab.image.sprite = physicalSprite;
weaponInfoTab.passiveInfoSheet.abilityImage.sprite = physicalSprite;
}
else if (item.weaponDamageType == ItemDataSO.WeaponDamageType.Fire)
{
// weaponInfoTab.image.sprite = fireSprite;
weaponInfoTab.passiveInfoSheet.abilityImage.sprite = fireSprite;
}
else if (item.weaponDamageType == ItemDataSO.WeaponDamageType.Frost)
{
// weaponInfoTab.image.sprite = frostSprite;
weaponInfoTab.passiveInfoSheet.abilityImage.sprite = frostSprite;
}
else if (item.weaponDamageType == ItemDataSO.WeaponDamageType.Poison)
{
//weaponInfoTab.image.sprite = poisonSprite;
weaponInfoTab.passiveInfoSheet.abilityImage.sprite = poisonSprite;
}
else if (item.weaponDamageType == ItemDataSO.WeaponDamageType.Shadow)
{
//weaponInfoTab.image.sprite = shadowSprite;
weaponInfoTab.passiveInfoSheet.abilityImage.sprite = shadowSprite;
}
else if (item.weaponDamageType == ItemDataSO.WeaponDamageType.Air)
{
//weaponInfoTab.image.sprite = airSprite;
weaponInfoTab.passiveInfoSheet.abilityImage.sprite = airSprite;
}
// Set description Text
weaponInfoTab.passiveInfoSheet.descriptionText.text = "This weapon deals " +
TextLogic.ReturnColoredText(item.baseDamage.ToString(), TextLogic.yellow) + " " +
TextLogic.ReturnColoredText(item.weaponDamageType.ToString(), TextLogic.GetColorCodeFromString(item.weaponDamageType.ToString())) +
" damage";
// Set name text
weaponInfoTab.passiveInfoSheet.nameText.text = "Weapon";
// Set pivot
PassiveInfoSheetController.Instance.SetPivotDirection(weaponInfoTab.passiveInfoSheet, PassiveInfoSheet.PivotDirection.Downwards);
}
// Set up item cards + etc
#region
public void SetUpItemCardFromData(ItemCard itemCard, ItemDataSO data, int sortingOrder)
{
Debug.Log("ItemManager.RunSetupFromItemData() called for: " + data.Name);
// Set scale
itemCard.originalScale = itemCard.GetComponent <RectTransform>().localScale.x;
// Store data
itemCard.myItemDataSO = data;
// Set canvas sorting order
itemCard.mainCanvas.sortingOrder = sortingOrder;
// Set properties
itemCard.myName = data.Name;
itemCard.myNameText.text = data.Name;
itemCard.itemImage.sprite = data.sprite;
itemCard.myDescriptionText.text = data.itemDescription;
itemCard.myItemTypeText.text = ConvertItemTypeEnumToString(data.itemType);
// Weapon specific set up
if (IsItemWeapon(data))
{
// Turn on damage type icon
itemCard.weaponDamageTypeParent.SetActive(true);
// Get and set correct damage type sprite
itemCard.itemDamageTypeImage.sprite = GetWeaponDamageTypeImage(data);
// Set base damage text
itemCard.myBaseDamageText.text = data.baseDamage.ToString();
}
// Set up ribbon + frame rarity sprites
if (data.itemRarity == ItemDataSO.ItemRarity.Common)
{
itemCard.commonParent.SetActive(true);
}
else if (data.itemRarity == ItemDataSO.ItemRarity.Rare)
{
itemCard.rareParent.SetActive(true);
}
else if (data.itemRarity == ItemDataSO.ItemRarity.Epic)
{
itemCard.epicParent.SetActive(true);
}
}
// Bools and conditional checks
#region
public bool IsItemWeapon(ItemDataSO item)
{
Debug.Log("ItemManager.IsItemWeapon() called for: " + item.Name);
if (item.itemType == ItemDataSO.ItemType.MeleeOneHand ||
item.itemType == ItemDataSO.ItemType.MeleeTwoHand ||
item.itemType == ItemDataSO.ItemType.RangedTwoHand)
{
Debug.Log(item.Name + " is a weapon");
return(true);
}
else
{
Debug.Log(item.Name + " is NOT a weapon");
return(false);
}
}
// Conditional Checks + Boolean logic
#region
public bool IsItemAlreadyInShop(ItemSlot slotToCheck)
{
bool alreadyInShop = false;
ItemDataSO itemChecked = slotToCheck.myItemCard.myItemDataSO;
foreach (ItemSlot slot in allItemsSlots)
{
if (slot.myItemCard.myItemDataSO != null &&
slot.myItemCard.myItemDataSO.Name == itemChecked.Name &&
slot != slotToCheck)
{
alreadyInShop = true;
break;
}
}
return(alreadyInShop);
}
public ItemDataSO GetItemByName(string itemName)
{
ItemDataSO itemReturned = null;
foreach (ItemDataSO itemData in allItems)
{
if (itemData.itemName == itemName)
{
itemReturned = itemData;
}
}
if (itemReturned == null)
{
Debug.Log("ItemLibrary.GetItem() search error: could not find a matching item in library");
}
return(itemReturned);
}
public ItemDataSO GetRandomLootRewardItem()
{
ItemDataSO itemReturned = null;
int randomNumber = Random.Range(0, 100);
if (randomNumber >= 0 && randomNumber <= 69)
{
itemReturned = GetRandomCommonItem();
}
else if (randomNumber >= 70 && randomNumber <= 94)
{
itemReturned = GetRandomRareItem();
}
else if (randomNumber >= 95 && randomNumber <= 99)
{
itemReturned = GetRandomEpicItem();
}
return(itemReturned);
}
public void ApplyAllItemEffectsToCharacterData(CharacterData character, ItemDataSO item, bool removing = false)
{
Debug.Log("ItemManager.ApplyAllItemEffectsToCharacterData() called for " + item.Name);
// Check item effect one
if (item.itemEffectOne != ItemDataSO.ItemEffect.None)
{
ApplyItemEffectToCharacterData(character, item.itemEffectOne, item.itemEffectOneValue, removing);
}
// Check item effect two
if (item.itemEffectTwo != ItemDataSO.ItemEffect.None)
{
ApplyItemEffectToCharacterData(character, item.itemEffectTwo, item.itemEffectTwoValue, removing);
}
// Check item effect three
if (item.itemEffectThree != ItemDataSO.ItemEffect.None)
{
ApplyItemEffectToCharacterData(character, item.itemEffectThree, item.itemEffectThreeValue, removing);
}
}
public Sprite GetWeaponDamageTypeImage(ItemDataSO data)
{
Debug.Log("GetWeaponDamageTypeImage() called...");
if (data.weaponDamageType == ItemDataSO.WeaponDamageType.Physical)
{
return(physicalDamageSprite);
}
else if (data.weaponDamageType == ItemDataSO.WeaponDamageType.Fire)
{
return(fireDamageSprite);
}
else if (data.weaponDamageType == ItemDataSO.WeaponDamageType.Frost)
{
return(frostDamageSprite);
}
else if (data.weaponDamageType == ItemDataSO.WeaponDamageType.Poison)
{
return(poisonDamageSprite);
}
else if (data.weaponDamageType == ItemDataSO.WeaponDamageType.Air)
{
return(airDamageSprite);
}
else if (data.weaponDamageType == ItemDataSO.WeaponDamageType.Shadow)
{
return(shadowDamageSprite);
}
else
{
Debug.Log("GetWeaponDamageTypeImage() coudln't detect damage type, returning a null sprite...");
return(null);
}
}
// Get ItemDataSO Logic
#region
public ItemDataSO GetItemByName(string itemName)
{
Debug.Log("ItemLibrary.GetItemByName() called, searching for " + itemName);
ItemDataSO itemReturned = null;
foreach (ItemDataSO itemData in allItems)
{
if (itemData.Name == itemName)
{
itemReturned = itemData;
break;
}
}
if (itemReturned == null)
{
Debug.Log("ItemLibrary.GetItemByName() search error: could not find a matching item in library with the name " + itemName);
}
return(itemReturned);
}
public void RunSetupFromItemData(ItemDataSO data)
{
myItemDataSO = data;
Debug.Log("RunSetupFromItemData() called...");
myName = data.itemName;
myNameText.text = myName;
myDescriptionText.text = data.itemDescription;
myImageComponent.sprite = data.itemImage;
myItemRarity = data.itemRarity;
if (myItemRarity == ItemDataSO.ItemRarity.Common)
{
myRarityFrame.color = data.commonColour;
}
else if (myItemRarity == ItemDataSO.ItemRarity.Rare)
{
myRarityFrame.color = data.rareColour;
}
else if (myItemRarity == ItemDataSO.ItemRarity.Epic)
{
myRarityFrame.color = data.epicColour;
}
}
// Setup + Initialization
#region
public void RunSetupFromItemData(ItemDataSO data, int sortingOrder)
{
ItemManager.Instance.SetUpItemCardFromData(this, data, sortingOrder);
myData = data;
}
// Initialization + Setup
#region
public void BuildItemCardRewardOverlayFromData(ItemDataSO data, ItemCardRewardOverlay card)
{
ItemManager.Instance.SetUpItemCardFromData(card.itemCard, data, itemCardSortingOrder);
}
private IEnumerator CreateItemCardRewardEffectCoroutine(ItemDataSO itemData, Action action)
{
// Create Card object
GameObject newItemCardGO = Instantiate(itemCardEffectPrefab, cardParent);
ItemCardRewardOverlay newItemCard = newItemCardGO.GetComponent <ItemCardRewardOverlay>();
// Set up card properties
BuildItemCardRewardOverlayFromData(itemData, newItemCard);
// Scale down card
SetParentScale(newItemCard.itemCardScaleParent, new Vector3(0.005f, 0.005f, 0.005f));
// Insert Delay, break up multiple simoltaenous reveals
yield return(new WaitForSeconds(CalculateCardRevealDelay()));
// Get next available slot position
CardRewardScreenSlot mySlot = GetNextAvailableSlotPosition();
// dont proceed unless a slot is available
if (mySlot == null)
{
action.actionResolved = true;
yield break;
}
// Move to starting slot position
newItemCard.masterLocationParent.position = mySlot.parentTransform.position;
// Start scaling card back to normal size
Action scaleEffect = ScaleUpCard(newItemCard.itemCardScaleParent, 1);
yield return(new WaitUntil(() => scaleEffect.actionResolved == true));
// Brief pause, so player can read the card
yield return(new WaitForSeconds(1));
// Free up slot
mySlot.occupied = false;
// Start scaling card back down
ScaleDownCard(newItemCard.itemCardScaleParent, 0.01f);
// Start card rotation towards destination
RotateCardZAxis(newItemCard.itemCardScaleParent, -45);
// Enable Sparkle Effect
newItemCard.sparkleParticleEffectParent.SetActive(true);
// Move character panel button position
Action moveEffect = MoveCardToDestination(newItemCard.masterLocationParent, charRosterButtonEndPosition.position);
yield return(new WaitUntil(() => moveEffect.actionResolved == true));
// Create mini explosion on char roster button
GameObject newPE = Instantiate(lootExplosionEffectPrefab, cardParent);
newPE.transform.position = charRosterButtonEndPosition.position;
// Destroy item card
Destroy(newItemCardGO);
// Resolve
action.actionResolved = true;
}
public int GetFinalDamageValueAfterAllCalculations(LivingEntity attacker, LivingEntity target, Ability abilityUsed, string damageType, bool critical, int baseDamage, ItemDataSO weaponUsed = null)
{
Debug.Log("CombatLogic.GetFinalDamageValueAfterAllCalculations() called...");
int finalDamageValueReturned = 0;
// calculate base damage
finalDamageValueReturned = GetBaseDamageValue(attacker, baseDamage, abilityUsed, damageType, weaponUsed);
Debug.Log("CombatLogic.GetFinalDamageValueAfterAllCalculations() finalDamageValueReturned value after base calculations: " + finalDamageValueReturned.ToString());
// calculate damage after standard modifiers
finalDamageValueReturned = GetDamageValueAfterNonResistanceModifiers(finalDamageValueReturned, attacker, target, abilityUsed, damageType, critical);
Debug.Log("CombatLogic.GetFinalDamageValueAfterAllCalculations() finalDamageValueReturned value after non resistance modifier calculations: " + finalDamageValueReturned.ToString());
// calcualte damage value after resistances
if (attacker.defender &&
StateManager.Instance.DoesPlayerAlreadyHaveState("Godly"))
{
Debug.Log("CombatLogic.GetFinalDamageValueAfterAllCalculations() detected that attacker is defender and has state 'Godly', ignoring target resistances...");
}
else
{
finalDamageValueReturned = GetDamageValueAfterResistances(finalDamageValueReturned, damageType, target);
Debug.Log("CombatLogic.GetFinalDamageValueAfterAllCalculations() finalDamageValueReturned value after resitance type calculations: " + finalDamageValueReturned.ToString());
}
// return final value
Debug.Log("CombatLogic.GetFinalDamageValueAfterAllCalculations() finalDamageValueReturned final value returned: " + finalDamageValueReturned.ToString());
return(finalDamageValueReturned);
}
public void UpdateCharacterAbilitiesFromWeapons(CharacterData character)
{
Debug.Log("InventoryController.UpdateCharacterAbilitiesFromWeapons() called...");
List <AbilityDataSO> abilitiesToLearn = new List <AbilityDataSO>();
ItemDataSO mainHandWeapon = character.mainHandWeapon;
ItemDataSO offHandWeapon = character.offHandWeapon;
AbilityDataSO strike = AbilityLibrary.Instance.GetAbilityByName("Strike");
AbilityDataSO defend = AbilityLibrary.Instance.GetAbilityByName("Defend");
AbilityDataSO shoot = AbilityLibrary.Instance.GetAbilityByName("Shoot");
AbilityDataSO twinStrike = AbilityLibrary.Instance.GetAbilityByName("Twin Strike");
// Unlearn previous weapon related abilities first
if (character.DoesCharacterAlreadyKnowAbility(strike))
{
character.HandleUnlearnAbility(strike);
}
if (character.DoesCharacterAlreadyKnowAbility(shoot))
{
character.HandleUnlearnAbility(shoot);
}
if (character.DoesCharacterAlreadyKnowAbility(defend))
{
character.HandleUnlearnAbility(defend);
}
if (character.DoesCharacterAlreadyKnowAbility(twinStrike))
{
character.HandleUnlearnAbility(twinStrike);
}
// Twin Strike
if (mainHandWeapon.itemType == ItemDataSO.ItemType.MeleeOneHand &&
offHandWeapon != null && offHandWeapon.itemType == ItemDataSO.ItemType.MeleeOneHand)
{
Debug.Log(character.myName + " learning Twin Strike from weapon loadout");
abilitiesToLearn.Add(twinStrike);
}
// Strike and Defend
else if (mainHandWeapon.itemType == ItemDataSO.ItemType.MeleeOneHand &&
offHandWeapon != null && offHandWeapon.itemType == ItemDataSO.ItemType.Shield)
{
Debug.Log(character.myName + " learning Strike and Defend from weapon loadout");
abilitiesToLearn.Add(strike);
abilitiesToLearn.Add(defend);
}
// Strike
else if (mainHandWeapon.itemType == ItemDataSO.ItemType.MeleeOneHand ||
mainHandWeapon.itemType == ItemDataSO.ItemType.MeleeTwoHand)
{
Debug.Log(character.myName + " learning Strike from weapon loadout");
abilitiesToLearn.Add(strike);
}
// Shoot
else if (mainHandWeapon.itemType == ItemDataSO.ItemType.RangedTwoHand)
{
Debug.Log(character.myName + " learning Shoot from weapon loadout");
abilitiesToLearn.Add(shoot);
}
// Learn abilities
foreach (AbilityDataSO ability in abilitiesToLearn)
{
character.HandleLearnAbility(ability);
}
}
public string CalculateFinalDamageTypeOfAttack(LivingEntity entity, Ability abilityUsed, ItemDataSO itemUsed = null)
{
Debug.Log("CombatLogic.CalculateFinalDamageTypeOfAttack() called...");
// preferences
string damageTypeReturned = "None";
// First, draw damage type from ability
damageTypeReturned = AbilityLogic.Instance.GetDamageTypeFromAbility(abilityUsed);
// Second, if ability uses weapon, get damage type from weapon
if (itemUsed != null && (abilityUsed.myAbilityData.requiresMeleeWeapon || abilityUsed.myAbilityData.requiresRangedWeapon))
{
Debug.Log("CombatLogic.CalculateFinalDamageTypeOfAttack() detected that " + abilityUsed.abilityName + " requires a weapon, drawing damage type from weapon...");
damageTypeReturned = ItemManager.Instance.GetDamageTypeFromWeapon(itemUsed);
Debug.Log("Damage type from weapon (" + itemUsed.Name + ") is: " + damageTypeReturned);
}
// Third, if character has a 'permanent' imbuement, get damage type from that passive
if (abilityUsed != null && abilityUsed.abilityType == AbilityDataSO.AbilityType.MeleeAttack)
{
Debug.Log("CombatLogic.CalculateFinalDamageTypeOfAttack() checking for damage type imbuements...");
if (entity.myPassiveManager.airImbuement)
{
Debug.Log(entity.name + " has Air Imbuement!");
damageTypeReturned = "Air";
}
else if (entity.myPassiveManager.fireImbuement)
{
Debug.Log(entity.name + " has Fire Imbuement!");
damageTypeReturned = "Fire";
}
else if (entity.myPassiveManager.poisonImbuement)
{
Debug.Log(entity.name + " has Poison Imbuement!");
damageTypeReturned = "Poison";
}
else if (entity.myPassiveManager.frostImbuement)
{
Debug.Log(entity.name + " has Frost Imbuement!");
damageTypeReturned = "Frost";
}
else if (entity.myPassiveManager.shadowImbuement)
{
Debug.Log(entity.name + " has Shadow Imbuement!");
damageTypeReturned = "Shadow";
}
}
// Fourth, if character has a temporary imbuement, get damage type from that (override permanent imbuement)
if (abilityUsed != null && abilityUsed.abilityType == AbilityDataSO.AbilityType.MeleeAttack)
{
Debug.Log("CombatLogic.CalculateFinalDamageTypeOfAttack() checking for TEMPORARY damage type imbuements...");
if (entity.myPassiveManager.temporaryAirImbuement)
{
Debug.Log(entity.name + " has Temporary Air Imbuement!");
damageTypeReturned = "Air";
}
else if (entity.myPassiveManager.temporaryFireImbuement)
{
Debug.Log(entity.name + " has Temporary Fire Imbuement!");
damageTypeReturned = "Fire";
}
else if (entity.myPassiveManager.temporaryPoisonImbuement)
{
Debug.Log(entity.name + " has Temporary Poison Imbuement!");
damageTypeReturned = "Poison";
}
else if (entity.myPassiveManager.temporaryFrostImbuement)
{
Debug.Log(entity.name + " has Temporary Frost Imbuement!");
damageTypeReturned = "Frost";
}
else if (entity.myPassiveManager.temporaryShadowImbuement)
{
Debug.Log(entity.name + " has Temporary Shadow Imbuement!");
damageTypeReturned = "Shadow";
}
}
Debug.Log("CombatLogic.CalculateFinalDamageTypeOfAttack() final damage type returned: " + damageTypeReturned);
return(damageTypeReturned);
}
// Damage, Damage Type and Resistance Calculators
#region
public int GetBaseDamageValue(LivingEntity entity, int baseDamage, Ability abilityUsed, string attackDamageType, ItemDataSO weaponUsed = null)
{
Debug.Log("CombatLogic.GetBaseDamageValue() called...");
int baseDamageValueReturned = 0;
// Add damage from weapon, if the weapon is being used for the attack
if (weaponUsed != null)
{
baseDamageValueReturned += weaponUsed.baseDamage;
Debug.Log(weaponUsed.Name + " base damage is: " + weaponUsed.baseDamage.ToString());
}
else
{
baseDamageValueReturned += baseDamage;
Debug.Log("Weapon not used, base damage from ability/effect is: " + baseDamageValueReturned.ToString());
}
// Add flat damage bonus from modifiers (strength, etc)
if (abilityUsed != null &&
abilityUsed.abilityType == AbilityDataSO.AbilityType.MeleeAttack)
{
baseDamageValueReturned += EntityLogic.GetTotalStrength(entity);
Debug.Log("Base damage after strength and related modifiers added: " + baseDamageValueReturned.ToString());
}
// Add damage from damage type modifiers that effect spell damage (wisdom, shadowform etc)
if (attackDamageType == "Fire" || attackDamageType == "Shadow" || attackDamageType == "Air" || attackDamageType == "Frost" || attackDamageType == "Poison")
{
baseDamageValueReturned += EntityLogic.GetTotalWisdom(entity);
Debug.Log("Base damage after wisdom added: " + baseDamageValueReturned.ToString());
}
// multiply by ability damage multiplier if ability uses a weapon
if (abilityUsed != null &&
(abilityUsed.requiresMeleeWeapon || abilityUsed.requiresRangedWeapon))
{
baseDamageValueReturned = (int)(baseDamageValueReturned * abilityUsed.weaponDamagePercentage);
Debug.Log("Base damage after ability percentage modifer " + baseDamageValueReturned.ToString());
}
// return final value
Debug.Log("Final base damage value of attack returned: " + baseDamageValueReturned.ToString());
return(baseDamageValueReturned);
}
