示例#1
0
    List <EntityBase> GetSkillDamageList(EntityBase entity, SkillDataGenerate skillData)
    {
        CampComponent        acc = entity.GetComp <CampComponent>();
        SkillStatusComponent ssc = entity.GetComp <SkillStatusComponent>();

        List <EntityBase> result = new List <EntityBase>();
        List <EntityBase> list   = GetEntityList(new string[] { "CollisionComponent", "LifeComponent", "CampComponent" });

        SkillUtils.UpdateArea(skillAreaCache, skillData.m_EffectArea, ssc.skillDir.ToVector(), entity);

        Debug.DrawRay(skillAreaCache.position, skillAreaCache.direction, Color.red, 10);

        for (int i = 0; i < list.Count; i++)
        {
            CollisionComponent bcc    = list[i].GetComp <CollisionComponent>();
            CampComponent      bcampc = list[i].GetComp <CampComponent>();
            LifeComponent      lc     = list[i].GetComp <LifeComponent>();

            //Debug.Log("bcampc.creater " + bcampc.creater + " AreaCollideSucceed -->" + skillAreaCache.AreaCollideSucceed(bcc.area));

            if (acc.creater != bcampc.creater &&
                skillAreaCache.AreaCollideSucceed(bcc.area) &&
                lc.Life > 0)
            {
                result.Add(list[i]);
            }
        }

        return(result);
    }
    void SkillLogic(EntityBase entity, int deltaTime)
    {
        SkillStatusComponent ssc = entity.GetComp <SkillStatusComponent>();
        MoveComponent        mc  = entity.GetComp <MoveComponent>();

        if (ssc.m_isHit)
        {
            SkillDataGenerate skillData = ssc.m_currentSkillData.SkillInfo;

            //TODO 技能代处理


            //获取伤害列表
            List <EntityBase> damageList = GetSkillDamageList(entity, skillData);
            //创建飞行物
            CreateFlyObject(skillData, entity);

            for (int i = 0; i < damageList.Count; i++)
            {
                //伤害处理
                Damage(entity, damageList[i], skillData);

                //击飞处理
                BlowFly(entity, damageList[i], skillData);

                //伤害Buff处理
                DamageBuff(entity, damageList[i], skillData);
            }

            //TODO 恢复
        }
    }
示例#3
0
    public void BlowFly(EntityBase skiller, EntityBase hurter, SkillDataGenerate skillData)
    {
        MoveComponent        amc  = skiller.GetComp <MoveComponent>();
        MoveComponent        bmc  = hurter.GetComp <MoveComponent>();
        SkillStatusComponent assc = skiller.GetComp <SkillStatusComponent>();

        string blowFlyID = skillData.m_BlowFlyID;

        //Debug.Log("BlowFly --> skill id " + skillData.m_key + "  blowfly id " + blowFlyID + " skilltoken pos " + amc.pos.ToVector() + " ");

        if (blowFlyID != "null")
        {
            //Debug.Log("BlowFly " + hurter.ID + " skillID " + skillData.m_key);

            //击飞处理
            if (hurter.GetExistComp <BlowFlyComponent>())
            {
                BlowFlyComponent bfc = hurter.GetComp <BlowFlyComponent>();
                if (!bfc.isBlow)
                {
                    bfc.isBlow    = true;
                    bfc.blowFlyID = blowFlyID;
                    bfc.blowTime  = (int)(bfc.BlowData.m_Time * 1000);
                    bfc.SetBlowFly(amc.pos.ToVector(), bmc.pos.ToVector(), assc.skillDir.ToVector());
                }
            }
        }
    }
    public static Area UpdatSkillArea(Area area, SkillDataGenerate skillData, EntityBase skiller, EntityBase aim = null)
    {
        string effectArea = skillData.m_EffectArea;

        UpdateArea(area, effectArea, skiller, aim);
        return(area);
    }
    void Absorb(int damageNumber, EntityBase character, SkillDataGenerate skillData)
    {
        //if (character.m_Property.m_HpAbsorb > 0)
        //{
        //    int AbsorbNumber = (int)((float)damageNumber * (float)character.m_Property.m_HpAbsorb / 10000f);

        //    RecoverCmd rcmd = HeapObjectPool<RecoverCmd>.GetObject();
        //    rcmd.SetData(time + SyncService.SyncAheadTime, character.m_characterID, character.m_characterID, skillID, null, AbsorbNumber, false);
        //    CommandRouteService.SendSyncCommand(rcmd);
        //}
    }
