/// <summary>
/// 普通攻击
/// </summary>
/// <param name="room"></param>
/// <param name="skillId"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="effect"></param>
/// <returns></returns>
public static DtoDamage[] NormalAttack(RoomBase <MobaPeer> room, int skillId, DtoMinion from, DtoMinion[] to, EffectModel effect)
{
DtoDamage[] damages = new DtoDamage[to.Length];
int attack = from.Attack;
// 遍历被攻击者
for (int i = 0; i < to.Length; i++)
{
DtoMinion item = to[i];
if (item == null)
{
continue;
}
int defense = item.Defense;
int damage = attack - defense;
// 减少生命值
item.CurHp -= damage;
// 死亡处理
if (item.CurHp <= 0)
{
((BattleRoom)room).UnitLost(from, item);
}
damages[i] = new DtoDamage(from.Id, item.Id, damage, item.CurHp <= 0);
}
return(damages);
}
public override void OnOperationRequest(OperationRequest request, SendParameters sendParameters, MobaPeer peer)
{
//MobaServer.LogInfo("处理使用技能的请求");
// 获取房间
int playerId = UserManager.GetPlayer(peer.Username).Identification;
BattleRoom room = Caches.Battle.GetRoomByPlayerId(playerId);
// 获取使用者数据
int fromId = (int)request[(byte)ParameterCode.FromId];
DtoMinion from = room.GetDto(fromId);
// 获取目标数据
DtoMinion[] to = null;
if (request.Parameters.ContainsKey((byte)ParameterCode.TargetArray))
{
int[] toIds = JsonMapper.ToObject <int[]>(request[(byte)ParameterCode.TargetArray] as string);
to = room.GetDtos(toIds);
}
// 获取技能id和等级
int skillId = (int)request[(byte)ParameterCode.SkillId];
int level = (int)request[(byte)ParameterCode.SkillLevel];
// 使用技能
SkillManager.Instance.UseSkill(skillId, level, from, to, room);
// 广播谁使用了技能
room.Brocast(OpCode, request.Parameters);
}
/// <summary>
/// 创建小兵
/// </summary>
/// <param name="minion"></param>
private void CreateMinion(params object[] args)
{
DtoMinion minion = (DtoMinion)args[0];
// 创建实例
GameObject go = null;
go = PoolManager.Instance.GetObject("Minion");
if (minion.Team == 1)
{
go.transform.position = TeamOne.position;
go.transform.SetParent(TeamOne);
}
else
{
go.transform.position = TeamTwo.position;
go.transform.SetParent(TeamTwo);
}
// 初始化控制器
AIBaseCtrl ctrl = go.GetComponent <AIBaseCtrl>();
ctrl.Init(minion, false);
if (minion.Team == 1)
{
(ctrl as MinionCtrl).EndPoint = TeamTwo.position;
ctrl.ChangeState(AIStateEnum.IDLE);
}
else
{
(ctrl as MinionCtrl).EndPoint = TeamOne.position;
ctrl.ChangeState(AIStateEnum.IDLE);
}
}
public override void OnOperationRequest(OperationRequest request, SendParameters sendParameters, MobaPeer peer)
{
//MobaServer.LogInfo("处理计算伤害的请求");
// 获取房间
int playerId = UserManager.GetPlayer(peer.Username).Identification;
BattleRoom room = Caches.Battle.GetRoomByPlayerId(playerId);
// 获取技能id
int skillId = (int)request[(byte)ParameterCode.SkillId];
// 获取攻击者数据
int fromId = (int)request[(byte)ParameterCode.FromId];
DtoMinion from = room.GetDto(fromId);
if (from == null)
{
return;
}
// 获取被攻击者的数据
int[] toIds = JsonMapper.ToObject <int[]>(request[(byte)ParameterCode.TargetArray] as string);
DtoMinion[] to = room.GetDtos(toIds);
// 使用技能 获取伤害数据
DtoDamage[] damages = null;
damages = SkillManager.Instance.Damage(room, skillId, 1, from, to);
// 广播伤害数据传输对象
Dictionary <byte, object> data = new Dictionary <byte, object>();
data.Add((byte)ParameterCode.DtoDamages, JsonMapper.ToJson(damages));
room.Brocast(OperationCode.Damage, data);
}
/// <summary>
/// 根据id获取数据
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public DtoMinion GetDto(int id)
{
DtoMinion dto = null;
// 英雄的id和玩家数据库id一致 所以正数id是英雄
if (id >= 0)
{
dto = GetDtoHero(id);
}
// 建筑id范围
else if (id >= ServerConfig.TeamTwoBuildId - 100 && id <= ServerConfig.TeamOneBuildId)
{
dto = GetDtoBuild(id);
}
// 小兵id范围
else if (id <= ServerConfig.MinionId)
{
dto = GetDtoMinion(id);
}
if (dto == null)
{
MobaServer.LogWarn(">>>>>>>>>>>>>> id:" + id + " cant found");
}
return(dto);
}
/// <summary>
/// 创建小兵
/// </summary>
/// <param name="minion"></param>
public void CreateMinion(params object[] args)
{
DtoMinion minion = (DtoMinion)args[0];
// 创建实例
GameObject go = null;
//go = Instantiate(Resources.Load<GameObject>(Paths.RES_MODEL_MINION + minion.Name),
//Team1MinionPoint[0].position, Quaternion.AngleAxis(180, Vector3.up));
go = PoolManager.Instance.GetObject("Minion");
if (minion.Team == 1)
{
go.transform.position = Team1MinionPoint[0].position;
go.transform.SetParent(Team1Parent);
}
else
{
go.transform.position = Team2MinionPoint[0].position;
go.transform.SetParent(Team2Parent);
}
// 初始化控制器
AIBaseCtrl ctrl = go.GetComponent <AIBaseCtrl>();
ctrl.Init(minion, minion.Team == GameData.HeroData.Team);
CtrlDict.Add(minion.Id, ctrl);
}
/// <summary>
/// 开启定时任务 每30秒生成小兵
/// </summary>
public void SpawnMinion()
{
MobaServer.LogInfo("----------- 开始生产小兵");
List <DtoMinion> minions = new List <DtoMinion>();
// 生成每队的小兵
for (int i = 0; i < 3; i++)
{
// 产生1队小兵
DtoMinion minion = MinionData.GetMinionCopy(m_MinionId--, MinionData.TypeId_Warrior);
minion.Team = 1;
TeamOneMinions.Add(minion.Id, minion);
minions.Add(minion);
// 生产2队小兵
minion = MinionData.GetMinionCopy(m_MinionId--, MinionData.TypeId_Warrior);
minion.Team = 2;
TeamTwoMinions.Add(minion.Id, minion);
minions.Add(minion);
}
// 告诉客户端出兵了
Dictionary <byte, object> data = new Dictionary <byte, object>();
data.Add((byte)ParameterCode.MinionArray, JsonMapper.ToJson(minions.ToArray()));
Brocast(OperationCode.SpawnMinion, data);
// 等待30秒再次产生小兵
StartSchedule(DateTime.UtcNow.AddSeconds(30), SpawnMinion);
}
void Start()
{
DtoMinion data = new DtoMinion(0, 0, TeamId, Hp, Attack, Defense, 5, 1.0f, 8, "Hero");
AIBaseCtrl ctrl = GetComponent <AIBaseCtrl>();
ctrl.Model = data;
ctrl.Init(data, true);
}
/// <summary>
/// 产生小兵
/// </summary>
/// <param name="minions"></param>
public void SpawnMinion(DtoMinion[] minions)
{
// 每0.5秒生产一个小兵
for (int i = 0; i < minions.Length; i++)
{
DtoMinion minion = minions[i];
TimerManager.Instance.AddTimer("SpawnMinion" + minion.Id, i * 0.5f, CreateMinion, minion);
}
}
/// <summary>
/// 根据id数组获取数据
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public DtoMinion[] GetDtos(int[] ids)
{
DtoMinion[] dtos = new DtoMinion[ids.Length];
for (int i = 0; i < ids.Length; i++)
{
dtos[i] = GetDto(ids[i]);
}
return(dtos);
}
void Start()
{
DtoMinion data = new DtoMinion(0, 0, TeamId, Hp, Attack, Defense, 3, 1.5, 3, "Minion");
MinionCtrl ctrl = GetComponent <MinionCtrl>();
ctrl.Model = data;
ctrl.Init(data, false);
ctrl.EndPoint = End.position;
ctrl.ChangeState(AIStateEnum.IDLE);
}
/// <summary>
/// 产生小兵
/// </summary>
/// <param name="minions"></param>
private void SpawnMinion()
{
// 每0.5秒创建一个小兵
for (int i = 0; i < m_MinionNum; i++)
{
DtoMinion teamOneMinion = new DtoMinion(m_MinionId--, 0, 1, 220, 40, 20, 3, 1.5, 5, "Minion");
TimerManager.Instance.AddTimer("SpawnMinion" + teamOneMinion.Id, i * 0.5f, CreateMinion, teamOneMinion);
DtoMinion teamTwoMinion = new DtoMinion(m_MinionId--, 0, 2, 220, 40, 20, 3, 1.5, 5, "Minion");
TimerManager.Instance.AddTimer("SpawnMinion" + teamTwoMinion.Id, i * 0.5f, CreateMinion, teamTwoMinion);
}
}
public override void Init(DtoMinion model, bool friend)
{
base.Init(model, friend);
// 设置小地图头像颜色
if (friend)
{
MiniMapHead.color = Color.blue;
}
else
{
MiniMapHead.color = Color.red;
}
}
/// <summary>
/// 使用技能 执行技能效果 不处理伤害
/// </summary>
/// <param name="room">使用房间</param>
/// <param name="from">使用者</param>
/// <param name="to">目标</param>
/// <returns></returns>
public void RunSkill(RoomBase <MobaPeer> room, DtoMinion from, DtoMinion[] to)
{
if (Effect == null)
{
return;
}
for (int i = 0; i < Effect.GetInvocationList().Length; i++)
{
var action = (EffectHandler)Effect.GetInvocationList()[i];
action(room, SkillId, from, to, Data[i]);
}
}
public static void AttakSpeedDouble(RoomBase <MobaPeer> room, int skillId, DtoMinion from, DtoMinion[] to,
EffectModel effect)
{
double original = from.AttackInterval;
// 增加攻速 1/攻击间隔 转换为每秒攻击次数 再乘以倍数
from.AttackInterval = 1 / (1 / from.AttackInterval * (effect.EffectValue - 1));
// 恢复攻速
room.StartSchedule(DateTime.UtcNow.AddSeconds(effect.Duration), () =>
{
from.AttackInterval = original;
});
}
/// <summary>
/// 移速buff/debuff
/// </summary>
/// <param name="room"></param>
/// <param name="skillId"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="effect"></param>
/// <returns></returns>
public static void SpeedDouble(RoomBase <MobaPeer> room, int skillId, DtoMinion from, DtoMinion[] to,
EffectModel effect)
{
// 增加移速
double value = from.Speed * (effect.EffectValue - 1);
from.Speed += value;
// 恢复移速
room.StartSchedule(DateTime.UtcNow.AddSeconds(effect.Duration), () =>
{
from.Speed -= value;
});
}
/// <summary>
/// 根据标识id获取小兵
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public DtoMinion GetDtoMinion(int id)
{
DtoMinion minion = null;
if (TeamOneMinions.TryGetValue(id, out minion))
{
return(minion);
}
if (TeamTwoMinions.TryGetValue(id, out minion))
{
return(minion);
}
return(null);
}
public override void Init(DtoMinion model, bool friend)
{
base.Init(model, friend);
// 设置小地图头像颜色
if (friend)
{
MiniMapHead.color = Color.blue;
}
else
{
MiniMapHead.color = Color.red;
}
m_IsFriend = friend;
m_Rader.Open(this);
}
public override void Init(DtoMinion model, bool friend)
{
base.Init(model, friend);
Speed = (float)Model.Speed;
m_IsFriend = friend;
// 开启寻路
SetAgent(true);
// 开启雷达
Radar.Open(this);
if (friend)
{
// 设置小地图头像颜色
MiniMapHead.color = Color.blue;
// 修改纹理
GetComponentInChildren <SkinnedMeshRenderer>().material.mainTexture = Resources.Load <Texture>(Paths.TEXTURE_MINION_BULE);
}
else
{
// 设置小地图头像颜色
MiniMapHead.color = Color.red;
// 修改纹理
GetComponentInChildren <SkinnedMeshRenderer>().material.mainTexture = Resources.Load <Texture>(Paths.TEXTURE_MINION_RED);
}
#if TEST
return;
#endif
// 设置终点为对方小兵出生地
if (model.Team == 1)
{
EndPoint = BattleData.Instance.Team2MinionPoint[0].position;
}
else
{
EndPoint = BattleData.Instance.Team1MinionPoint[0].position;
}
ChangeState(AIStateEnum.IDLE);
}
public override void Init(DtoMinion model, bool friend)
{
base.Init(model, friend);
// 设置移动速度
Speed = (float)Model.Speed;
#if !TEST
// 调整角度
MiniMapHead.transform.rotation = Quaternion.Euler(90, 0, 0);
transform.rotation = Model.Team == 1 ? Quaternion.Euler(0, 90, 0) : Quaternion.Euler(0, -90, 1);
#endif
// 初始化状态机
AddState(new HeroIdel());
AddState(new HeroMove());
AddState(new HeroAttack());
AddState(new HeroDead());
ChangeState(AIStateEnum.IDLE);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="model"></param>
/// <param name="friend"></param>
public virtual void Init(DtoMinion model, bool friend)
{
Model = model;
// 设置血条颜色
m_HpCtrl.SetColor(friend);
OnHpChange();
// 设置层
if (friend)
{
gameObject.layer = LayerMask.NameToLayer("Friend");
}
else
{
gameObject.layer = LayerMask.NameToLayer("Enemy");
}
// 设置攻击速度
if (AnimeCtrl != null)
{
AnimeCtrl.SetAttackSpeed((float)model.AttackInterval);
}
}
/// <summary>
/// 攻击buff/debuff
/// </summary>
/// <param name="room"></param>
/// <param name="skillId"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="effect"></param>
/// <returns></returns>
public static void AttackDouble(RoomBase <MobaPeer> room, int skillId, DtoMinion from, DtoMinion[] to,
EffectModel effect)
{
// 增加攻击
double value = from.Attack * (effect.EffectValue - 1);
from.Attack += (int)value;
string timerKey = ServerConfig.GetEffectKey(from.Id, skillId, effect.Type);
MobaServer.LogInfo(">>>>>>>>>>> value:" + value);
MobaServer.LogInfo(">>>>>>>>>> attack : " + from.Attack);
// 恢复攻击
Action action = () =>
{
from.Attack -= (int)value;
MobaServer.LogInfo(">>>>>>>>>> attack : " + from.Attack);
// 移除延时处理
TimerDict.Remove(timerKey);
};
Guid guid = room.Timer.AddAction(DateTime.UtcNow.AddSeconds(effect.Duration), action);
// 添加到延时处理
TimerDict.Add(timerKey, new TimerAction(guid, action));
}
/// <summary>
/// 失去单位
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
public void UnitLost(DtoMinion from, DtoMinion to)
{
// 传输数据
Dictionary <byte, object> data = new Dictionary <byte, object>();
DtoHero[] heros = null;
int getCoinsId = 0;
#region 经验奖励
int exp = 0;
// 被击杀者是小兵
if (to.Id <= ServerConfig.MinionId)
{
exp = 100;
}
// 被击杀者是英雄
else if (to.Id >= 0)
{
exp = 100 * (to as DtoHero).Level;
}
// 添加经验
heros = TeamGetExp(from.Team, exp);
#endregion
#region 金币奖励
// 击杀者是英雄才有金币
if (from.Id > 0)
{
int coins = 0;
// 小兵
if (to.Id <= ServerConfig.MinionId)
{
coins = 50;
}
// 英雄
else if (to.Id >= 0)
{
coins = 300;
}
// 建筑
else if (to.Id >= ServerConfig.TeamTwoBuildId - 100 && to.Id <= ServerConfig.TeamOneBuildId)
{
// 防御塔
if (to.TypeId == ServerConfig.TowerId)
{
coins = 200;
}
}
// 添加金币
getCoinsId = HeroGetCoins(from.Id, coins);
}
#endregion
// 发送奖励数据
data.Add((byte)ParameterCode.HerosArray, JsonMapper.ToJson(heros));
data.Add((byte)ParameterCode.HeroId, getCoinsId);
Brocast(OperationCode.GetReward, data);
// 如果被杀的是小兵 移除小兵数据
if (to.Id <= ServerConfig.MinionId)
{
if (TeamOneMinions.ContainsKey(to.Id))
{
TeamOneMinions.Remove(to.Id);
}
if (TeamTwoMinions.ContainsKey(to.Id))
{
TeamTwoMinions.Remove(to.Id);
}
}
else if (to.Id > 0)
{
// 如果被杀的是英雄 开启复活倒计时
StartSchedule(DateTime.UtcNow.AddSeconds(ServerConfig.HeroRebirthCD), () =>
{
data.Clear();
// 恢复血量
to.CurHp = to.MaxHp;
// 广播英雄复活的消息
data.Add((byte)ParameterCode.HeroId, to.Id);
Brocast(OperationCode.HeroRebirth, data);
});
}
}
/// <summary>
/// 计算伤害
/// </summary>
/// <param name="room"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <returns></returns>
public DtoDamage[] RunDamage(RoomBase <MobaPeer> room, DtoMinion from, DtoMinion[] to)
{
return(Damage == null ? null : Damage(room, SkillId, from, to, Data[Data.Length - 1]));
}
/// <summary>
/// 计算伤害
/// </summary>
/// <param name="skillId"></param>
/// <param name="level"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="room"></param>
/// <returns></returns>
public DtoDamage[] Damage(RoomBase <MobaPeer> room, int skillId, int level, DtoMinion from, DtoMinion[] to)
{
SkillHandler skillHandler = HandlerDict.ExTryGet(skillId)[level - 1];
return(skillHandler.RunDamage(room, from, to));
}
/// <summary>
/// 使用技能
/// </summary>
/// <param name="skillId"></param>
/// <param name="level"></param>
/// <param name="room"></param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <returns></returns>
public void UseSkill(int skillId, int level, DtoMinion from, DtoMinion[] to = null, RoomBase <MobaPeer> room = null)
{
SkillHandler skillHandler = HandlerDict.ExTryGet(skillId)[level - 1];
skillHandler.RunSkill(room, from, to);
}
