Beispiel #1
0
    public override void start()
    {
        base.start();

        //mCurrSkillId 应该服务器传过来
        int index = Random.Range(0, mRoleData.mSkillList.Count);

        mRoleData.mCurrSkillId = mRoleData.mSkillList[index];
        mSkillInfo             = SkillConfig.singleton.GetSkillInfo(mRoleData.mCurrSkillId);
        if (mSkillInfo == null)
        {
            Debug.Log("skill is null skillId = " + mRoleData.mCurrSkillId);
        }

        mAI = new MonsterAI(this);
        InvokeRepeating("AI", 1.0f, 1.0f);
    }
Beispiel #2
0
    public override void OnLeave(int stateHash)
    {
        if (mMulAtk > 0 && mMulAtk <= mStateHashList.Count)
        {
            // 连击完成
            if (!mRole.mBuffSystem.CanAtk() || stateHash == mStateHashList[mMulAtk + 2])
            {
                mMulAtk = 0;
                mAnimator.SetInteger(mParameter, mMulAtk);
                mChangeState = true;

                for (int i = 0; i < mRole.mRoleData.mMulSkillList.Count; ++i)
                {
                    mSkillInfo = SkillConfig.singleton.GetSkillInfo(mRole.mRoleData.mMulSkillList[i]);
                    if (mSkillInfo != null)
                    {
                        mSkillInfo.mSelfEffect.SetActive(false);
                    }
                }
            }
        }
    }
Beispiel #3
0
    public override void OnAniEnter(int stateHash)
    {
        mCurrSkillID = -1;
        for (int i = 0; i < mRole.mRoleData.mMulSkillList.Count; ++i)
        {
            if (stateHash == mStateHashList[i])
            {
                mCurrSkillID = mRole.mRoleData.mMulSkillList[i];
                break;
            }
        }

        if (mCurrSkillID < 0)
        {
            return;
        }

        base.OnAniEnter(stateHash);
        mSkillInfo = SkillConfig.singleton.GetSkillInfo(mCurrSkillID);
        if (mSkillInfo == null)
        {
            return;
        }

        if (mSkillInfo.mSelfEffect != null)
        {
            mSkillInfo.mSelfEffect.SetActive(false);
            mSkillInfo.mSelfEffect.SetActive(true);
        }

        if (mSkillInfo.mTargetEffect != null)
        {
            mSkillInfo.mTargetEffect.SetActive(false);
            mSkillInfo.mTargetEffect.SetActive(true);
        }

        Skill.ExecuteSkill(mRole, mTargetRole, mSkillInfo);
        mChangeState = false;
    }
Beispiel #4
0
    public override void ExecuteState(StateMachine stateMachine, IState prevState, object param1, object param2)
    {
        base.ExecuteState(stateMachine, prevState, param1, param2);

        mCurrSkillID = (int)param1;
        mChangeState = false;

        mSkillInfo = SkillConfig.singleton.GetSkillInfo(mCurrSkillID);
        if (mSkillInfo == null || mSkillInfo.mTimeline == null)
        {
            return;
        }
        mTargetRole = mRole.mRoleData.GetTargetRole();

        if (Skill.ExecuteSkill(mRole, mTargetRole, mSkillInfo))
        {
            mChangeState = false;
        }
        else
        {
            StateComplete();
            return;
        }

        // 获取timeline
        mDirector = mSkillInfo.mTimeline.GetComponent <PlayableDirector>();
        mDirector.Stop();

        // 取出timeline 左边的名字进行绑定右边的资源
        foreach (PlayableBinding bind in mDirector.playableAsset.outputs)
        {
            if (bind.streamName == "Self")
            {
                AnimationTrack animationTrack = bind.sourceObject as AnimationTrack;
                mDuringTime = (float)animationTrack.duration;
                mBeginTime  = Time.fixedTime;
                mDirector.SetGenericBinding(bind.sourceObject, mAnimator);
            }
            else if (bind.streamName == "Target")
            {
                mDirector.SetGenericBinding(bind.sourceObject, mTargetRole.mAnimator);

                mRole.transform.position = -mRole.transform.forward * mSkillInfo.mAtkDistance + mTargetRole.transform.position;

                mRole.mRoleData.SetForward(mTargetRole.transform.position, mRole.transform.position);
                mRole.transform.rotation = Quaternion.LookRotation(mRole.mRoleData.GetForward());

                mTargetRole.mRoleData.SetForward(mRole.transform.position, mTargetRole.transform.position);
                mTargetRole.transform.rotation = Quaternion.LookRotation(mTargetRole.mRoleData.GetForward());
            }
            else if (bind.streamName == "SelfEffect")
            {
                mDirector.SetGenericBinding(bind.sourceObject, mSkillInfo.mSelfEffect);
            }
            else if (bind.streamName == "TargetEffect")
            {
                mDirector.SetGenericBinding(bind.sourceObject, mSkillInfo.mTargetEffect);
            }
            else if (bind.streamName == "Control Track")
            {
                ControlTrack ct = bind.sourceObject as ControlTrack;
                foreach (var clip in ct.GetClips())
                {
                    ControlPlayableAsset playableAsset = clip.asset as ControlPlayableAsset;
                    mDirector.SetReferenceValue(playableAsset.sourceGameObject.exposedName, mRole.gameObject);
                }
            }
            else if (bind.streamName == "Playable Track")
            {
                PlayableTrack ct = bind.sourceObject as PlayableTrack;
                foreach (TimelineClip clip in ct.GetClips())
                {
                    PlayableAssetEx playableAsset = clip.asset as PlayableAssetEx;
                    if (playableAsset)
                    {
                        // 1.自定义脚本获取绑定 自定义的变量
                        playableAsset.mParamAttackTL = this;
                    }
                }
            }
        }

        mDirector.Play(); // 播放timeline
    }