示例#6
0
    void Recover(EntityBase skiller, EntityBase recover, SkillDataGenerate skillData)
    {
        int revoverNumber = RecoverValueFormula(skillData, skiller, recover);

        if (revoverNumber == 0)
        {
            return;
        }

        SkillUtils.Recover(m_world, skiller, recover, revoverNumber);
    }
示例#7
0
 static int RecoverValueFormula(SkillDataGenerate skillData, EntityBase skiller, EntityBase recover)
 {
     if (skillData.m_ReValuep >= 0)
     {
         return((int)(skillData.m_RecoverValue));
     }
     else
     {
         return((int)(skillData.m_RecoverValue));
     }
 }
    void SkillLogic(EntityBase entity, int deltaTime)
    {
        SkillStatusComponent ssc = entity.GetComp <SkillStatusComponent>();
        MoveComponent        mc  = entity.GetComp <MoveComponent>();

        if (ssc.m_isHit)
        {
            SkillDataGenerate skillData = ssc.m_currentSkillData.m_skillInfo;
            Debug.Log("isHit");
            //获取伤害列表

            //创建飞行物
            CreateFlyObject(skillData, entity);
        }
    }
    void DamageBuff(EntityBase skiller, EntityBase hurter, SkillDataGenerate skillData)
    {
        if (skillData.m_HurtBuff.Length > 0)
        {
            for (int i = 0; i < skillData.m_HurtBuff.Length; i++)
            {
                //TODO 添加BUFF

                //AddBuffCmd acmd = HeapObjectPool<AddBuffCmd>.GetObject();
                //acmd.SetData(time + SyncService.SyncAheadTime, hurter.m_characterID, skiller.m_characterID, data.m_HurtBuff[i], skillID);

                //CommandRouteService.SendSyncCommand(acmd);
            }
        }
    }
示例#10
0
    void CreateFlyObject(SkillDataGenerate skillData, EntityBase skiller)
    {
        CampComponent campComp = skiller.GetComp <CampComponent>();

        //Debug.Log("CreateFlyObject " + skiller.ID + "  " + campComp.creater);

        if (skillData.m_FlyObjectName.Length != 0)
        {
            List <CreatPostionInfo> poss = GetCreatePostionInfos(skillData, skiller, skillData.m_FlyObjectName.Length);

            for (int i = 0; i < poss.Count; i++)
            {
                FlyDataGenerate flyData = DataGenerateManager <FlyDataGenerate> .GetData(skillData.m_FlyObjectName[i]);

                TransfromComponent tc = new TransfromComponent();
                tc.pos = poss[i].m_pos;
                tc.dir = poss[i].m_dir;

                MoveComponent mc = new MoveComponent();
                mc.pos        = poss[i].m_pos;
                mc.dir        = poss[i].m_dir;
                mc.m_velocity = flyData.m_Speed;

                LifeSpanComponent lsc = new LifeSpanComponent();
                lsc.lifeTime = flyData.m_LiveTime;

                AssetComponent ac = new AssetComponent();
                ac.m_assetName = flyData.m_ModelName;

                CampComponent cp = new CampComponent();
                cp.camp    = campComp.camp;
                cp.creater = campComp.creater;

                CollisionComponent cc = new CollisionComponent();
                cc.area.areaType = AreaType.Circle;
                cc.area.radius   = flyData.m_Radius / 1000;

                FlyObjectComponent fc = new FlyObjectComponent();
                fc.createrID   = skiller.ID;
                fc.damage      = skillData.m_FlyDamageValue;
                fc.flyObjectID = skillData.m_FlyObjectName[i];

                string identify = skiller.ID + "FlyObject" + i + poss[i].m_pos;
                m_world.CreateEntity(identify, tc, mc, ac, cp, lsc, cc, fc);
            }
        }
    }
示例#11
0
    void SkillLogic(EntityBase entity, int deltaTime)
    {
        SkillStatusComponent ssc = entity.GetComp <SkillStatusComponent>();
        MoveComponent        mc  = entity.GetComp <MoveComponent>();
        CampComponent        cc  = entity.GetComp <CampComponent>();

        if (ssc.m_isHit)
        {
            SkillDataGenerate skillData = ssc.m_currentSkillData.SkillInfo;

            //技能代处理
            SkillUtils.TokenUseSkill(m_world, entity.ID, skillData.m_SkillAgency, mc.pos.ToVector(), ssc.skillDir.ToVector());

            //获取伤害列表
            List <EntityBase> damageList = GetSkillDamageList(entity, skillData);

            //Debug.Log("damageList " + damageList.Count);

            //创建飞行物
            CreateFlyObject(skillData, entity);

            //自身buff
            SkillUtils.AddBuff(m_world, entity, entity, skillData.m_SelfBuff);

            //Debug.Log("SkillLogic hit " + entity.ID + " createrid " + cc.creater + " damageList.Count " + damageList.Count);

            for (int i = 0; i < damageList.Count; i++)
            {
                //伤害处理
                Damage(entity, damageList[i], skillData);

                //击飞处理
                BlowFly(entity, damageList[i], skillData);

                //伤害Buff处理
                DamageBuff(entity, damageList[i], skillData);
            }

            //TODO 恢复
            Recover(entity, entity, skillData);
        }
    }
