/// <summary>
/// 根据服务器传来的数值，显示伤害
/// </summary>
/// <param name="damageDTO"></param>
private void Damage(DamageDTO damageDTO)
{
foreach (int[] damage in damageDTO.targetDamages)
{
SendMsg(Msgs.GetMsgIntArr((ushort)FightEvent.Damage, damage));
}
}
public void Attacked()
{
state = AnimState.Idle;
animatorManage.SetInt("state", (int)state);
if (id != GameData.UserDto.id)
{
return; //如果不是自己打出伤害，则返回
}
// 发送伤害
if (list.Length > 0)
{
List <int[]> idListList = new List <int[]>();
List <int> idList = new List <int>();
DamageDTO damageDto = new DamageDTO();
damageDto.userid = id;
if (SkillAttackDto != null && SkillAttackDto.skillDto.id > 0)
{
damageDto.skill = SkillAttackDto.skillDto.id;
}
else
{
damageDto.skill = -1;
}
for (int i = 0; i < list.Length; i++)
{
idList.Add(list[i].GetComponent <Info>().id);
idListList.Add(idList.ToArray());
}
damageDto.targets = idListList.ToArray();
NetIO.Instance.Write(Protocol.Map, SceneManager.GetActiveScene().buildIndex, MapProtocol.Damage_CREQ, damageDto);
}
}
/// <summary>
/// 子弹伤害请求
/// </summary>
/// <param name="token"></param>
/// <param name="model"></param>
internal void BulletDamageCREQ(BaseToken token, TransModel model)
{
if (state != FightRoomState.Fight)
{
return;
}
//throw new NotImplementedException();
if (IsVaildUserModel(token))
{
try {
DamageDTO damageDTO = model.GetMsg <DamageDTO>();
if (tokenToModelID[token] == damageDTO.SrcID)
{
if (tokenToModelID.ContainsValue(damageDTO.DstID))
{
lock (DamageDic) {
DamageMutex.WaitOne();
if (!DamageDic.ContainsKey(damageDTO.SrcID))
{
//DamageDic.Add(damageDTO.SrcID, 0);
baseModelDic[damageDTO.DstID].hp -= 20;
//伤害广播
Broadcast(tokenToModelID.Keys.ToList(), 1003010, 0, damageDTO);
if (baseModelDic[damageDTO.DstID].hp <= 0)
{
//击杀 广播 && 失败反馈
BaseToken dstToken = tokenToModelID.Where((t, id) => t.Value == damageDTO.DstID).ToList()[0].Key;
Broadcast(tokenToModelID.Keys.ToList(), 1003011, 0, damageDTO);
Send(dstToken, 10039998, damageDTO.DstID);
// 清除失败 token
tokenToModelID.Remove(dstToken);
tokenToUserDTO.Remove(dstToken);
long rid;
FightManager.Ins.tokenToRoomID.Remove(dstToken, out rid);
if (tokenToModelID.Count == 1)
{
//成功广播 并销毁房间
Broadcast(tokenToModelID.Keys.ToList(), 10039999, damageDTO.SrcID);
Clear();
}
}
}
DamageMutex.ReleaseMutex();
}
}
}
}
catch (Exception ex) {
Debugger.Error(ex.ToString());
//throw;
}
}
}
private void Damage(DamageDTO value)
{
foreach (int[] target in value.Targets)
{
PlayerCtr pc = models[target[0]];
//实例化掉血数字
FightScene.Instance.NumUp(pc.transform, target[1].ToString());
pc.HpChange();
if (pc.data.Id == GameData.user.ID)
{
FightScene.Instance.RefreshView(pc.data);
}
if (target[2] == 0)
{
if (target[0] >= 0)
{
pc.gameObject.SetActive(false);
if (pc.data.Id == GameData.user.ID)
{
FightScene.Instance.Dead = true;
}
}
else
{
Destroy(pc.gameObject);
}
}
}
}
private void damage(DamageDTO value)
{
foreach (int[] item in value.target)
{
PlayerCon pc = models[item[0]];
pc.data.hp -= item[1];
//实例化掉血数字
FightScene.instance.NumUp(pc.transform, item[1].ToString());
pc.HpChange();
if (pc.data.id == GameData.User.id)
{
FightScene.instance.refreshView(pc.data);
}
if (item[2] == 0)
{
if (item[0] >= 0)
{
pc.gameObject.SetActive(false);
if (pc.data.id == GameData.User.id)
{
FightScene.instance.dead = true;
}
}
else
{
Destroy(pc.gameObject);
}
}
}
}
public InspectionDTO ToDTO(Inspection inspection)
{
InspectionDTO inspectionDTO = new InspectionDTO();
inspectionDTO.CreatorUserName = inspection.IdUser.UserName;
inspectionDTO.Date = inspection.Date;
inspectionDTO.Location = inspection.IdLocation.Name;
inspectionDTO.Id = inspection.Id;
inspectionDTO.IdVehicle = inspection.IdVehicle.Vin;
if (inspection.Damages != null)
{
List <DamageDTO> damagesDTO = new List <DamageDTO>();
foreach (Damage damage in inspection.Damages)
{
DamageDTO damageDTO = new DamageDTO();
damageDTO.Description = damage.Description;
damageDTO.Images = new List <Base64ImageDTO>();
foreach (Base64Image image in damage.Images)
{
Base64ImageDTO imageDTO = new Base64ImageDTO();
imageDTO.Base64EncodedImage = image.Base64EncodedImage;
damageDTO.Images.Add(imageDTO);
}
damagesDTO.Add(damageDTO);
}
inspectionDTO.Damages = damagesDTO;
}
return(inspectionDTO);
}
protected void NetWorkSetDamage()
{
DamageDTO dto = new DamageDTO();
dto.id = atkId;
dto.skill = skill;
dto.targetDamage = new int[][] { new int[] { target.GetComponent <PlayerCon>().Data.id } };
NetWorkScript.Instance.write(Protocol.TYPE_FIGHT, -1, FightProtocol.DAMAGE_CREQ, dto);
}
private void damage(DamageDTO dto)
{
foreach (int[] item in dto.targetDamage)
{
GameObject target = FightUnitMgr.Instance.GetGameObjectById(item[0]);
if (target != null)
{
target.GetComponent <FightUnit>().damage(item[1]);
}
}
}
private void damage(DamageDTO dto)
{
foreach (int[] item in dto.targetDamage)
{
GameObject target = heros[item[0]];
//todo damage text effect
//GameObject obj= Instantiate(ResourceLoad.getHpUp(), target.transform.position+Vector3.up*2, Camera.main.transform.rotation) as GameObject;
//obj.GetComponent<HpUp>().setValue(item[1]);
target.GetComponent <PlayerComponent>().con.damage(item[1]);
}
}
public async Task <IActionResult> DamageCharacter(string characterName, DamageDTO damageDTO)
{
try
{
return(StatusCode(200, (await _characterHealthService.DamageCharacter(characterName, damageDTO.Damage)).HP));
}
catch (KeyNotFoundException keyEx) { return(StatusCode(404)); }
catch (ArgumentException argEx) { return(StatusCode(400)); }
catch (Exception ex)
{
_logger.LogError(ex, "Error in damage character");
return(StatusCode(500));
}
}
private void DamageBro(DamageDTO damagedto)//damagedto.targets[i][0]//0为被攻击者id,1为收到伤害的值，2被攻击者是否死亡，3是否触发暴击
{
for (int i = 0; i < damagedto.targets.Length; i++)
{
UserDTO userDto = IdToUserDtoDic[damagedto.targets[i][0]] as UserDTO;
GameObject model = idToGameObjectDic[damagedto.targets[i][0]];
if (userDto != null)
{
if (userDto.id >= 0) //受到伤害的是否为玩家
{
if (userDto.id == GameData.UserDto.id) //受到攻击为本人，更新ui界面的数据
{
GameData.SetHpMp(-damagedto.targets[i][1]);
}
else
{
userDto.hp -= damagedto.targets[i][1];
if (userDto.hp <= 0)
{
userDto.hp = 0;
}
}
//更新玩家血条数据
model.transform.Find("infoUi").GetComponent <CameraFacingBillboard>().SetInfo(userDto.name, (float)userDto.hp / userDto.maxHp, (float)userDto.mp / userDto.maxMp);
}
else
{
model.transform.Find("infoUi").GetComponent <CameraFacingBillboard>().SetInfo(userDto.name, (float)userDto.hp / userDto.maxHp);
}
Info info = model.GetComponent <Info>();
InitFallBoold(info, damagedto.targets[i][1], Color.red, damagedto.targets[i][3]);//实例化掉血
AnimatorManage animatorManage = model.GetComponent <AnimatorManage>();
info.state = AnimState.Control;
animatorManage.SetInt("state", (int)AnimState.Control);
if (damagedto.targets[i][2] == 0 || userDto.hp <= 0)
{
if (userDto.id == GameData.UserDto.id)//自己死亡，显示复活时间和开启ui遮罩
{
mask.gameObject.SetActive(true);
fuhuoText.gameObject.SetActive(true);
timer = 11;
isFuhuo = true;
}
info.state = AnimState.Die;
animatorManage.SetInt("state", (int)AnimState.Die);
}
}
}
}
/// <summary>
/// 动画事件添加
/// </summary>
public override void attacked()
{
//用于显示特效
state = AnimState.IDLE;
//遍历攻击目标
foreach (Transform item in list)
{
//向服务器发送伤害
DamageDTO dto = new DamageDTO();
dto.userId = data.id;
dto.skill = -1;
dto.target = new int[][] { new int[] { item.GetComponent <PlayerCon>().data.id } };
this.Write(Protocol.TYPE_FIGHT, 0, FightProtocol.DAMAGE_CREQ, dto);
}
}
void Update()
{
if (target)
{
transform.position = Vector3.Lerp(transform.position, target.position, 0.5f);
if (Vector3.Distance(transform.position, target.position) < 0.1f)
{
//向服务器发送 伤害目标
DamageDTO dto = new DamageDTO();
dto.userId = userId;
dto.skill = skill;
dto.target = new int[][] { new int[] { target.GetComponent <PlayerCon>().data.id } };
this.WriteMessage(Protocol.TYPE_FIGHT, 0, FightProtocol.DAMAGE_CREQ, dto);
Destroy(gameObject);
}
}
}
private List <DamageDTO> CreateDamages()
{
Base64ImageDTO base64Image = new Base64ImageDTO();
base64Image.Base64EncodedImage = Convert.ToBase64String(File.ReadAllBytes(@"..\..\Damage\attention.png"));
DamageDTO damage = new DamageDTO();
damage.Description = "Daño en la puerta derecha";
damage.Images = new List <Base64ImageDTO>();
damage.Images.Add(base64Image);
List <DamageDTO> damages = new List <DamageDTO>();
damages.Add(damage);
return(damages);
}
void Update()
{
if (target != null)
{
transform.position = Vector3.Lerp(transform.position, target.position, 0.5f);
if (Vector3.Distance(transform.position, target.position) < 0.1f)
{
//像服务器发送伤害目标
DamageDTO dto = new DamageDTO();
dto.UserID = userId;
dto.Skill = skill;
dto.Targets = new int[][] { new int[] { target.GetComponent <PlayerCtr>().data.Id } };
this.Wirte(Protocol.TYPE_FIGHT, 0, FightProtocol.DAMAGE_CREQ, dto);
Destroy(gameObject);
}
}
}
void OnCollisionEnter(Collision c)
{
int target;
if (c.gameObject.layer == LayerMask.NameToLayer("enemy"))
{
target = c.gameObject.GetComponent <PlayerCon>().data.id;
}
else
{
return;
}
DamageDTO dto = new DamageDTO();
dto.userId = GameData.user.id;
dto.skill = 1;
dto.target = new int[][] { new int[] { target } };
this.WriteMessage(Protocol.TYPE_FIGHT, 0, FightProtocol.DAMAGE_CREQ, dto);
}
public void MapDamageDTOToDamageTest()
{
VehicleDTO vehicle = this.CreateVehicle();
DamageMapper mapper = new DamageMapper();
Base64ImageDTO base64Image = new Base64ImageDTO();
base64Image.Base64EncodedImage = Convert.ToBase64String(File.ReadAllBytes(@"..\..\Damage\attention.png"));
DamageDTO damage = new DamageDTO();
damage.Description = "Daño en la puerta derecha";
damage.Images = new List <Base64ImageDTO>();
damage.Images.Add(base64Image);
Damage damageEntity = mapper.ToEntity(damage);
Assert.AreEqual(damage.Description, damageEntity.Description);
foreach (Base64ImageDTO image in damage.Images)
{
Assert.IsNotNull(damageEntity.Images.Find(i => i.Base64EncodedImage == image.Base64EncodedImage));
}
}
public void damage(DamageDTO value)
{
foreach (int[] item in value.target)
{
PlayerCon pc = models[item[0]];
pc.data.hp -= item[1];
//掉血效果
Debug.Log("受到伤害掉血");
//更新ui
gohpDic[pc.data.id].GetComponent <HpBar>().refesh(pc.data);
if (pc.data.id == GameData.user.id)
{
//如果是自己受到伤害
}
if (item[2] == 0)//hp没有了
{
if (item[0] >= 0)
{
//pc.gameObject.SetActive(false);
//gohpDic[pc.data.id].SetActive(false);
//models.Remove(pc.data.id);//将该英雄从列表中移除
pc.death();
//血条处理
Destroy(gohpDic[pc.data.id]);
gohpDic.Remove(pc.data.id);
//gohpDic.Remove();
if (pc.data.id == GameData.user.id)
{
//s设置-->死亡
deathMask.gameObject.SetActive(true);
}
}
else
{
Destroy(pc.gameObject);
}
}
}
}
IEnumerator skillToTarget()
{
while (true)
{
if (target)
{
transform.position = Vector3.Lerp(transform.position, target.transform.position + Vector3.up, 0.5f);
if (Vector3.Distance(transform.position, target.transform.position + Vector3.up) < 0.1f)
{
//发送攻击 切销毁自身
DamageDTO dto = new DamageDTO();
dto.id = atkId;
dto.skill = skill;
dto.targetDamage = new int[][] { new int[] { target.GetComponent <FightUnit>().getData().id } };
this.WriteMessage(Protocol.TYPE_FIGHT, -1, FightProtocol.DAMAGE_CREQ, dto);
Destroy(gameObject);
StopCoroutine(skillToTarget());
}
}
yield return(new WaitForEndOfFrame());
}
}
private void damage(UserToken token, DamageDTO value)
{
AbsFightModel atkPlayer = null;
int userId = getUserId(token);
int skillLevel = 0;
int atkTeam = 0;
FightModelType atkType;
if (value.id > 0)
{
if (value.id != userId)
{
return;
}
atkPlayer = getPlayer(userId);
if (value.skill > 0)
{
skillLevel = (atkPlayer as FightPlayerModel).skillLevel(value.skill);
if (skillLevel == -1)
{
return;
}
}
atkTeam = getPlayerTeam(userId);
atkType = FightModelType.HUMAN;
}
else
{
//TODO 如果ID小于0的话 则为炮塔或者小兵 需要判断目标是否为用户
if (value.id >= -20)
{
atkType = FightModelType.BUILD;
}
else
{
atkType = FightModelType.HUMAN;
}
}
if (!SkillProcessMap.has(value.skill))
{
return;
}
ISkill skill = SkillProcessMap.get(value.skill);
List <int[]> damages = new List <int[]>();
foreach (int[] item in value.targetDamage)
{
AbsFightModel beatk = null;
int beTeam = 0;
FightModelType beatkType;
if (item[0] > 0)
{
beatk = getPlayer(item[0]);
beTeam = getPlayerTeam(item[0]);
beatkType = FightModelType.HUMAN;
}
else
{
if (item[0] >= -20)
{
if (item[0] >= -10)
{
beatk = teamOneBuildMap[item[0]];
beTeam = 1;
}
else
{
beatk = teamTwoBuildMap[item[0]];
beTeam = 2;
}
beatkType = FightModelType.BUILD;
}
else
{
//TODO这里是小兵了
beatkType = FightModelType.HUMAN;
}
}
skill.damage(skillLevel, ref atkPlayer, ref beatk, atkType, beatkType, atkTeam == beTeam, ref damages);
if (beatk.hp == 0)
{
if (beatk.id > 0)
{
//说明是英雄 给予击杀者奖金
}
else if (beatk.id < -20)
{
//说明是小兵 给予周围辅助 辅助金
}
else
{
//说明是炮台 判断是否拥有复活能力 给予全体奖金
}
}
}
DamageDTO dto = new DamageDTO();
dto.id = value.id;
dto.skill = value.skill;
dto.targetDamage = damages.ToArray();
brocast(FightProtocol.DAMAGE_BRO, dto);
}
void damage(NetFrame.UserToken token, DamageDTO value)
{
int userID = getUserID(token);
AbsFightModel atkModel;
int skillLevel = 0;
//判断攻击者
if (value.userId >= 0)
{
if (value.userId != userID)
{
return;
}
atkModel = getPlayer(userID);
if (value.skill > 0)
{
skillLevel = (atkModel as FightPlayerModel).SkillLevel(value.skill);
if (skillLevel == -1)
{
return;
}
}
}
else
{
atkModel = getPlayer(userID);
}
//TODO
//获取技能算法
//循环获取目标数据 和攻击者数据 进行伤害计算 得出伤害数值
if (!SkillProcessMap.has(value.skill))
{
return;
}
ISkill skill = SkillProcessMap.get(value.skill);
List <int[]> damages = new List <int[]>();
foreach (int[] item in value.target)
{
AbsFightModel target = getPlayer(item[0]);
skill.damage(skillLevel, ref atkModel, ref target, ref damages);
//Console.WriteLine("计算伤害值");
if (target.hp == 0)
{
switch (target.type)
{
case ModelType.HUMAN:
if (target.id > 0)
{
//击杀英雄
//启动定时任务 指定时间之后发送英雄复活信息 并且将英雄数据设置为满状态
}
else
{
//击杀小兵
//移除小兵数据
}
break;
case ModelType.BUILD:
//打破了建筑 给钱
break;
}
}
}
value.target = damages.ToArray();
brocast(FightProtocol.DAMAGE_BRO, value);
}
private void Damage(UserToken token, DamageDTO value)
{
int userId = GetUserId(token);
AbsFightModel atkModel;
int skillLevel = 0;
//判断攻击者是玩家英雄 还是小兵
if (value.UserID >= 0)
{
if (value.UserID != userId)
{
return;
}
atkModel = GetPlayer(userId);
if (value.Skill > 0)
{
skillLevel = (atkModel as FightPlayerModel).SkillLevel(value.Skill);
if (skillLevel == -1)
{
return;
}
}
}
else
{
//TODO:
atkModel = GetPlayer(userId);
}
//获取技能算法
//循环获取目标数据 和攻击者数据 进行伤害计算 得出伤害数值
if (!SkillProcessMap.Has(value.Skill))
{
return;
}
ISkill skill = SkillProcessMap.Get(value.Skill);
List <int[]> damages = new List <int[]>();
foreach (int[] item in value.Targets)
{
AbsFightModel target = GetPlayer(item[0]);
skill.Damage(skillLevel, ref atkModel, ref target, ref damages);
if (target.Hp == 0)
{
switch (target.Type)
{
case ModelType.HUMAN:
if (target.Id > 0)
{
//击杀英雄
//启动定时任务 指定时间之后发送英雄复活信息 并且将英雄数据设置为满状态
}
else
{
//击杀小兵
//移除小兵数据
}
break;
case ModelType.BUILD:
//打破了建筑 给钱
break;
}
}
}
value.Targets = damages.ToArray();
Brocast(FightProtocol.DAMAGE_BRO, value);
}
void Damage(UserToken token, DamageDTO damageDto)
{
int userId = userCache.GetUserId(token);
AbsRoleModel attRoleModel = GetRoleModel(userId);;
damageDto.userid = userId;
List <int[]> damages = new List <int[]>();
for (int i = 0; i < damageDto.targets.Length; i++)
{
AbsRoleModel targetRoleModel = GetRoleModel(damageDto.targets[i][0]);
GetValue(token, userId, damageDto.skill, ref attRoleModel, ref targetRoleModel, ref damages);
if (targetRoleModel.hp <= 0)
{
string kill = "";
ExecutorPool.Instance.Executor(delegate
{
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
if (random.Next(0, 11) > 4)
{
int index = random.Next(0, inventorys.Length - 1);
InventoryItemDTO itemDto = inventoryBiz.AddInventory(token, inventorys[index]);
Write(token, Protocol.Inventory, GetArea(), InventoryProtocol.AddInventory_SRES, itemDto);
kill = "并且获得斩杀奖励【" + itemDto.inventory.name + "】，别的小伙伴请继续努力！";
}
});//随机掉物品
targetRoleModel.hp = 0;
TalkDTO talkDto = new TalkDTO();
talkDto.userid = -1;
talkDto.talkType = TalkType.System;
talkDto.userName = "******";
talkDto.text = attRoleModel.name + "杀死了" + targetRoleModel.name + "！" + kill;
Brocast(MapProtocol.Talk_BRO, talkDto);//广播信息
UserDTO attUserDto = attRoleModel as UserDTO;
USER attUser = userCache.GetUserById(targetRoleModel.id);
if (attUserDto != null)
{
attUser.Money += attUser.Level * 100;
attUserDto.money += attUserDto.level * 100;
attUserDto.exp += 30 * (targetRoleModel.level / attUserDto.level) + attUserDto.level * 5;
attUser.Exp += 30 * (targetRoleModel.level / attUserDto.level) + attUserDto.level * 5;
int total_exp = 100 + attUser.Level * 30;
while (attUser.Exp >= total_exp)
{
// 升级
attUser.Level++;
attUserDto.level++;
attUser.Exp -= total_exp;
attUserDto.exp = attUser.Exp;
attUser.Hp += attUser.Level * 50;
attUser.MaxHp += attUser.Level * 50;
attUser.Mp += attUser.Level * 25;
attUser.MaxMp += attUser.Level * 25;
attUserDto.hp += attUserDto.level * 50;
attUserDto.maxHp += attUserDto.level * 50;
attUserDto.mp += attUserDto.level * 25;
attUserDto.maxMp += attUserDto.level * 25;
total_exp = 100 + attUser.Level * 30;
}
Brocast(MapProtocol.Killraward_BRO, attUserDto);//广播杀人
}
if (targetRoleModel.id >= 0)
{
// 开启计时任务复活
int timeEventId = ScheduleUtil.Instance.Schedule(delegate
{
UserDTO userDto = targetRoleModel as UserDTO;
userDto.hp = (int)(userDto.maxHp * 0.5f);
userDto.mp = (int)(userDto.maxMp * 0.5f);
USER user = userCache.GetUserById(targetRoleModel.id);
user.Hp = (int)(user.MaxHp * 0.5);
user.Mp = (int)(user.MaxMp * 0.5);
Brocast(MapProtocol.Revive_BRO, targetRoleModel.id);
}, 10);//10秒后复活玩家
}
else
{
//TODO 击杀NPC移除NPC数据
}
}
}
damageDto.targets = damages.ToArray();
Brocast(MapProtocol.Damage_BRO, damageDto);
}
/// <summary>
/// 计算伤害、存储结果、并向客户端发送消息
/// </summary>
/// <param name="token"></param>
/// <param name="damageDTO"></param>
private void Damage(UserToken token, DamageDTO damageDTO)
{
int userId = GetUserId(token);
AbsFightInstance atkInstance;
int skillLevel = 0;
//判断攻击者是玩家英雄 还是小兵
if (damageDTO.userId >= 0)//是英雄
{
if (damageDTO.userId != userId)
{
return;
}
atkInstance = instances[userId];
if (damageDTO.skill > 0)
{
skillLevel = (atkInstance as HeroInstance).SkillLevel(damageDTO.skill);
if (skillLevel == -1)
{
return;
}
else
{
}
}
}
else//是兵或者建筑
{
//TODO:
atkInstance = instances[userId];
}
if (!SkillData.SkillModels.ContainsKey(damageDTO.skill))
{
return;
}
//1.获取技能方法
ISkill skill = SkillProcessMap.Get(damageDTO.skill);
List <int[]> damages = new List <int[]>();
//2.根据技能定义，获取目标数据和攻击者数据，计算伤害值
foreach (int[] item in damageDTO.targetDamages)
{
AbsFightInstance target = instances[item[0]];
//计算伤害值并存储
skill.Damage(skillLevel, ref atkInstance, ref target, ref damages);
if (target.hp == 0)
{
switch (target.fightModel.category)
{
case (byte)ModelType.Hero:
//击杀英雄
//奖励玩家
//启动定时任务 指定时间之后发送英雄复活信息 并且将英雄数据设置为满状态
break;
case (byte)ModelType.Creature:
//发送消息
//TODO 给钱、经验
//移除生物数据
break;
case (byte)ModelType.Building:
//摧毁建筑 给钱，通知进攻树变更
break;
}
}
}
damageDTO.targetDamages = damages.ToArray();
brocast(FightProtocol.DAMAGE_BRO, damageDTO);
}
void damage(DamageDTO value)
{
FightScene._instance.damage(value);
}
