/// <summary>
/// 处理获得物品协议
/// </summary>
/// <param name="protocol"></param>
public void TreateGetItemProtocol(ProtocolBytes protocol)
{
// 获得用户名
string userName = protocol.GetString();
if (userName == NetWorkManager.Instance.NowPlayerID)
{
return;
}
// 获得物品ID
int itemId = protocol.GetInt();
// 获得物品数量
int itemNumber = protocol.GetInt();
// 根据用户名获得英雄
CharacterMono character = NetWorkManager.Instance.networkPlayers[userName].GetComponent <CharacterMono>();
// 构造物品格子
ItemGrid itemGrid = new ItemGrid {
item = TestDatabase.Instance.items[0],
ItemCount = itemNumber
};
// 处理单位获得物品事件
character.GetItem(itemGrid);
}
/// <summary>
/// 处理Damage协议
/// </summary>
/// <param name="protocolBytes"></param>
public void TreateDamageProtocol(ProtocolBytes protocolBytes)
{
// 获得攻击者ID
string attackerId = protocolBytes.GetString();
// 不处理本地玩家的伤害事件,因为本地客户端会自行处理
if (attackerId == NowPlayerID)
{
return;
}
if (attackerId.Contains("NPC#") && IsHomeowner)
{
return;
}
CharacterMono attacker = NetWorkManager.Instance.networkPlayers[attackerId].GetComponent <CharacterMono>();
// 获得受害者ID
string victimId = protocolBytes.GetString();
CharacterMono victim = NetWorkManager.Instance.networkPlayers[victimId].GetComponent <CharacterMono>();
// 获得基础伤害
int baseDamage = protocolBytes.GetInt();
// 获得附加伤害
int plusDamage = protocolBytes.GetInt();
Damage damage = new Damage(baseDamage, plusDamage);
victim.characterModel.Damaged(victim, damage, attacker);
}
public override bool IsValid()
{
CharacterMono characterMono = BlackBorad.CharacterMono;
if (characterMono.prepareSkill.IsMustDesignation)
{
target = BlackBorad.GetCharacterMono("Enemry");
}
else
{
targetPosition = BlackBorad.GetVector3("EnemryPosition");
}
if ((characterMono.prepareSkill.IsMustDesignation && target == null) || characterMono == null)
{
return(false);
}
Vector3 position = target == null ? targetPosition : target.transform.position;
if ((Input.GetKeyDown(KeyCode.Escape) || Input.GetMouseButtonDown(1)) &&
Vector2.Distance(
new Vector2(position.x, position.z),
new Vector2(characterMono.transform.position.x, characterMono.transform.position.z)
) > characterMono.prepareSkill.SpellDistance
)
{
Debug.Log("单位按下ESC键,并且两个单位相距距离超过技能释放距离");
BlackBorad.GameObject.GetComponent <CharacterMono>().isPrepareUseSkill = false;
return(true);
}
return(false);
}
// 产生特效并执行伤害
public void Execute()
{
if (projectileModel.spherInfluence == 0)
{
// 只影响单人的投射物
// 产生敌人身上的特效
if (projectileModel.tartgetEnemryEffect != null)
{
EffectsLifeCycle lifeCycle = TransientGameObjectFactory.AcquireObject(EffectConditonalType.During, templateObject: projectileModel.tartgetEnemryEffect, during: 2f);
lifeCycle.transform.SetParent(target.transform);
lifeCycle.transform.localPosition = Vector3.zero;
}
// 产生目标位置的特效
if (projectileModel.targetPositionEffect != null)
{
EffectsLifeCycle lifeCycle = TransientGameObjectFactory.AcquireObject(EffectConditonalType.During, templateObject: projectileModel.targetPositionEffect, during: 2f);
lifeCycle.transform.SetParent(target.transform);
lifeCycle.transform.localPosition = Vector3.zero;
}
target.characterModel.Damaged(damage);
}
else
{
// 影响一个范围的投射物
// 产生技能特效
// 产生目标位置的特效
if (projectileModel.targetPositionEffect != null)
{
EffectsLifeCycle lifeCycle = TransientGameObjectFactory.AcquireObject(EffectConditonalType.During, templateObject: projectileModel.targetPositionEffect, during: 2f);
lifeCycle.transform.SetParent(target.transform);
lifeCycle.transform.localPosition = Vector3.zero;
}
Collider[] colliders = Physics.OverlapSphere(targetPosition, projectileModel.spherInfluence);
foreach (Collider collider in colliders)
{
CharacterMono targetMono = collider.GetComponent <CharacterMono>();
if (targetMono == null)
{
continue;
}
// 产生敌人身上的特效
if (projectileModel.tartgetEnemryEffect != null)
{
EffectsLifeCycle lifeCycle = TransientGameObjectFactory.AcquireObject(EffectConditonalType.During, templateObject: projectileModel.tartgetEnemryEffect, during: 2f);
lifeCycle.transform.SetParent(target.transform);
lifeCycle.transform.localPosition = Vector3.zero;
}
targetMono.characterModel.Damaged(targetMono, damage, launcher);
}
}
}
/// <summary>
/// 在两个单位之间创建链条特效
/// </summary>
public void CreateChainEffect(CharacterMono speller, CharacterMono target)
{
EffectsLifeCycle lifeCycle = TransientGameObjectFactory.AcquireObject(EffectConditonalType.During, during: 1f, templateObject: TargetEffect);
lifeCycle.transform.position = target.transform.position;
lifeCycle.OnFinshied += () => {
CharacterMono nextTarget = null;
// 找到目标单位周围随机的单位
Collider[] colliders = Physics.OverlapSphere(target.transform.position, SkillInfluenceRadius);
foreach (var collider in colliders)
{
CharacterMono characterMono = collider.GetComponent <CharacterMono>();
if (characterMono != null && characterMono != target)
{
nextTarget = characterMono;
break;
}
}
if (nextTarget != null && nowCount >= 1)
{
Execute(speller, nextTarget);
nowCount -= 1;
}
else
{
// 复原
nowCount = Count;
}
};
}
/// <summary>
/// 非房主产生NPC对象的方法,非房主产生的NPC无AI系统也无同步系统,其主要根据房主的NPC进行同步.
/// </summary>
/// <param name="id"></param>
public void AddNetworkNpc(string id, Vector3 pos, string unitFaction)
{
if (!networkPlayers.ContainsKey(id))
{
CharacterModel characterModel = NpcPrefab.GetComponent <CharacterMono>().characterModel.DeepCopy();
if (unitFaction == "Red")
{
characterModel.unitFaction = UnitFaction.Red;
}
else
{
characterModel.unitFaction = UnitFaction.Blue;
}
// 如果本次生成的对象不是旧对象,那么将该对象放到networkPlayers字典中去,同时给对象增加AI系统和同步系统
CharacterMono NPC = CharacterMonoFactory.AcquireObject(characterModel, NpcPrefab, pos);
networkPlayers[id] = NPC.gameObject;
// 设置网络ID
NPC.GetComponent <CharacterMono>().NetWorkPlayerID = id;
NPC.GetComponent <CharacterMono>().characterModel.Name = id;
// 给产生的网络对象附加伤害同步的监听方法
NPC.GetComponent <CharacterMono>().characterModel.OnDamaged += DamageSynchronize;
}
}
/// <summary>
/// 删除物品同步,监听删除物品事件
/// </summary>
/// <param name="characterMono"></param>
/// <param name="itemGrid"></param>
public void DeleteItemSynchronize(CharacterMono characterMono, ItemGrid itemGrid)
{
if (itemGrid.item == null)
{
return;
}
// 获得物品ID
int itemId = itemGrid.item.ItemId;
// 获得用户名
string userName = NetWorkManager.Instance.NowPlayerID;
// 构造获得物品协议
ProtocolBytes protocolBytes = new ProtocolBytes();
// 协议名
protocolBytes.AddString("DeleteItem");
// 参数
protocolBytes.AddString(userName);
protocolBytes.AddInt(itemId);
// 发送协议
NetWorkManager.Instance.Send(protocolBytes);
}
public void CancelExecute(CharacterMono speller, CharacterMono target)
{
if (CanBeExecuteToTarget(speller, target))
{
target.RemoveBattleState(additiveState.Name);
}
}
/// <summary>
/// 获得一个
/// </summary>
/// <param name="templateObjectt"></param>
/// <param name="position"></param>
/// <returns></returns>
public static CharacterMono AcquireObject(CharacterModel characterModel, GameObject templateObjectt, Vector3 position)
{
GameObject gameObject = GameObject.Instantiate(templateObjectt);
NavMeshHit closetsHit;
if (NavMesh.SamplePosition(position, out closetsHit, 500, 1))
{
gameObject.transform.position = closetsHit.position;
gameObject.GetComponent <NavMeshAgent>().enabled = true;
}
CharacterMono characterMono = gameObject.GetComponent <CharacterMono>();
if (characterMono == null)
{
characterMono = gameObject.AddComponent <CharacterMono>();
}
// 赋值CharacterModel属性
characterMono.characterModel = characterModel.DeepCopy();
// 更改GameObject的名字
characterMono.name = characterModel.Name;
// 将新创建的单位增加到战争迷雾系统中
FogSystem.Instace.AddFOVUnit(characterMono);
return(characterMono);
}
/// <summary>
/// 学习光环技能时,触发的方法
/// </summary>
/// <param name="speller"></param>
public override void Execute(CharacterMono speller)
{
// 给单位增加光环触发器
//==========================================
// 新建光环触发器组件所依附的GameObject对象
GameObject haloTrigger = new GameObject(SkillName + "HaloTrigger");
haloTrigger.transform.SetParent(speller.transform);
haloTrigger.transform.localPosition = Vector3.zero;
//===============================================
// 初始化光环触发器
Trigger = haloTrigger.AddComponent <HaloTrigger>();
// 设置触发器组件
SphereCollider sphereCollider = haloTrigger.AddComponent <SphereCollider>();
sphereCollider.isTrigger = true;
sphereCollider.radius = inflenceRadius;
// 设置光环触发器的一些属性
Trigger.TiggerRadius = inflenceRadius;
Trigger.SkillTargetType = skillTargetType;
Trigger.HaloSkillExecute += Execute;
Trigger.HaloSkillCancelExecute += CancelExecute;
Trigger.gameObject.layer = 2;
Trigger.Speller = speller;
}
public StateConditional(CharacterMono target, BattleState battleState)
{
this.battleState = battleState;
this.target = target;
this.target.OnRemoveBattleStatus += RemoveState;
}
public void Init()
{
characterMono = BlackBorad.CharacterMono;
EnemryTransform = BlackBorad.GetTransform("EnemryTransform");
//enemryMono = BlackBorad.GetGameObject("Enemry").GetComponent<CharacterMono>();
enemryMono = BlackBorad.GetCharacterMono("Enemry");
}
/// <summary>
/// 当单位进入光环时,触发的方法
/// </summary>
/// <param name="speller"></param>
/// <param name="target"></param>
public override void Execute(CharacterMono speller, CharacterMono target)
{
if (CanBeExecuteToTarget(speller, target))
{
// 给目标附加一个持续时间为永久的中毒状态
target.AddBattleState(additiveState.DeepCopy());
}
}
public override void Execute(CharacterMono spller, CharacterMono target)
{
base.Execute(spller, target);
target.characterModel.Damaged(target, new Damage()
{
BaseDamage = Damage.TotalDamage
}, spller);
}
public override void OnAwake()
{
characterMono = GetComponent <CharacterMono>();
if (characterMono.wayPointsUnit != null)
{
moveTargetPosition.Value = characterMono.wayPointsUnit.GetNextWayPoint();
}
}
public override void Execute(CharacterMono speller, CharacterMono target)
{
if (nowCount >= 1)
{
CreateChainEffect(speller, target);
}
target.characterModel.Damaged(Damage);
}
public GameObject GetGameObjectWithPool(Vector3 position, GameObject templateObject = null)
{
lock (pools) {
// 判断要获取的对象的类型在池中是否有
// 如果要获取的对象在对象池中还有剩余
// 返回这个剩余的对象
for (int i = 0; i < pools.Count; i++)
{
PoolData p = pools[i];
if (!p.InUse)
{
// 初始化对象
p.Obj.transform.position = position;
p.Obj.SetActive(true);
p.InUse = true;
// 如果该对象是CharacterMono对象,使其状态回复
CharacterMono c = p.Obj.GetComponent <CharacterMono>();
if (c != null)
{
c.ResetCharacterModel();
}
return(p.Obj);
}
}
// 如果对象池中找不到要获取的对象,或者要获取的对象全部都在使用中,
// 那么新创建一个对象(从模板对象处进行创建)
if (templateObject == null)
{
return(null); // 如果没有模板对象，那么返回null
}
GameObject obj = GameObject.Instantiate(templateObject);
NavMeshHit closetsHit;
if (NavMesh.SamplePosition(position, out closetsHit, 500, 1))
{
obj.transform.position = closetsHit.position;
obj.GetComponent <NavMeshAgent>().enabled = true;
}
// 如果要创建的对象是CharacterMono,那么监听该CharacterMono的死亡事件
// 替换掉原本CharacterMono的死亡事件,将该对象死亡时回收对象池
CharacterMono characterMono = obj.GetComponent <CharacterMono>();
if (characterMono != null)
{
characterMono.OnDiedReplacement += (CharacterMono character) => {
PutObject(character.gameObject);
};
}
PoolData p1 = new PoolData {
InUse = true, Obj = obj
};
pools.Add(p1);
return(obj);
}
}
/// <summary>
/// 增加视野体
/// </summary>
/// <param name="characterMono"></param>
public void AddFOVUnit(CharacterMono characterMono)
{
lock (LogicalLayerObjects) {
LogicalLayerObjects.Add(characterMono);
lock (PresentationLayerObjects){
PresentationLayerObjects.Add(characterMono.characterModel);
}
}
}
// 获得当前单位与目标单位的平方距离(欧几里得距离)
private float GetDistance(CharacterMono unit)
{
float x1 = unit.transform.position.x;
float x2 = characterMono.transform.position.x;
float z1 = unit.transform.position.z;
float z2 = characterMono.transform.position.z;
return((x2 - x1) * (x2 - x1) + (z2 - z1) * (z2 - z1));
}
public void Init(CharacterMono characterMono)
{
characterMono.OnMove += TransformSynchronize;
characterMono.OnPlayAnimation += AniamtionSynchronize;
characterMono.characterModel.LevelChangedHandler += LevelSynchronize;
characterMono.OnSpell += SpellSkillSynchronize;
characterMono.OnGetItem += GetItemSynchronize;
characterMono.OnDelteItem += DeleteItemSynchronize;
}
/// <summary>
///
/// </summary>
/// <param name="damage"></param>
/// <param name="attacker">袭击这个单位的人</param>
public virtual void Damaged(CharacterMono victim, Damage damage, CharacterMono attacker)
{
Damaged(damage);
if (OnDamaged != null)
{
OnDamaged(victim, damage, attacker, Hp);
}
}
/// <summary>
/// Execute方法表示应用此技能的特效,
/// 即 施法开始-产生特效-造成伤害这一系列操作.
/// 更准确的说,这个virtual方法使得技能类几乎可以实现所有效果,
/// 只要后面的子技能类重写就OK了.
/// </summary>
/// <param name="speller">施法者</param>
/// <param name="target">受到法术伤害的目标</param>
public virtual void Execute(CharacterMono speller, Vector3 position)
{
#region 耦合,待重构
speller.characterModel.Mp -= this.mp;
#endregion
finalSpellTime = Time.time;
CreateEffect(speller, position);
}
/// <summary>
/// Execute方法表示应用此技能的特效,
/// 即 施法开始-产生特效-造成伤害这一系列操作.
/// 更准确的说,这个virtual方法使得技能类几乎可以实现所有效果,
/// 只要后面的子技能类重写就OK了.
/// </summary>
/// <param name="speller">施法者</param>
/// <param name="target">受到法术伤害的目标</param>
public virtual void Execute(CharacterMono speller, CharacterMono target)
{
#region 耦合,待重构
speller.characterModel.Mp -= this.mp;
#endregion
finalSpellTime = Time.time;
CreateEffect(speller, target.transform.position);
}
private void Awake()
{
_animator = GetComponent <Animator>();
_weaponMono = GetComponent <WeaponMono>();
_characterMono = GetComponent <CharacterMono>();
_capsuleCollider = GetComponent <CapsuleCollider>();
_rigidbody = GetComponent <Rigidbody>();
_thirdPersonCharacter = GetComponent <ThirdPersonCharacter>();
_thirdPersonUserControl = GetComponent <ThirdPersonUserControl>();
}
public override void Execute(CharacterMono speller, Vector3 position)
{
base.Execute(speller, position);
//========================================
// 为延迟技能(只能对非指向型技能)增加监听事件
for (int i = 0; i < ActiveSkills.Count(); i++)
{
var skill = ActiveSkills[i];
var delayAttribute = SkillDelayAttributes[i];
if (delayAttribute.isDelay && !skill.IsMustDesignation)
{
var activeSkill = ActiveSkills[delayAttribute.index];
if (!activeSkill.IsMustDesignation)
{
OnSkillCompeleteHandler delayExcute = null;
delayExcute = () => {
skill.Execute(speller, position);
};
activeSkill.OnCompelte += delayExcute;
}
}
}
// 首先遍历技能组,释放该技能组中的所有无需对目标单位释放的技能
for (int i = 0; i < ActiveSkills.Count(); i++)
{
var skill = ActiveSkills[i];
var delayAttribute = SkillDelayAttributes[i];
if (!skill.IsMustDesignation && !delayAttribute.isDelay)
{
skill.Execute(speller, position);
}
}
// 在目标地点产生一个球形检测区域,半径由skillInflence决定,
// 对检测区域内所有CharacterMono单位释放技能组中的单体技能
Collider[] colliders = Physics.OverlapSphere(position, skillModel.SkillInfluenceRadius);
foreach (var collider in colliders)
{
CharacterMono target = collider.GetComponent <CharacterMono>();
if (target != null)
{
foreach (var skill in ActiveSkills)
{
if (skill.IsMustDesignation)
{
skill.Execute(speller, target);
}
}
}
}
}
/// <summary>
/// 监听 准备释放技能 事件
/// </summary>
/// <param name="characterMono"></param>
/// <param name="activeSkill"></param>
private void OnPlyaerPrepareSpell(CharacterMono characterMono, ActiveSkill activeSkill)
{
if (characterMono.characterModel.Mp < activeSkill.Mp)
{
if (!isActiveAndEnabled)
{
Show().onComplete += Hide;
}
WarnningString = "当前单位Mp值不足!";
}
}
/// <summary>
/// 向单位固定事件进行订阅，当事件发生时，声音模块将发出声音
/// </summary>
public void Bind(CharacterMono target, AudioSource audioSource)
{
try {
target.OnAttack += (CharacterMono Attacker, CharacterMono Suffered, Damage damage) => {
audioSource.clip = audios[UnitAudioType.AttackAudio];
audioSource.Play();
};
} catch (Exception e) {
Debug.Log(e.Message);
}
}
/// <summary>
/// 遗忘光环技能时,触发的方法
/// </summary>
/// <param name="speller"></param>
public void CancelExecute(CharacterMono speller)
{
//=========================================
// 取消对Trigger事件的监听
Trigger.HaloSkillExecute -= Execute;
Trigger.HaloSkillCancelExecute -= CancelExecute;
//=================================
// 摧毁光环触发器
GameObject.Destroy(Trigger.gameObject);
}
protected virtual void OnEnter(CharacterMono stateHolder)
{
firsstEnterTime = Time.time;
if (stateHolderEffect != null)
{
EffectsLifeCycle lifeCycle = TransientGameObjectFactory.AcquireObject(EffectConditonalType.BattleState, templateObject: stateHolderEffect, battleState: this, target: stateHolder);
lifeCycle.transform.SetParent(stateHolder.transform, false);
lifeCycle.transform.localPosition = Vector3.zero;
}
}
public override void Execute(CharacterMono speller, CharacterMono target)
{
base.Execute(speller, target);
if (AdditionalSkill.IsMustDesignation)
{
Execute(speller, target);
}
else
{
AdditionalSkill.Execute(speller, target.transform.position);
}
}