示例#12
0
    ////判断CD结束
    //public bool CDFinished()
    //{
    //    if (GetCDResidueTime() <= 0)
    //    {
    //        return true;
    //    }
    //    else
    //    {

    //        return false;
    //    }
    //}

    ///// <summary>
    ///// 获取CD剩余时间
    ///// </summary>
    //public float GetCDResidueTime()
    //{
    //    if (m_lastExecuteTime < 0)
    //    {
    //        return 0;
    //    }

    //    float result = m_CDSpace - (SyncService.CurrentServiceTime - m_lastExecuteTime);

    //    if (result < 0)
    //    {
    //        result = 0;
    //    }

    //    return result;
    //}

    #endregion

    public void UpdateInfo()
    {
        if (m_skillID != "" && m_skillID != "null")
        {
            m_skillInfo = DataGenerateManager <SkillDataGenerate> .GetData(m_skillID);

            m_beforeInfo = DataGenerateManager <SkillStatusDataGenerate> .GetData(m_skillInfo.m_BeforeStatus);

            m_currentInfo = DataGenerateManager <SkillStatusDataGenerate> .GetData(m_skillInfo.m_CurrentStatus);

            m_laterInfo = DataGenerateManager <SkillStatusDataGenerate> .GetData(m_skillInfo.m_LaterStatus);

            m_beforeTime = m_beforeInfo.m_Time;

            m_hitTime     = m_beforeTime + m_skillInfo.m_HitTime;
            m_currentTime = m_beforeTime + m_currentInfo.m_Time;
            m_laterTime   = m_currentTime + m_laterInfo.m_Time;
            m_CDSpace     = m_skillInfo.m_CD;
        }
    }
    public void BlowFly(EntityBase skiller, EntityBase hurter, SkillDataGenerate skillData)
    {
        MoveComponent   amc = skiller.GetComp <MoveComponent>();
        MoveComponent   bmc = hurter.GetComp <MoveComponent>();
        PlayerComponent apc = skiller.GetComp <PlayerComponent>();

        string blowFlyID = skillData.m_BlowFlyID;

        if (blowFlyID != "null")
        {
            //击飞处理
            if (hurter.GetExistComp <BlowFlyComponent>())
            {
                BlowFlyComponent bfc = hurter.GetComp <BlowFlyComponent>();
                bfc.blowFlyID = blowFlyID;
                bfc.blowTime  = (int)(bfc.BlowData.m_Time * 1000);
                bfc.SetBlowFly(amc.pos.ToVector(), bmc.pos.ToVector(), apc.faceDir.ToVector());
            }
        }
    }
    List <EntityBase> GetSkillDamageList(EntityBase entity, SkillDataGenerate skillData)
    {
        List <EntityBase> result = new List <EntityBase>();
        List <EntityBase> list   = GetEntityList(new string[] { "CollisionComponent", "LifeComponent", "CampComponent" });

        UpdateArea(skillAreaCache, skillData.m_EffectArea, entity);

        for (int i = 0; i < list.Count; i++)
        {
            CollisionComponent bcc = list[i].GetComp <CollisionComponent>();
            CampComponent      cc  = list[i].GetComp <CampComponent>();

            if (skillAreaCache.AreaCollideSucceed(bcc.area) &&
                entity.ID != list[i].ID)
            {
                result.Add(list[i]);
            }
        }

        return(result);
    }
    void CreateFlyObject(SkillDataGenerate skillData, EntityBase skiller)
    {
        CampComponent campComp = skiller.GetComp <CampComponent>();

        if (skillData.m_FlyObjectName.Length != 0)
        {
            List <CreatPostionInfo> poss = GetCreatePostionInfos(skillData, skiller, skillData.m_FlyObjectName.Length);

            for (int i = 0; i < poss.Count; i++)
            {
                FlyDataGenerate flyData = DataGenerateManager <FlyDataGenerate> .GetData(skillData.m_FlyObjectName[i]);

                MoveComponent mc = new MoveComponent();
                mc.pos.FromVector(poss[i].m_pos);
                mc.dir.FromVector(poss[i].m_dir);
                mc.m_velocity = (int)(flyData.m_Speed * 1000);

                LifeSpanComponent lsc = new LifeSpanComponent();
                lsc.lifeTime = (int)(flyData.m_LiveTime * 1000);

                AssetComponent ac = new AssetComponent();
                ac.m_assetName = flyData.m_ModelName;

                CampComponent cp = new CampComponent();
                cp.camp = campComp.camp;

                CollisionComponent cc = new CollisionComponent();
                cc.area.areaType = AreaType.Circle;
                cc.area.radius   = flyData.m_Radius;

                FlyObjectComponent fc = new FlyObjectComponent();
                fc.createrID = skiller.ID;
                fc.damage    = skillData.m_DamageValue;

                m_world.CreateEntity(mc, ac, cp, lsc, cc, fc);

                Debug.Log(poss[i].m_pos.ToString());
            }
        }
    }