Beispiel #5
0
    static public bool ExecuteSkill(Role role, Role targetRole, SkillConfig.SkillInfo skillInfo)
    {
        if (targetRole && targetRole.mRoleData.mHp <= 0)
        {
            return(false);
        }

        if (targetRole && skillInfo.mTargetType != SkillConfig.TargetType.None)
        {
            if (Vector3.Distance(role.transform.position, targetRole.transform.position) > skillInfo.mAtkDistance)
            {
                return(false);
            }

            role.mRoleData.SetForward(targetRole.transform.position, role.transform.position);
            role.transform.rotation = Quaternion.LookRotation(role.mRoleData.GetForward());
        }
        else
        {
            role.transform.rotation = Quaternion.LookRotation(role.mRoleData.GetForward());
        }

        foreach (var item in skillInfo.mBuffIdList)
        {
            if (item.mTrigger == IBuff.BuffStage.Start)
            {
                if (item.mBuffAttach == IBuff.BuffAttach.Self)
                {
                    role.mBuffSystem.AddBuff(role, item.mType, item.mTypeId);
                }
                else if (item.mBuffAttach == IBuff.BuffAttach.Target)
                {
                    if (targetRole)
                    {
                        if (skillInfo.mTargetType == SkillConfig.TargetType.None && !targetRole.mBuffSystem.EnableSelect())
                        {
                            continue;
                        }
                        targetRole.mBuffSystem.AddBuff(role, item.mType, item.mTypeId);
                    }
                }
                else if (item.mBuffAttach == IBuff.BuffAttach.Area)
                {
                    AreaBuffTriggerMgr.singleton.AddBuff(role, role.transform.position, item.mTypeId);
                }
            }
        }

        if (skillInfo.mSelfEffect)
        {
            skillInfo.mSelfEffect.transform.position = role.transform.position;
            skillInfo.mSelfEffect.transform.rotation = Quaternion.LookRotation(role.transform.forward);
            EffectColliderList effect = skillInfo.mSelfEffect.GetComponent <EffectColliderList>();
            if (effect)
            {
                effect.SetColliders(role, skillInfo.mSkillTypeId);
            }
        }

        if (skillInfo.mTargetEffect)
        {
            skillInfo.mTargetEffect.transform.position = targetRole.transform.position;
            skillInfo.mTargetEffect.transform.rotation = Quaternion.LookRotation(role.transform.forward);
            EffectColliderList effect = skillInfo.mTargetEffect.GetComponent <EffectColliderList>();
            if (effect)
            {
                effect.SetColliders(role, skillInfo.mSkillTypeId);
            }
        }

        return(true);
    }
