public void Summon(BaseCharacterEntity summoner, short summonLevel, float duration, int summonExp, int summonCurrentHp, int summonCurrentMp)
{
Summon(summoner, summonLevel, duration);
CacheEntity.Exp = summonExp;
CacheEntity.CurrentHp = summonCurrentHp;
CacheEntity.CurrentMp = summonCurrentMp;
}
public virtual void Target(GameObject enemy)
{
if (enemy != null)
{
BaseGameEntity agent = enemy.GetComponentInParent <BaseGameEntity>();
if (agent != null)
{
if (selectedTarget != null && selectedTarget == enemy)
{
UnTarget(selectedTarget);
}
selectedTarget = enemy;
if (potentialTarget == selectedTarget)
{
potentialTarget = null;
}
if (agent is BaseCharacterEntity)
{
recticleMoveTime = 0;
BaseCharacterEntity character = agent as BaseCharacterEntity;
character.OnTargeted(GetComponent <BaseCharacterEntity>());
character.CharacterDied.AddListener(AgentDies);
}
}
}
}
public static BaseCharacterModel InstantiateModel(this ICharacterData data, Transform parent)
{
BaseCharacterEntity entityPrefab = data.GetEntityPrefab();
if (entityPrefab == null)
{
Debug.LogWarning("[InstantiateModel] Cannot find character entity with id: " + data.EntityId);
return(null);
}
BaseCharacterEntity result = Object.Instantiate(entityPrefab, parent);
LiteNetLibBehaviour[] networkBehaviours = result.GetComponentsInChildren <LiteNetLibBehaviour>();
foreach (LiteNetLibBehaviour networkBehaviour in networkBehaviours)
{
networkBehaviour.enabled = false;
}
GameObject[] ownerObjects = result.ownerObjects;
foreach (GameObject ownerObject in ownerObjects)
{
ownerObject.SetActive(false);
}
GameObject[] nonOwnerObjects = result.nonOwnerObjects;
foreach (GameObject nonOwnerObject in nonOwnerObjects)
{
nonOwnerObject.SetActive(false);
}
result.gameObject.SetLayerRecursively(GameInstance.Singleton.characterLayer, true);
result.gameObject.SetActive(true);
result.transform.localPosition = Vector3.zero;
return(result.CharacterModel);
}
public virtual void UnTarget(GameObject enemy, bool deselect = true)
{
if (enemy != null)
{
var agent = enemy.GetComponentInParent <BaseGameEntity>();
if (agent != null)
{
if (agent is BaseCharacterEntity)
{
BaseCharacterEntity character = agent as BaseCharacterEntity;
character.OnUnTargeted(GetComponent <BaseCharacterEntity>());
character.CharacterDied.RemoveListener(AgentDies);
}
if (selectedTarget == enemy)
{
if (deselect)
{
selectedTarget = null;
targeting = false;
}
recticleMoveTime = 0;
}
}
}
}
public void SpawnCombatCustomText(BaseCharacterEntity character, string customStr)
{
var combatText = Instantiate(combatPoisonPrefab, combatTextContainer);
combatText.transform.localScale = Vector3.one;
combatText.TempObjectFollower.targetObject = character.bodyEffectContainer;
combatText.CustomStr = customStr;
}
public void SpawnMissText(BaseCharacterEntity character)
{
var combatText = Instantiate(combatMissPrefab, combatTextContainer);
combatText.transform.localScale = Vector3.one;
combatText.TempObjectFollower.targetObject = character.bodyEffectContainer;
combatText.Amount = 0;
combatText.TempText.text = RPGLanguageManager.Texts[GameText.COMBAT_MISS];
}
//战斗
public void SpawnCombatText(UICombatText prefab, int amount, BaseCharacterEntity character, string customStr = "")
{
var combatText = Instantiate(prefab, combatTextContainer);
combatText.transform.localScale = Vector3.one;
combatText.TempObjectFollower.targetObject = character.bodyEffectContainer;
combatText.CustomStr = customStr;
combatText.Amount = amount;
}
public static BaseCharacterEntity GetEntityPrefab(this ICharacterData data)
{
BaseCharacterEntity entityPrefab = null;
if (!GameInstance.AllCharacterEntities.TryGetValue(data.EntityId, out entityPrefab))
{
Debug.LogWarning("[GetEntityPrefab] Cannot find character entity with id: " + data.EntityId);
return(null);
}
return(entityPrefab);
}
public override void Killed(BaseCharacterEntity lastAttacker)
{
base.Killed(lastAttacker);
deadTime = Time.unscaledTime;
var maxHp = this.GetStats().hp;
var randomedExp = Random.Range(MonsterDatabase.randomExpMin, MonsterDatabase.randomExpMax);
var randomedGold = Random.Range(MonsterDatabase.randomGoldMin, MonsterDatabase.randomGoldMax);
if (receivedDamageRecords.Count > 0)
{
var enemies = new List <BaseCharacterEntity>(receivedDamageRecords.Keys);
foreach (var enemy in enemies)
{
var receivedDamageRecord = receivedDamageRecords[enemy];
var rewardRate = receivedDamageRecord.totalReceivedDamage / maxHp;
if (rewardRate > 1)
{
rewardRate = 1;
}
enemy.IncreaseExp((int)(randomedExp * rewardRate));
if (enemy is PlayerCharacterEntity)
{
var enemyPlayer = enemy as PlayerCharacterEntity;
enemyPlayer.IncreaseGold((int)(randomedGold * rewardRate));
}
}
}
receivedDamageRecords.Clear();
foreach (var randomItem in MonsterDatabase.randomItems)
{
if (Random.value <= randomItem.dropRate)
{
var item = randomItem.item;
var amount = randomItem.amount;
if (item != null && GameInstance.Items.ContainsKey(item.HashId))
{
var itemDataId = item.HashId;
if (amount > item.maxStack)
{
amount = item.maxStack;
}
ItemDropEntity.DropItem(this, itemDataId, 1, amount);
}
}
}
var lastPlayer = lastAttacker as PlayerCharacterEntity;
if (lastPlayer != null)
{
lastPlayer.OnKillMonster(this);
}
}
public void Summon(BaseCharacterEntity summoner, short summonLevel, float duration)
{
if (GetPrefab() == null)
{
return;
}
var identity = BaseGameNetworkManager.Singleton.Assets.NetworkSpawn(GetPrefab().Identity, summoner.GetSummonPosition(), summoner.GetSummonRotation());
cacheEntity = identity.GetComponent <BaseMonsterCharacterEntity>();
CacheEntity.Summon(summoner, type, summonLevel);
objectId = CacheEntity.ObjectId;
summonRemainsDuration = duration;
}
public List <GameEffect> InstantiatesTo(BaseCharacterEntity character)
{
var result = new List <GameEffect>();
if (bodyEffect != null)
{
result.Add(bodyEffect.InstantiateTo(character.bodyEffectContainer));
}
if (floorEffect != null)
{
result.Add(floorEffect.InstantiateTo(character.floorEffectContainer));
}
return(result);
}
public void SetAttackTarget(BaseCharacterEntity target)
{
if (target == null || target.CurrentHp <= 0)
{
return;
}
// Already have target so don't set target
BaseCharacterEntity oldTarget;
if (TryGetTargetEntity(out oldTarget) && oldTarget.CurrentHp > 0)
{
return;
}
// Set target to attack
SetTargetEntity(target);
}
public override bool IsAlly(BaseCharacterEntity characterEntity)
{
if (characterEntity == null)
{
return(false);
}
// If this character have been attacked by any character
// It will tell another ally nearby to help
var monsterCharacterEntity = characterEntity as MonsterCharacterEntity;
if (monsterCharacterEntity != null && monsterCharacterEntity.MonsterDatabase.allyId == MonsterDatabase.allyId)
{
return(true);
}
return(false);
}
public bool TryGetAttackingCharacter(out BaseCharacterEntity character)
{
character = null;
if (CharacterEntity.TryGetTargetEntity(out character))
{
// TODO: Returning Pvp characters
if (character is MonsterCharacterEntity)
{
return(true);
}
else
{
character = null;
}
}
return(false);
}
public override void ReceiveDamage(BaseCharacterEntity attacker, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, CharacterBuff debuff, int hitEffectsId)
{
// Damage calculations apply at server only
if (!IsServer || CurrentHp <= 0)
{
return;
}
base.ReceiveDamage(attacker, allDamageAmounts, debuff, hitEffectsId);
// If no attacker, skip next logics
if (attacker == null || !IsEnemy(attacker))
{
return;
}
// If character isn't dead
// If character is not dead, try to attack
if (CurrentHp > 0)
{
var gameInstance = GameInstance.Singleton;
// If no target enemy and current target is character, try to attack
BaseCharacterEntity targetEntity;
if (!TryGetTargetEntity(out targetEntity))
{
SetAttackTarget(attacker);
// If it's assist character call another character for assist
if (MonsterDatabase.characteristic == MonsterCharacteristic.Assist)
{
var foundObjects = new List <Collider>(Physics.OverlapSphere(CacheTransform.position, MonsterDatabase.visualRange, gameInstance.characterLayer.Mask));
foreach (var foundObject in foundObjects)
{
var monsterCharacterEntity = foundObject.GetComponent <MonsterCharacterEntity>();
if (monsterCharacterEntity != null && IsAlly(monsterCharacterEntity))
{
monsterCharacterEntity.SetAttackTarget(attacker);
}
}
}
}
else if (attacker != targetEntity && Random.value >= 0.5f)
{
// Random 50% to change target when receive damage from anyone
SetAttackTarget(attacker);
}
}
}
protected override void Update()
{
base.Update();
if (CacheTargetObject != null)
{
CacheTargetObject.gameObject.SetActive(destination.HasValue);
}
if (CharacterEntity.CurrentHp <= 0)
{
queueUsingSkill = null;
destination = null;
if (CacheUISceneGameplay != null)
{
CacheUISceneGameplay.SetTargetCharacter(null);
}
}
else
{
BaseCharacterEntity targetCharacter = null;
CharacterEntity.TryGetTargetEntity(out targetCharacter);
if (CacheUISceneGameplay != null)
{
CacheUISceneGameplay.SetTargetCharacter(targetCharacter);
}
}
if (destination.HasValue)
{
var destinationValue = destination.Value;
if (CacheTargetObject != null)
{
CacheTargetObject.transform.position = destinationValue;
}
if (Vector3.Distance(destinationValue, CharacterTransform.position) < StoppingDistance + 0.5f)
{
destination = null;
}
}
UpdateInput();
UpdateFollowTarget();
}
public override void ReceivedDamage(BaseCharacterEntity attacker, CombatAmountType damageAmountType, int damage)
{
base.ReceivedDamage(attacker, damageAmountType, damage);
// Add received damage entry
if (attacker == null)
{
return;
}
var receivedDamageRecord = new ReceivedDamageRecord();
receivedDamageRecord.totalReceivedDamage = damage;
if (receivedDamageRecords.ContainsKey(attacker))
{
receivedDamageRecord = receivedDamageRecords[attacker];
receivedDamageRecord.totalReceivedDamage += damage;
}
receivedDamageRecord.lastReceivedDamageTime = Time.unscaledTime;
receivedDamageRecords[attacker] = receivedDamageRecord;
}
public void SetupDamage(
BaseCharacterEntity attacker,
Dictionary <DamageElement, MinMaxFloat> allDamageAmounts,
CharacterBuff debuff,
int hitEffectsId,
float missileDistance,
float missileSpeed)
{
SetupDamage(attacker, allDamageAmounts, debuff, hitEffectsId);
this.missileDistance = missileDistance;
this.missileSpeed.Value = missileSpeed;
if (missileDistance > 0 && missileSpeed > 0)
{
NetworkDestroy(missileDistance / missileSpeed);
}
else
{
NetworkDestroy();
}
}
public void UnSummon(BaseCharacterEntity summoner)
{
if (type == SummonType.Pet)
{
var newItem = CharacterItem.Create(dataId, Level, 1);
newItem.exp = Exp;
if (CacheEntity == null || CacheEntity.CurrentHp <= 0)
{
newItem.Lock(GameInstance.Singleton.petDeadLockDuration);
}
else
{
newItem.Lock(GameInstance.Singleton.petUnSummonLockDuration);
}
summoner.NonEquipItems.Add(newItem);
}
if (CacheEntity != null)
{
CacheEntity.UnSummon();
}
}
public void SpawnDamageText(int amount, BaseCharacterEntity character)
{
SpawnCombatText(combatDamagePrefab, amount, character);
}
protected static void UpdateRecovery(float deltaTime, BaseGameplayRule gameplayRule, CharacterRecoveryComponent recoveryData, BaseCharacterEntity characterEntity)
{
if (characterEntity.isRecaching || characterEntity.CurrentHp <= 0 || !characterEntity.IsServer)
{
return;
}
recoveryData.recoveryUpdateDeltaTime += deltaTime;
if (recoveryData.recoveryUpdateDeltaTime >= RECOVERY_UPDATE_DURATION)
{
// Hp
recoveryData.recoveryingHp += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetRecoveryHpPerSeconds(characterEntity);
if (characterEntity.CurrentHp < characterEntity.CacheMaxHp)
{
if (recoveryData.recoveryingHp >= 1)
{
var intRecoveryingHp = (int)recoveryData.recoveryingHp;
characterEntity.CurrentHp += intRecoveryingHp;
characterEntity.RequestCombatAmount(CombatAmountType.HpRecovery, intRecoveryingHp);
recoveryData.recoveryingHp -= intRecoveryingHp;
}
}
else
{
recoveryData.recoveryingHp = 0;
}
// Decrease Hp
recoveryData.decreasingHp += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetDecreasingHpPerSeconds(characterEntity);
if (characterEntity.CurrentHp > 0)
{
if (recoveryData.decreasingHp >= 1)
{
var intDecreasingHp = (int)recoveryData.decreasingHp;
characterEntity.CurrentHp -= intDecreasingHp;
recoveryData.decreasingHp -= intDecreasingHp;
}
}
else
{
recoveryData.decreasingHp = 0;
}
// Mp
recoveryData.recoveryingMp += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetRecoveryMpPerSeconds(characterEntity);
if (characterEntity.CurrentMp < characterEntity.CacheMaxMp)
{
if (recoveryData.recoveryingMp >= 1)
{
var intRecoveryingMp = (int)recoveryData.recoveryingMp;
characterEntity.CurrentMp += intRecoveryingMp;
characterEntity.RequestCombatAmount(CombatAmountType.MpRecovery, intRecoveryingMp);
recoveryData.recoveryingMp -= intRecoveryingMp;
}
}
else
{
recoveryData.recoveryingMp = 0;
}
// Decrease Mp
recoveryData.decreasingMp += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetDecreasingMpPerSeconds(characterEntity);
if (characterEntity.CurrentMp > 0)
{
if (recoveryData.decreasingMp >= 1)
{
var intDecreasingMp = (int)recoveryData.decreasingMp;
characterEntity.CurrentMp -= intDecreasingMp;
recoveryData.decreasingMp -= intDecreasingMp;
}
}
else
{
recoveryData.decreasingMp = 0;
}
// Stamina
recoveryData.recoveryingStamina += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetRecoveryStaminaPerSeconds(characterEntity);
if (characterEntity.CurrentStamina < characterEntity.CacheMaxStamina)
{
if (recoveryData.recoveryingStamina >= 1)
{
var intRecoveryingStamina = (int)recoveryData.recoveryingStamina;
characterEntity.CurrentStamina += intRecoveryingStamina;
characterEntity.RequestCombatAmount(CombatAmountType.StaminaRecovery, intRecoveryingStamina);
recoveryData.recoveryingStamina -= intRecoveryingStamina;
}
}
else
{
recoveryData.recoveryingStamina = 0;
}
// Decrease Stamina while sprinting
recoveryData.decreasingStamina += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetDecreasingStaminaPerSeconds(characterEntity);
if (characterEntity.isSprinting && characterEntity.CurrentStamina > 0)
{
if (recoveryData.decreasingStamina >= 1)
{
var intDecreasingStamina = (int)recoveryData.decreasingStamina;
characterEntity.CurrentStamina -= intDecreasingStamina;
recoveryData.decreasingStamina -= intDecreasingStamina;
}
}
else
{
recoveryData.decreasingStamina = 0;
}
// Food
if (characterEntity.CurrentFood < characterEntity.CacheMaxFood)
{
if (recoveryData.recoveryingFood >= 1)
{
var intRecoveryingFood = (int)recoveryData.recoveryingFood;
characterEntity.CurrentFood += intRecoveryingFood;
characterEntity.RequestCombatAmount(CombatAmountType.FoodRecovery, intRecoveryingFood);
recoveryData.recoveryingFood -= intRecoveryingFood;
}
}
else
{
recoveryData.recoveryingFood = 0;
}
// Decrease Food
recoveryData.decreasingFood += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetDecreasingFoodPerSeconds(characterEntity);
if (characterEntity.CurrentFood > 0)
{
if (recoveryData.decreasingFood >= 1)
{
var intDecreasingFood = (int)recoveryData.decreasingFood;
characterEntity.CurrentFood -= intDecreasingFood;
recoveryData.decreasingFood -= intDecreasingFood;
}
}
else
{
recoveryData.decreasingFood = 0;
}
// Water
if (characterEntity.CurrentWater < characterEntity.CacheMaxWater)
{
if (recoveryData.recoveryingWater >= 1)
{
var intRecoveryingWater = (int)recoveryData.recoveryingWater;
characterEntity.CurrentWater += intRecoveryingWater;
characterEntity.RequestCombatAmount(CombatAmountType.WaterRecovery, intRecoveryingWater);
recoveryData.recoveryingWater -= intRecoveryingWater;
}
}
else
{
recoveryData.recoveryingWater = 0;
}
// Decrease Water
recoveryData.decreasingWater += recoveryData.recoveryUpdateDeltaTime * gameplayRule.GetDecreasingWaterPerSeconds(characterEntity);
if (characterEntity.CurrentWater > 0)
{
if (recoveryData.decreasingWater >= 1)
{
var intDecreasingWater = (int)recoveryData.decreasingWater;
characterEntity.CurrentWater -= intDecreasingWater;
recoveryData.decreasingWater -= intDecreasingWater;
}
}
else
{
recoveryData.decreasingWater = 0;
}
recoveryData.recoveryUpdateDeltaTime = 0;
}
characterEntity.ValidateRecovery();
}
private void Start()
{
animator = GetComponent <Animator>();
character = GetComponent <BaseCharacterEntity>();
}
public float GetDamageReducedByResistance(BaseCharacterEntity damageReceiver, float damageAmount)
{
var gameInstance = GameInstance.Singleton;
return(gameInstance.GameplayRule.GetDamageReducedByResistance(damageReceiver, damageAmount, this));
}
public void SpawnCustomText(string custr, int amount = 0, BaseCharacterEntity character = null)
{
SpawnCombatText(combatHealPrefab, amount, character, custr);
}
//毒
public void SpawnPoisonText(int amount, BaseCharacterEntity character)
{
SpawnCombatText(combatPoisonPrefab, amount, character, "中毒");
}
public void SpawnAddHealText(string custr, int amount, BaseCharacterEntity character)
{
SpawnCombatText(combatHealPrefab, amount, character, custr);
}
public void SpawnBlockText(int amount, BaseCharacterEntity character)
{
SpawnCombatText(combatBlockPrefab, amount, character, "格挡");
}
public void SpawnCriticalText(int amount, BaseCharacterEntity character)
{
SpawnCombatText(combatCriticalPrefab, amount, character, "暴击");
}
public override bool IsEnemy(BaseCharacterEntity characterEntity)
{
return(characterEntity != null && characterEntity is PlayerCharacterEntity);
}
public override bool CanReceiveDamageFrom(BaseCharacterEntity characterEntity)
{
return(characterEntity != null && characterEntity is PlayerCharacterEntity);
}