示例#16
0
    public void Damage(EntityBase skiller, EntityBase hurter, SkillDataGenerate skillData)
    {
        bool isCrit       = false;
        bool isDisrupting = false;
        int  damageNumber = DamageValueFormula(skillData, skiller, hurter, out isCrit, out isDisrupting);

        if (damageNumber == 0)
        {
            return;
        }

        CampComponent acc = skiller.GetComp <CampComponent>();
        CampComponent bcc = hurter.GetComp <CampComponent>();

        //Debug.Log("Damage == " + damageNumber + " hurter  " + hurter.ID + " acc " + acc.creater + " bcc " + bcc.creater + " frame " + m_world.FrameCount);

        //TODO 吸血
        Absorb(damageNumber, skiller, skillData);

        //伤害处理
        SkillUtils.Damage(m_world, skiller, hurter, damageNumber);
    }
    public void Damage(EntityBase skiller, EntityBase hurter, SkillDataGenerate skillData)
    {
        bool isCrit       = false;
        bool isDisrupting = false;
        int  damageNumber = DamageValueFormula(skillData, skiller, hurter, out isCrit, out isDisrupting);

        if (damageNumber == 0)
        {
            return;
        }

        Debug.Log("Damage!");

        //TODO 吸血
        Absorb(damageNumber, skiller, skillData);

        //伤害处理
        LifeComponent lc = hurter.GetComp <LifeComponent>();

        lc.life -= damageNumber;

        ECSEvent.DispatchEvent(GameUtils.GetEventKey(hurter.ID, CharacterEventType.Damage), hurter);
    }
 int DamageValueFormula(SkillDataGenerate skillData, EntityBase attacker, EntityBase hurter, out bool isCrit, out bool isDisrupting)
 {
     isCrit       = false;
     isDisrupting = false;
     return(skillData.m_DamageValue);
 }
示例#19
0
    List <CreatPostionInfo> GetCreatePostionInfos(SkillDataGenerate skillData, EntityBase skiller, int Length)
    {
        MoveComponent        mc  = skiller.GetComp <MoveComponent>();
        SkillStatusComponent ssc = skiller.GetComp <SkillStatusComponent>();

        List <CreatPostionInfo> result = new List <CreatPostionInfo>();

        //result.Clear();

        if (Length == 0)
        {
            return(result);
        }

        HardPointEnum l_FXCreatPoint = skillData.m_FlyCreatPoint;

        SyncVector3 forward = new SyncVector3().FromVector(ssc.skillDir.ToVector().normalized);
        SyncVector3 dir     = forward;
        SyncVector3 pos     = mc.pos;

        SyncVector3 leftBorder    = new SyncVector3();
        SyncVector3 leftDir       = new SyncVector3();
        SyncVector3 leftPos       = new SyncVector3();
        float       sectorStep    = 0;
        float       rectangleStep = 0;

        AreaDataGenerate area = DataGenerateManager <AreaDataGenerate> .GetData(skillData.m_FlyObjectArea);

        switch (area.m_SkewDirection)
        {
        case DirectionEnum.Forward: break;

        case DirectionEnum.Backward: forward *= -1; break;
            //case DirectionEnum.Close: forward = (emc.pos - mc.pos); break;
            //case DirectionEnum.Leave: forward = (mc.pos - emc.pos); break;
        }

        switch (area.m_Shape)
        {
        case AreaType.Circle:
            leftBorder = forward.RotateInXZ(360 * 0.5f);
            sectorStep = 360 / (Length + 1);
            break;

        case AreaType.Sector:
            leftBorder = forward.RotateInXZ(area.m_Angle * 0.5f);
            sectorStep = area.m_Angle / (Length + 1);
            pos        = pos + forward * area.m_SkewDistance;
            break;

        case AreaType.Rectangle:
            leftDir       = forward.RotateInXZ(90);
            leftPos       = pos + leftDir * area.m_Width * 0.5f;
            rectangleStep = area.m_Width / (Length + 1);

            break;
        }
        for (int i = 0; i < Length; i++)
        {
            switch (area.m_Shape)
            {
            case AreaType.Circle:
            case AreaType.Sector:
                dir = leftBorder.RotateInXZ2((i + 1) * sectorStep);

                break;

            case AreaType.Rectangle:
                pos = leftPos - leftDir * rectangleStep * (i + 1);
                break;
            }
            CreatPostionInfo cpi = new CreatPostionInfo();
            pos.y = 0;
            dir.y = 0;

            cpi.m_pos = pos;
            cpi.m_dir = dir;
            result.Add(cpi);

            //CreatPostionInfo cpi = new CreatPostionInfo();
            //cpi.m_pos = mc.pos.DeepCopy();
            //cpi.m_dir.FromVector( ssc.skillDir.DeepCopy().ToVector().normalized);

            //result.Add(cpi);
        }

        return(result);
    }
