private void Awake() { if (characterEntity == null) { characterEntity = GetComponentInParent <BaseCharacterEntity>(); } }
public override float GetHitChance(BaseCharacterEntity attacker, BaseCharacterEntity damageReceiver) { // Attacker stats var attackerStats = attacker.CacheStats; // Damage receiver stats var dmgReceiverStats = damageReceiver.CacheStats; // Calculate chance to hit var attackerAcc = attackerStats.accuracy; var dmgReceiverEva = dmgReceiverStats.evasion; var attackerLvl = attacker.Level; var dmgReceiverLvl = damageReceiver.Level; var hitChance = 2f; if (attackerAcc != 0 && dmgReceiverEva != 0) { hitChance *= (attackerAcc / (attackerAcc + dmgReceiverEva)); } if (attackerLvl != 0 && dmgReceiverLvl != 0) { hitChance *= ((float)attackerLvl / (float)(attackerLvl + dmgReceiverLvl)); } // Minimum hit chance is 5% if (hitChance < 0.05f) { hitChance = 0.05f; } // Maximum hit chance is 95% if (hitChance > 0.95f) { hitChance = 0.95f; } return(hitChance); }
public void Summon(BaseCharacterEntity summoner, SummonType summonType, short level) { Summoner = summoner; SummonType = summonType; Level = level; InitStats(); }
private void DecreaseEquipShieldsDurability(BaseCharacterEntity entity, float decreaseDurability) { var tempDestroy = false; var equipWeapons = entity.EquipWeapons; var rightHand = equipWeapons.rightHand; var leftHand = equipWeapons.leftHand; if (rightHand.GetShieldItem() != null && rightHand.GetMaxDurability() > 0) { rightHand = DecreaseDurability(rightHand, decreaseDurability, out tempDestroy); if (tempDestroy) { equipWeapons.rightHand = CharacterItem.Empty; } else { equipWeapons.rightHand = rightHand; } } if (leftHand.GetShieldItem() != null && leftHand.GetMaxDurability() > 0) { leftHand = DecreaseDurability(leftHand, decreaseDurability, out tempDestroy); if (tempDestroy) { equipWeapons.leftHand = CharacterItem.Empty; } else { equipWeapons.leftHand = leftHand; } } entity.EquipWeapons = equipWeapons; }
public override bool IncreaseExp(BaseCharacterEntity character, int exp) { var monsterCharacter = character as BaseMonsterCharacterEntity; if (monsterCharacter != null && monsterCharacter.SummonType != SummonType.Pet) { // If it's monster and not pet, do not increase exp return(false); } var isLevelUp = false; character.Exp += exp; var playerCharacter = character as BasePlayerCharacterEntity; var nextLevelExp = character.GetNextLevelExp(); while (nextLevelExp > 0 && character.Exp >= nextLevelExp) { character.Exp = character.Exp - nextLevelExp; ++character.Level; nextLevelExp = character.GetNextLevelExp(); if (playerCharacter != null) { playerCharacter.StatPoint += increaseStatPointEachLevel; playerCharacter.SkillPoint += increaseSkillPointEachLevel; } isLevelUp = true; } return(isLevelUp); }
public override void NotifyEnemySpotted(BaseCharacterEntity ally, BaseCharacterEntity attacker) { if ((Summoner != null && Summoner == ally) || MonsterDatabase.characteristic == MonsterCharacteristic.Assist) { SetAttackTarget(attacker); } }
public override bool CanReceiveDamageFrom(IAttackerEntity attacker) { if (attacker == null) { return(false); } BaseCharacterEntity characterEntity = attacker as BaseCharacterEntity; if (characterEntity == null) { return(false); } if (isInSafeArea || characterEntity.isInSafeArea) { // If this character or another character is in safe area so it cannot receive damage return(false); } if (characterEntity is BasePlayerCharacterEntity) { // If not ally while this is Pvp map, assume that it can receive damage if (!IsAlly(characterEntity) && gameManager.CurrentMapInfo.canPvp) { return(true); } } if (characterEntity is BaseMonsterCharacterEntity) { // If this character is not summoner so it is enemy and also can receive damage return(!IsAlly(characterEntity)); } return(false); }
public override bool IsAlly(BaseCharacterEntity characterEntity) { if (characterEntity == null) { return(false); } if (IsSummoned) { // If summoned by someone, will have same allies with summoner return(characterEntity == Summoner || characterEntity.IsAlly(Summoner)); } if (characterEntity is BaseMonsterCharacterEntity) { // If another monster has same allyId so it is ally var monsterCharacterEntity = characterEntity as BaseMonsterCharacterEntity; if (monsterCharacterEntity != null) { if (monsterCharacterEntity.IsSummoned) { return(IsAlly(monsterCharacterEntity.Summoner)); } return(monsterCharacterEntity.MonsterDatabase.allyId == MonsterDatabase.allyId); } } return(false); }
public override sealed void Killed(BaseCharacterEntity lastAttacker) { float expLostPercentage = gameInstance.GameplayRule.GetExpLostPercentageWhenDeath(this); GuildData guildData; if (gameManager.TryGetGuild(GuildId, out guildData)) { expLostPercentage -= expLostPercentage * guildData.DecreaseExpLostPercentage; } if (expLostPercentage <= 0f) { expLostPercentage = 0f; } int exp = Exp; exp -= (int)(this.GetNextLevelExp() * expLostPercentage / 100f); if (exp <= 0) { exp = 0; } Exp = exp; base.Killed(lastAttacker); currentNpcDialog = null; }
public override void ReceivedDamage(IAttackerEntity attacker, CombatAmountType damageAmountType, int damage) { BaseCharacterEntity attackerCharacter = attacker as BaseCharacterEntity; // If summoned by someone, summoner is attacker if (attackerCharacter != null && attackerCharacter is BaseMonsterCharacterEntity && (attackerCharacter as BaseMonsterCharacterEntity).IsSummoned) { attackerCharacter = (attackerCharacter as BaseMonsterCharacterEntity).Summoner; } // Add received damage entry if (attackerCharacter != null) { ReceivedDamageRecord receivedDamageRecord = new ReceivedDamageRecord(); receivedDamageRecord.totalReceivedDamage = damage; if (receivedDamageRecords.ContainsKey(attackerCharacter)) { receivedDamageRecord = receivedDamageRecords[attackerCharacter]; receivedDamageRecord.totalReceivedDamage += damage; } receivedDamageRecord.lastReceivedDamageTime = Time.unscaledTime; receivedDamageRecords[attackerCharacter] = receivedDamageRecord; } base.ReceivedDamage(attackerCharacter, damageAmountType, damage); }
public override void ReceiveDamage(IAttackerEntity attacker, CharacterItem weapon, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, CharacterBuff debuff, uint hitEffectsId) { if (!IsServer || IsDead() || !CanReceiveDamageFrom(attacker)) { return; } base.ReceiveDamage(attacker, weapon, allDamageAmounts, debuff, hitEffectsId); BaseCharacterEntity attackerCharacter = attacker as BaseCharacterEntity; // If character is not dead, try to attack if (!IsDead()) { BaseCharacterEntity targetEntity; if (!TryGetTargetEntity(out targetEntity)) { // If no target enemy, set target enemy as attacker SetAttackTarget(attackerCharacter); } else if (attackerCharacter != targetEntity && Random.value > 0.5f) { // Random 50% to change target when receive damage from anyone SetAttackTarget(attackerCharacter); } } }
public override float GetExpLostPercentageWhenDeath(BaseCharacterEntity character) { if (character is BaseMonsterCharacterEntity) { return(0f); } return(expLostPercentageWhenDeath); }
public override float GetDecreasingWaterPerSeconds(BaseCharacterEntity character) { if (character is BaseMonsterCharacterEntity) { return(0f); } return(waterDecreasePerSeconds); }
public override float GetRecoveryMpPerSeconds(BaseCharacterEntity character) { if (IsThirsty(character)) { return(0); } return(character.CacheMaxMp * mpRecoveryRatePerSeconds); }
public override float GetRecoveryHpPerSeconds(BaseCharacterEntity character) { if (IsHungry(character)) { return(0); } return(character.CacheMaxHp * hpRecoveryRatePerSeconds); }
protected void DevExtReceivedDamageDemo(BaseCharacterEntity attacker, CombatAmountType combatAmountType, int damage) { if (writeAddonLog) { Debug.Log("[" + name + "] MonsterCharacterEntity.ReceivedDamage(" + attacker.Title + ", " + combatAmountType + ", " + damage + ")"); } }
protected void DevExtReceiveDamageDemo(BaseCharacterEntity attacker, CharacterItem weapon, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, CharacterBuff debuff, uint hitEffectsId) { if (writeAddonLog) { Debug.Log("[" + name + "] MonsterCharacterEntity.ReceiveDamage(" + attacker.Title + ", " + weapon + ", " + allDamageAmounts.Count + ", " + debuff + ", " + hitEffectsId + ")"); } }
public override void ReceiveDamage(IAttackerEntity attacker, CharacterItem weapon, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, CharacterBuff debuff, uint hitEffectsId) { if (!IsServer || IsDead() || weapon == null) { return; } base.ReceiveDamage(attacker, weapon, allDamageAmounts, debuff, hitEffectsId); BaseCharacterEntity attackerCharacter = attacker as BaseCharacterEntity; // Play hit effect if (hitEffectsId == 0) { hitEffectsId = gameInstance.DefaultHitEffects.Id; } if (hitEffectsId > 0) { RequestPlayEffect(hitEffectsId); } // Apply damages int totalDamage = 0; Item weaponItem = weapon.GetWeaponItem(); HarvestEffectiveness harvestEffectiveness; WeightedRandomizer <ItemDropByWeight> itemRandomizer; if (harvestable.CacheHarvestEffectivenesses.TryGetValue(weaponItem.weaponType, out harvestEffectiveness) && harvestable.CacheHarvestItems.TryGetValue(weaponItem.weaponType, out itemRandomizer)) { totalDamage = (int)(weaponItem.harvestDamageAmount.GetAmount(weapon.level).Random() * harvestEffectiveness.damageEffectiveness); ItemDropByWeight receivingItem = itemRandomizer.TakeOne(); int dataId = receivingItem.item.DataId; short amount = (short)(receivingItem.amountPerDamage * totalDamage); bool droppingToGround = collectType == HarvestableCollectType.DropToGround; if (attackerCharacter.IncreasingItemsWillOverwhelming(dataId, amount)) { droppingToGround = true; } if (!droppingToGround) { attackerCharacter.IncreaseItems(CharacterItem.Create(dataId, 1, amount)); } else { ItemDropEntity.DropItem(this, CharacterItem.Create(dataId, 1, amount), new uint[0]); } } CurrentHp -= totalDamage; ReceivedDamage(attackerCharacter, CombatAmountType.NormalDamage, totalDamage); if (IsDead()) { CurrentHp = 0; CallNetFunction(NetFuncOnHarvestableDestroy, FunctionReceivers.All); DestroyAndRespawn(); } }
public bool IsAbleToLoot(BaseCharacterEntity baseCharacterEntity) { if (looters == null || looters.Contains(baseCharacterEntity.ObjectId) || Time.unscaledTime - dropTime > GameInstance.itemLootLockDuration) { return(true); } return(false); }
public override void OnHarvestableReceivedDamage(BaseCharacterEntity attacker, HarvestableEntity damageReceiver, CombatAmountType combatAmountType, int damage) { var decreaseWeaponDurability = normalDecreaseWeaponDurability; var decreaseShieldDurability = normalDecreaseShieldDurability; var decreaseArmorDurability = normalDecreaseArmorDurability; GetDecreaseDurabilityAmount(combatAmountType, out decreaseWeaponDurability, out decreaseShieldDurability, out decreaseArmorDurability); // Decrease Weapon Durability DecreaseEquipWeaponsDurability(attacker, decreaseWeaponDurability); }
/// <summary> /// Return TRUE if this will override default apply skill function /// </summary> /// <param name="character"></param> /// <param name="skillLevel"></param> /// <param name="isLeftHand"></param> /// <param name="weapon"></param> /// <param name="damageInfo"></param> /// <param name="allDamageAmounts"></param> /// <param name="hasAimPosition"></param> /// <param name="aimPosition"></param> /// <returns></returns> public virtual bool OnApplySkill( BaseCharacterEntity character, short skillLevel, bool isLeftHand, CharacterItem weapon, DamageInfo damageInfo, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, bool hasAimPosition, Vector3 aimPosition) { return(false); }
public void UseItem(BaseCharacterEntity characterEntity, short itemIndex, CharacterItem characterItem) { if (!characterEntity.CanUseItem() || characterItem.level <= 0 || !characterEntity.DecreaseItemsByIndex(itemIndex, 1)) { return; } characterEntity.FillEmptySlots(); characterEntity.ApplyBuff(DataId, BuffType.PotionBuff, characterItem.level, characterEntity.GetInfo()); characterEntity.RewardExp(new Reward() { exp = Exp }, 1, RewardGivenType.None); }
/// <summary> /// Finds the BaseCharacterEntity with the same ID as the storage's creator and sets it as the ownerEntity. /// Called by CLIENT only. /// </summary> protected void FindOwnerEntity() { BaseCharacterEntity[] characters = FindObjectsOfType <BaseCharacterEntity>(); foreach (BaseCharacterEntity bce in characters) { if (bce.ObjectId == OwnerObjectID) { ownerEntity = bce; ownerSet = true; return; } } }
public override float GetMoveSpeed(BaseCharacterEntity character) { float moveSpeed = character.CacheMoveSpeed; if (character.MovementState.HasFlag(MovementState.IsSprinting)) { moveSpeed *= moveSpeedRateWhileSprint; } if (character.isAttackingOrUsingSkill) { moveSpeed *= character.moveSpeedRateWhileAttackOrUseSkill; } return(moveSpeed); }
public override void OnCharacterReceivedDamage(BaseCharacterEntity attacker, BaseCharacterEntity damageReceiver, CombatAmountType combatAmountType, int damage) { float decreaseWeaponDurability = normalDecreaseWeaponDurability; float decreaseShieldDurability = normalDecreaseShieldDurability; float decreaseArmorDurability = normalDecreaseArmorDurability; GetDecreaseDurabilityAmount(combatAmountType, out decreaseWeaponDurability, out decreaseShieldDurability, out decreaseArmorDurability); // Decrease Weapon Durability DecreaseEquipWeaponsDurability(attacker, decreaseWeaponDurability); // Decrease Shield Durability DecreaseEquipShieldsDurability(damageReceiver, decreaseShieldDurability); // Decrease Armor Durability DecreaseEquipItemsDurability(damageReceiver, decreaseArmorDurability); }
public override bool IsEnemy(BaseCharacterEntity characterEntity) { if (characterEntity == null) { return(false); } if (IsSummoned) { // If summoned by someone, will have same enemies with summoner return(characterEntity != Summoner && characterEntity.IsEnemy(Summoner)); } // Attack only player by default return(characterEntity is BasePlayerCharacterEntity); }
public override float GetDamageReducedByResistance(BaseCharacterEntity damageReceiver, float damageAmount, DamageElement damageElement) { if (damageElement == null) { return(damageAmount -= damageReceiver.CacheStats.armor); // If armor is minus damage will be increased } var resistances = damageReceiver.CacheResistances; float resistanceAmount = 0f; resistances.TryGetValue(damageElement, out resistanceAmount); if (resistanceAmount > damageElement.maxResistanceAmount) { resistanceAmount = damageElement.maxResistanceAmount; } return(damageAmount -= damageAmount * resistanceAmount); // If resistance is minus damage will be increased }
protected void SetTargetCharacter(BaseCharacterEntity character) { if (uiTargetCharacter == null) { return; } if (character == null) { uiTargetCharacter.Hide(); return; } uiTargetCharacter.Data = character; uiTargetCharacter.Show(); }
public override float GetCriticalChance(BaseCharacterEntity attacker, BaseCharacterEntity damageReceiver) { var criRate = damageReceiver.CacheStats.criRate; // Minimum critical chance is 5% if (criRate < 0.05f) { criRate = 0.05f; } // Maximum critical chance is 95% if (criRate > 0.95f) { criRate = 0.95f; } return(criRate); }
public virtual void SetAttackTarget(BaseCharacterEntity target) { if (target == null || target.IsDead()) { return; } // Already have target so don't set target BaseCharacterEntity oldTarget; if (TryGetTargetEntity(out oldTarget) && !oldTarget.IsDead()) { return; } // Set target to attack SetTargetEntity(target); }