Beispiel #6
0
    public void OnBtnSkill(int i)
    {
        if (mMyPlayer == null)
        {
            return;
        }

        if (!mMyPlayer.mBuffSystem.CanAtk())
        {
            return;
        }

        IState.StateType state = IState.StateType.None;
        if (i == 0) // 连击
        {
            mMyPlayer.mRoleData.mCurrSkillId = mMyPlayer.mRoleData.mMulSkillList[0];
            state = IState.StateType.MultlAtk;
        }
        else if (i == 1)
        {
            mMyPlayer.mRoleData.mCurrSkillId = mMyPlayer.mRoleData.mSkillList[0];
            state = IState.StateType.Atk_TL;
        }
        else if (i == 2)
        {
            mMyPlayer.mRoleData.mCurrSkillId = mMyPlayer.mRoleData.mSkillList[1];
            state = IState.StateType.Atk_TL;
        }
        else if (i == 3)
        {
            mMyPlayer.mRoleData.mCurrSkillId = mMyPlayer.mRoleData.mSkillList[2];
            state = IState.StateType.Atk_TL;
        }

        SkillConfig.SkillInfo skillInfo = SkillConfig.singleton.GetSkillInfo(mMyPlayer.mRoleData.mCurrSkillId);
        if (skillInfo != null)
        {
            if (skillInfo.mTargetType == SkillConfig.TargetType.None)
            {
                mMyPlayer.mStateMachine.SwitchState(state, mMyPlayer.mRoleData.mCurrSkillId, null);
            }
            else
            {
                if (skillInfo.mTargetType == SkillConfig.TargetType.Enemy)
                {
                    mMyPlayer.mRoleData.SetTargetRole(RoleMgr.singleton.FindNearMonster(mMyPlayer.transform.position));
                }
                else if (skillInfo.mTargetType == SkillConfig.TargetType.Friends)
                {
                }
                else if (skillInfo.mTargetType == SkillConfig.TargetType.Self)
                {
                }

                if (mMyPlayer.mRoleData.GetTargetRole())
                {
                    float dis = Vector3.Distance(mMyPlayer.mRoleData.GetTargetRole().transform.position, mMyPlayer.transform.position);
                    if (skillInfo.mAtkDistance < dis)
                    {
                        mMyPlayer.mStateMachine.SetNextState(state, mMyPlayer.mRoleData.mCurrSkillId, null, 1);
                        mMyPlayer.mStateMachine.SwitchState(IState.StateType.TrailingObj, 1.0f, skillInfo.mAtkDistance);
                    }
                    else
                    {
                        mMyPlayer.mStateMachine.SwitchState(state, mMyPlayer.mRoleData.mCurrSkillId, null);
                    }
                }
            }
        }
    }
Beispiel #7
0
    public virtual void OnHitEnter(Collider other)
    {
        if (mRole.mRoleData.mHp <= 0)
        {
            return;
        }

        ColliderParam colliderParam = other.gameObject.GetComponent <ColliderParam>();

        if (colliderParam == null)
        {
            return;
        }

        SkillConfig.SkillInfo skillInfo = SkillConfig.singleton.GetSkillInfo(colliderParam.mSkillId);
        if (skillInfo == null)
        {
            return;
        }

        GameObject sendRoleGO;
        Role       sendRole;

        if (colliderParam)
        {
            if (colliderParam.HasCollider(mRole))
            {
                return;
            }

            colliderParam.AddCollider(mRole);

            sendRole   = colliderParam.GetUserRole();
            sendRoleGO = sendRole.gameObject;

            if (sendRole.mRoleData.mGroupType == mRole.mRoleData.mGroupType)
            {
                return;
            }
        }
        else
        {
            return;
        }

        foreach (var item in skillInfo.mBuffIdList)
        {
            if (item.mTrigger == IBuff.BuffStage.Hit)
            {
                if (item.mBuffAttach == IBuff.BuffAttach.Self)
                {
                    sendRole.mBuffSystem.AddBuff(sendRole, item.mType, item.mTypeId);
                }
                else if (item.mBuffAttach == IBuff.BuffAttach.Target)
                {
                    if (skillInfo.mTargetType == SkillConfig.TargetType.None && !mRole.mBuffSystem.EnableSelect())
                    {
                        continue;
                    }
                    mRole.mBuffSystem.AddBuff(sendRole, item.mType, item.mTypeId);
                }
                else if (item.mBuffAttach == IBuff.BuffAttach.Area)
                {
                    AreaBuffTriggerMgr.singleton.AddBuff(sendRole, sendRole.transform.position, item.mTypeId);
                }
            }
        }
    }