示例#20
0
 void DamageBuff(EntityBase skiller, EntityBase hurter, SkillDataGenerate skillData)
 {
     SkillUtils.AddBuff(m_world, skiller, hurter, skillData.m_HurtBuff);
 }
    List <CreatPostionInfo> GetCreatePostionInfos(SkillDataGenerate skillData, EntityBase skiller, int Length)
    {
        MoveComponent   mc = skiller.GetComp <MoveComponent>();
        PlayerComponent pc = skiller.GetComp <PlayerComponent>();

        List <CreatPostionInfo> result = new List <CreatPostionInfo>();

        result.Clear();

        if (Length == 0)
        {
            return(result);
        }

        HardPointEnum l_FXCreatPoint = skillData.m_FlyCreatPoint;

        Vector3 forward = pc.faceDir.ToVector();
        Vector3 dir     = forward;
        Vector3 pos     = Vector3.zero;

        //获取散射区域
        Area skillArea = UpdatSkillArea(areaCache, skillData, skiller, null);

        //TODO 寻敌方法
        //CharacterBase enemy = GetRecentlyEnemy(skillArea, skiller.m_camp, false);
        //CharacterBase enemy = null;
        MoveComponent emc = null;

        if (l_FXCreatPoint != HardPointEnum.enemy)
        {
            pos = mc.pos.ToVector();
        }
        else
        {
            if (emc == null)
            {
                return(result);
            }
            else
            {
                pos = emc.pos.ToVector();
            }
        }

        Vector3 leftBorder    = Vector3.zero;
        Vector3 leftDir       = Vector3.zero;
        Vector3 leftPos       = Vector3.zero;
        float   sectorStep    = 0;
        float   rectangleStep = 0;

        AreaDataGenerate area = DataGenerateManager <AreaDataGenerate> .GetData(skillData.m_FlyObjectArea);

        switch (area.m_SkewDirection)
        {
        case DirectionEnum.Forward: break;

        case DirectionEnum.Backward: forward *= -1; break;

        case DirectionEnum.Close: forward = (emc.pos.ToVector() - mc.pos.ToVector()).normalized; break;

        case DirectionEnum.Leave: forward = (mc.pos.ToVector() - emc.pos.ToVector()).normalized; break;
        }

        switch (area.m_Shape)
        {
        case AreaType.Circle:
            leftBorder = forward.Vector3RotateInXZ(360 * 0.5f);
            sectorStep = 360 / (Length + 1);
            break;

        case AreaType.Sector:
            leftBorder = forward.Vector3RotateInXZ(area.m_Angle * 0.5f);
            sectorStep = area.m_Angle / (Length + 1);
            break;

        case AreaType.Rectangle:
            leftDir       = forward.Vector3RotateInXZ(90);
            leftPos       = pos + leftDir * area.m_Width * 0.5f;
            rectangleStep = area.m_Width / (Length + 1);
            break;
        }

        for (int i = 0; i < Length; i++)
        {
            switch (area.m_Shape)
            {
            case AreaType.Circle:
            case AreaType.Sector:
                dir = leftBorder.Vector3RotateInXZ2((i + 1) * sectorStep);
                pos = pos + forward * area.m_SkewDistance;
                break;

            case AreaType.Rectangle:
                pos = leftPos - leftDir * rectangleStep * (i + 1);
                break;
            }


            CreatPostionInfo cpi = new CreatPostionInfo();
            cpi.m_pos = pos;
            cpi.m_dir = dir;

            result.Add(cpi);
        }

        return(result);
    }