// -----------------------------------------------------------------------------------
// CanUnequip (Swapping)
// -----------------------------------------------------------------------------------
public bool CanUnequip(Player player, int inventoryIndex, int equipmentIndex)
{
MutableWrapper <bool> bValid = new MutableWrapper <bool>(true);
Utils.InvokeMany(typeof(EquipmentItem), this, "CanUnequip_", player, inventoryIndex, equipmentIndex, bValid);
return(bValid.Value);
}
// -----------------------------------------------------------------------------------
// CanUnequipClick (Clicking)
// -----------------------------------------------------------------------------------
public bool CanUnequipClick(Player player, EquipmentItem item)
{
MutableWrapper <bool> bValid = new MutableWrapper <bool>(true);
Utils.InvokeMany(typeof(EquipmentItem), this, "CanUnequipClick_", player, item, bValid);
return(bValid.Value);
}
public void CanUnequipClick_UCE_EquipableBag(Player player, EquipmentItem item, MutableWrapper <bool> bValid)
{
if (!bValid.Value)
{
return; //when not valid, we dont have to check at all
}
bValid.Value = player.UCE_inventorySlotCount() < player.inventorySize - extraInventorySize; // has to be less, because we have to take the unequipped item into account as well
if (bValid.Value == false)
{
player.UCE_TargetAddMessage(bagCannotUnequipMsg);
}
}
private void CanUnequipClick_CursedEquipment(Player player, EquipmentItem item, MutableWrapper <bool> bValid)
{
if (!bValid.Value)
{
return; //when not valid, we dont have to check at all
}
if (player.equipment.Any(x => (x.amount > 0 && ((EquipmentItem)x.item.data).nullsAllCurses == true)))
{ // no need to check if any item can nullify curses
bValid.Value = true;
return;
}
int overrideLevel = item.overrideCursedLevel;
bValid.Value = player.equipment.Any(x => (x.amount > 0 && (cursedLevel <= 0 || (cursedLevel > 0 && overrideLevel >= cursedLevel))));
if (bValid.Value == false)
{
player.UCE_TargetAddMessage(cursedCannotUnequipMsg);
}
}
public virtual void DealDamageAt(Entity entity, int amount, float stunChance = 0, float stunTime = 0)
{
int damageDealt = 0;
DamageType damageType = DamageType.Normal;
if (entity && !entity.invincible && entity.isAlive && (amount > 0 || stunChance > 0 || stunTime > 0))
{
int target_Defense = entity.defense - Convert.ToInt32(entity.defense * defenseBreakFactor);
float target_BlockChance = entity.blockChance - Convert.ToInt32(entity.blockChance * blockBreakFactor);
float self_critChance = criticalChance - Convert.ToInt32(criticalChance * entity.criticalEvasion);
// -- Base Damage
if (UCE_relationalDamage)
{
damageDealt = Convert.ToInt32((amount * (100 - Mathf.Sqrt(target_Defense)) / 100));
}
else
{
damageDealt = Mathf.Max(amount - target_Defense, 1);
}
// -- Elemental Modifiers
UCE_ElementTemplate element = null;
#if _iMMOELEMENTS
if (damageDealt > 0)
{
if (currentSkill != -1 && skills[currentSkill].data is DamageSkill)
{
element = ((DamageSkill)skills[currentSkill].data).element;
}
#if _iMMOPROJECTILES || _iMMOMELEE
if (currentSkill != -1 && skills[currentSkill].data is UCE_DamageSkill)
{
element = ((UCE_DamageSkill)skills[currentSkill].data).element;
}
#endif
if (element == null && this is Player)
{
element = ((Player)this).UCE_getAttackElement();
}
}
#endif
// -- Custom Hook for Modifiers
if (damageDealt > 0)
{
MutableWrapper <int> damageBonus = new MutableWrapper <int>(0);
Utils.InvokeMany(typeof(Entity), this, "OnDealDamage_", entity, element, damageDealt, damageBonus);
damageDealt += damageBonus.Value;
}
// -- Randomized Variance
if (damageDealt > 0 && UCE_randomDamageDeviation != 0)
{
int minDamage = (int)UnityEngine.Random.Range((int)damageDealt * (1 - UCE_randomDamageDeviation), damageDealt);
int maxDamage = (int)UnityEngine.Random.Range(damageDealt, (int)damageDealt * (1 + UCE_randomDamageDeviation));
damageDealt = UnityEngine.Random.Range(minDamage, maxDamage);
}
// -- Block
if (UnityEngine.Random.value < target_BlockChance)
{
damageDealt -= Convert.ToInt32(damageDealt * blockFactor);
damageType = DamageType.Block;
}
else
{
// -- Crit
if (UnityEngine.Random.value < self_critChance)
{
damageDealt = Convert.ToInt32(damageDealt * criticalFactor);
damageType = DamageType.Crit;
}
// -- Deal Damage
entity.health -= damageDealt;
// -- Check Stun
if (UnityEngine.Random.value <= stunChance)
{
double newStunEndTime = NetworkTime.time + stunTime;
entity.stunTimeEnd = Math.Max(newStunEndTime, stunTimeEnd);
}
}
entity.OnAggro(this);
entity.RpcOnDamageReceived(damageDealt, damageType);
// reset last combat time for both
lastCombatTime = NetworkTime.time;
entity.lastCombatTime = NetworkTime.time;
Utils.InvokeMany(typeof(Entity), this, "DealDamageAt_", entity, amount, stunChance, stunTime);
}
}
private void OnDealDamage_UCE_Elements(Entity target, UCE_ElementTemplate element, int damageDealt, MutableWrapper <int> damageBonus)
{
if (target == null || element == null || damageDealt <= 0)
{
return;
}
damageBonus.Value += (int)(damageDealt * target.UCE_CalculateElementalResistance(element));
}
public void CanUnequip_CursedEquipment(Player player, int inventoryIndex, int equipmentIndex, MutableWrapper <bool> bValid)
{
if (!bValid.Value)
{
return; //when not valid, we dont have to check at all
}
if (player.equipment.Any(x => (x.amount > 0 && ((EquipmentItem)x.item.data).nullsAllCurses == true)))
{ // no need to check if any item can nullify curses
bValid.Value = true;
return;
}
int overrideLevel = 0;
if (player.inventory[inventoryIndex].amount > 0)
{
EquipmentItem item = (EquipmentItem)player.inventory[inventoryIndex].item.data;
overrideLevel = item.overrideCursedLevel;
}
bValid.Value = CanEquip(player, inventoryIndex, equipmentIndex) &&
(player.equipment.Any(x => (x.amount > 0 && (cursedLevel <= 0 || (cursedLevel > 0 && overrideLevel >= cursedLevel)))));
if (bValid.Value == false)
{
player.UCE_TargetAddMessage(cursedCannotUnequipMsg);
}
}
