Beispiel #1
0
    // Start
    void Start()
    {
        inst = GetComponent<SkillInstance>();
        caster = inst.caster;
        speed = caster.baseMoveSpeed * moveSpeedMultiplier;

        //forwardVector = caster.charGraphics.forward * (caster.baseMoveSpeed * moveSpeedMultiplier);
        //caster.hasControlOverMovement = false;
    }
    public SkillInstance GetSkillInstanceByName(string name)
    {
        SkillInstance ret = null;

        if (name.Equals ("Base_Kick"))
        {
            ret = new SkillInstance ();
            ret.Id_ = ++m_Id;
            ret.Name_ = name;
            ret.ColliderName_ = "NormalAttackCollider";
            ret.Fx_ = null;
            ret.Sound_ = null;
            ret.TrackClass_ = "TrackMovementKickBase";
        }

        return ret;
    }
Beispiel #3
0
 public void SkillButtonClicked(SkillInstance skill)
 {
     skill.OnAcivate(PlayerObject);
 }
Beispiel #4
0
 Vector2 AddSkill(SkillInstance skill, Vector2 offset)
 {
     return AddSkill(skill.BaseSkill, skill.Level, offset, skill);
 }
    // SpawnSkillPrefab
    public void SpawnSkillPrefab(
		GameObject prefabSpawned,
		Vector3 position,
		Quaternion rotation,
		out GameObject clone,
		out SkillInstance inst
	)
    {
        clone = (GameObject)Object.Instantiate(prefabSpawned, position, rotation);
        clone.transform.parent = Entity.skillInstancesRoot;
        clone.layer = gameObject.layer;

        inst = clone.GetComponent<SkillInstance>();
        inst.caster = caster;
        inst.skill = skill;
        inst.skillStage = skillStage;
    }
Beispiel #6
0
 public virtual bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
 {
     return false;
 }
    // Use this for initialization
    void Awake()
    {
        base.Awake ();

        m_PlayerState = PlayerState.PlayerStateIdle;

        m_CharacterController = GetComponent<CharacterController> ();

        m_CurrentSkillInstance = null;
        m_SkillTriggerObjectList = new List<GameObject> ();

        m_Animator = GetComponent<AnimatorAlpha> ();

        if (m_CharacterController) {}
    }
Beispiel #8
0
 public void SkillButtonClicked(SkillInstance skill)
 {
     skill.OnAcivate(PlayerObject);
 }
 private int TryGetTimeFromConfig(SkillInstance instance)
 {
     return(SkillParamUtility.RefixNonStringVariable <int>(m_Type, instance));
 }
Beispiel #10
0
        public override bool Cast(Entity target, string skillKey, bool autocast = false)
        {
            string tryAlias = Engine.GetSkillManager().GetKeyFromAlias(skillKey);

            if (tryAlias == null)
            {
                tryAlias = skillKey;
            }

            SkillInstance skill = Skills.ContainsKey(tryAlias) ? Skills[tryAlias] : null;

            if (skill == null)
            {
                Engine.Log().Log($"[{Name}] You don't have that skill({tryAlias}).");
                //log that you don't have that skill
                return(false);
            }
            if (skill.CooldownFinishTime != 0)
            {
                long seconds = (skill.CooldownFinishTime - Engine.GetTimer().GetNow()) / GameConstants.TickTime;
                Engine.Log().Log($"[{Name}] {skill.Skill.Name} is on cooldown for {seconds} s.");
                return(false);
            }

            if (!Free)
            {
                Engine.Log().Log($"[{Name}] You are busy.");
                return(false);
            }

            if (!ResourceMap.ContainsKey(skill.Values().Cost.Resource.Key))
            {
                Engine.Log().Log($"[{Name}] You don't have \"{skill.Values().Cost.Resource.Name}\".");
                return(false);
            }
            ResourceInstance res    = ResourceMap[skill.Values().Cost.Resource.Key];
            double           amount = Sanitizer.ReplacePropeties(skill.Values().Cost.Amount, this).Resolve().Value.ToDouble();

            if (!res.CanCast(amount))
            {
                Engine.Log().Log($"[{Name}] Not enough {skill.Values().Cost.Resource.Name} for {skill.Skill.Name}.");
                return(false);
            }

            res.Cast(amount);

            Free = false;

            CurrentlyCasting = new SkillCastData(skill, target, this, Engine.GetTimer().GetNow());
            long time = CurrentlyCasting.CastFinishTime - Engine.GetTimer().GetNow();

            if (time >= GameConstants.TickTime * 3)
            {
                string type         = skill.Skill.Type == SkillType.Cast ? "casting" : "channeling";
                string castedFinish = Key.Equals(CurrentlyCasting.Target.Key)
                    ? ""
                    : $" on  {CurrentlyCasting.Target.Name}";
                Engine.Log()
                .Log(
                    $"[{Name}] Started {type} {CurrentlyCasting.Skill.Skill.Name}{castedFinish}.");
            }
            return(true);
        }
Beispiel #11
0
    override public void Update(IM.Number fDeltaTime)
    {
        base.Update(fDeltaTime);

        if (m_player.CanRebound(m_ball) && (timerRebound == null || timerRebound.stop))
        {
            //Debug.Log("Rebound info of " + m_player.m_name);
            ReboundAttrConfig.ReboundAttr attr = GameSystem.Instance.ReboundAttrConfigData.GetReboundAttr(m_player.m_position);
            if (attr == null)
            {
                Debug.LogError("Rebound height config error.");
            }

            ShootSolution.SShootCurve curve = m_ball.CompleteLastCurve();
            IM.Number ballHeight            = m_ball.position.y;
            ballHeight *= (IM.Number.one - m_system.AI.devBallHeight);
            if (ballHeight >= attr.minHeight)
            {
                //Debug.Log("Rebound max height: " + attr.maxHeight +" Ball height: " + ballHeight + " Rebound height scale: " + attr.reboundHeightScale + " Ball height scale: " + attr.ballHeightScale);
                IM.Number npcReboundBallHeight = AIUtils.GetNPCReboundBallHeight(attr.maxHeight, ballHeight, attr.reboundHeightScale, attr.ballHeightScale);
                //Debug.Log("NPC rebound ball height: " + npcReboundBallHeight);
                IM.Number time1, time2;
                curve.GetTimeByHeight(npcReboundBallHeight, out time1, out time2);
                IM.Number ballFlyTime = time2;
                //Debug.Log("Ball fly time: " + ballFlyTime);
                if (ballFlyTime < -new IM.Number(0, 1))
                {
                    Debug.LogError("Ball fly time error.");
                }

                SkillInstance basicRebound  = m_player.m_skillSystem.GetBasicSkillsByCommand(Command.Rebound)[0];
                string        basicActionId = basicRebound.skill.actions[0].action_id;
                IM.Number     frameRate     = m_player.animMgr.GetFrameRate(basicActionId);
                Dictionary <string, PlayerAnimAttribute.AnimAttr> rebounds = m_player.m_animAttributes.m_rebound;
                int       reboundKey        = rebounds[m_player.animMgr.GetOriginName(basicActionId)].GetKeyFrame("OnRebound").frame;
                IM.Number reboundActionTime = reboundKey / frameRate;

                IM.Number reboundDelayTime = ballFlyTime - m_ball.m_fTime - reboundActionTime;
                //Debug.Log("Rebound delay time: " + reboundDelayTime);
                if (reboundDelayTime < IM.Number.zero)
                {
                    reboundDelayTime = IM.Number.zero;
                }
                timerRebound.SetTimer(reboundDelayTime);
                timerRebound.stop = false;

                return;
            }
        }

        if (m_ball.m_owner != null)
        {
            m_system.SetTransaction(AIState.Type.eIdle);
        }
        else
        {
            IM.Vector3 vMoveTarget = m_ball.position;
            if (m_ball.m_ballState == BallState.eUseBall_Shoot)
            {
                vMoveTarget = m_match.mCurScene.mBasket.m_vShootTarget;
            }
            vMoveTarget.y       = IM.Number.zero;
            m_moveTarget        = vMoveTarget;
            m_player.m_moveType = fogs.proto.msg.MoveType.eMT_Rush;

            if (m_ball.m_ballState == BallState.eLoseBall &&
                (m_player.m_position == PositionType.PT_PG || m_player.m_position == PositionType.PT_SG))
            {
                IM.Vector3 ballPos    = m_ball.position;
                IM.Number  distToBall = GameUtils.HorizonalDistance(ballPos, m_player.position);
                if (distToBall < PlayerState_BodyThrowCatch.GetMaxDistance(m_player) && ballPos.y <= IM.Number.one)
                {
                    m_system.SetTransaction(AIState.Type.eBodyThrowCatch);
                }
            }
        }

        if (timerRebound != null)
        {
            timerRebound.Update(fDeltaTime);
        }
    }
        private bool Prepare(GfxSkillSenderInfo senderObj, SkillInstance instance, GameObject obj, GameObject targetObj)
        {
            if (!m_TargetChecked)
            {
                m_TargetChecked = true;
                m_RealDuration  = m_Duration;
                m_RealVelocity  = m_Velocity;
                if (m_RealDuration <= 0)
                {
                    m_RealDuration += instance.CurSectionDuration;
                }
                if (m_RealDuration <= 0)
                {
                    LogSystem.Warn("charge duration is 0, skill id:{0} dsl skill id:{1}", senderObj.SkillId, instance.DslSkillId);
                    return(false);
                }
                m_StartPos = obj.transform.position;
                Vector3 targetPos = Vector3.zero;
                if (null != targetObj)
                {
                    targetPos = targetObj.transform.position;
                }
                if (!m_IsFreeMove && targetPos.sqrMagnitude > Geometry.c_FloatPrecision)
                {
                    float degree = Geometry.GetYRadian(new ScriptRuntime.Vector2(m_StartPos.x, m_StartPos.z), new ScriptRuntime.Vector2(targetPos.x, targetPos.z));
                    ScriptRuntime.Vector2 newPos;
                    if (m_RandRelativeToSelf)
                    {
                        int v = Helper.Random.Next();
                        if (v < 50)
                        {
                            newPos    = new ScriptRuntime.Vector2(m_StartPos.x, m_StartPos.z) + Geometry.GetRotate(new ScriptRuntime.Vector2(m_Offset.x, m_Offset.z), degree);
                            targetPos = new Vector3(newPos.X, m_StartPos.y + m_Offset.y, newPos.Y);
                        }
                        else
                        {
                            newPos    = new ScriptRuntime.Vector2(m_StartPos.x, m_StartPos.z) + Geometry.GetRotate(new ScriptRuntime.Vector2(-m_Offset.x, m_Offset.z), degree);
                            targetPos = new Vector3(newPos.X, m_StartPos.y + m_Offset.y, newPos.Y);
                        }
                    }
                    else if (m_RelativeToSelf)
                    {
                        newPos    = new ScriptRuntime.Vector2(m_StartPos.x, m_StartPos.z) + Geometry.GetRotate(new ScriptRuntime.Vector2(m_Offset.x, m_Offset.z), degree);
                        targetPos = new Vector3(newPos.X, m_StartPos.y + m_Offset.y, newPos.Y);
                    }
                    else if (m_RandRelativeToTarget)
                    {
                        int v = Helper.Random.Next();
                        if (v < 50)
                        {
                            newPos    = new ScriptRuntime.Vector2(targetPos.x, targetPos.z) + Geometry.GetRotate(new ScriptRuntime.Vector2(m_Offset.x, m_Offset.z), degree);
                            targetPos = new Vector3(newPos.X, targetPos.y + m_Offset.y, newPos.Y);
                        }
                        else
                        {
                            newPos    = new ScriptRuntime.Vector2(targetPos.x, targetPos.z) + Geometry.GetRotate(new ScriptRuntime.Vector2(-m_Offset.x, m_Offset.z), degree);
                            targetPos = new Vector3(newPos.X, targetPos.y + m_Offset.y, newPos.Y);
                        }
                    }
                    else
                    {
                        newPos    = new ScriptRuntime.Vector2(targetPos.x, targetPos.z) + Geometry.GetRotate(new ScriptRuntime.Vector2(m_Offset.x, m_Offset.z), degree);
                        targetPos = new Vector3(newPos.X, targetPos.y + m_Offset.y, newPos.Y);
                    }

                    m_Forward   = targetPos - m_StartPos;
                    m_Forward.y = 0;
                    m_Forward.Normalize();

                    if (m_StopAtTarget == (int)StopAtTargetType.AdjustVelocity)
                    {
                        m_RealVelocity = (long)(1000.0f * (targetPos - m_StartPos).magnitude / m_RealDuration);
                        m_TargetPos    = targetPos;
                    }
                    else if (m_StopAtTarget == (int)StopAtTargetType.AdjustTime)
                    {
                        m_RealDuration = (long)(1000.0f * (targetPos - m_StartPos).magnitude / m_RealVelocity);
                        m_TargetPos    = targetPos;
                    }
                    else
                    {
                        m_TargetPos = m_StartPos + m_Forward * m_RealVelocity * m_RealDuration / 1000.0f;
                    }
                }
                else
                {
                    if (m_RandRelativeToSelf)
                    {
                        int v = Helper.Random.Next();
                        if (v < 50)
                        {
                            m_TargetPos = obj.transform.TransformPoint(m_Offset.x, 0, m_Offset.z);
                        }
                        else
                        {
                            m_TargetPos = obj.transform.TransformPoint(-m_Offset.x, 0, m_Offset.z);
                        }
                    }
                    else if (m_RelativeToSelf)
                    {
                        m_TargetPos = obj.transform.TransformPoint(m_Offset.x, 0, m_Offset.z);
                    }
                    else
                    {
                        m_TargetPos = obj.transform.TransformPoint(0, 0, m_RealVelocity * m_RealDuration / 1000.0f);
                    }
                    m_Forward = obj.transform.forward;
                }
            }
            return(true);
        }
        public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
        {
            GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;

            if (null == senderObj)
            {
                return(false);
            }
            GameObject obj = senderObj.GfxObj;

            if (null == obj)
            {
                return(false);
            }
            GameObject targetObj = senderObj.TargetGfxObj;

            if (null != senderObj.TrackEffectObj)
            {
                obj       = senderObj.TrackEffectObj;
                targetObj = senderObj.GfxObj;
            }
            if (curSectionTime < StartTime)
            {
                return(true);
            }
            else if (curSectionTime <= StartTime + m_RealDuration)
            {
                if (!Prepare(senderObj, instance, obj, targetObj))
                {
                    return(false);
                }
                if (null != m_Curve && m_Curve.keys.Length >= 2)
                {
                    float   time      = Mathf.Clamp01((curSectionTime - StartTime) * 1.0f / m_RealDuration);
                    float   val       = m_Curve.Evaluate(time);
                    Vector3 targetPos = Vector3.SlerpUnclamped(new Vector3(m_StartPos.x, m_StartPos.y, m_StartPos.z), new Vector3(m_TargetPos.x, m_StartPos.y, m_StartPos.z), val);
                    if (!m_IsFreeMove)
                    {
                        if (!TriggerUtil.RaycastNavmesh(obj.transform.position, targetPos))
                        {
                            TriggerUtil.MoveObjTo(obj, targetPos);
                        }
                        else
                        {
                            targetPos = TriggerUtil.GetGroundPos(targetPos);
                            TriggerUtil.MoveObjTo(obj, targetPos);
                        }
                    }
                    else
                    {
                        TriggerUtil.MoveObjTo(obj, targetPos);
                    }
                }
                else
                {
                    float   dist      = TriggerUtil.ConvertToSecond(delta) * m_RealVelocity;
                    Vector3 targetPos = obj.transform.position + m_Forward * dist;
                    if (!m_IsFreeMove)
                    {
                        if (!TriggerUtil.RaycastNavmesh(obj.transform.position, targetPos))
                        {
                            TriggerUtil.MoveObjTo(obj, targetPos);
                        }
                        else
                        {
                            targetPos = TriggerUtil.GetGroundPos(targetPos);
                            TriggerUtil.MoveObjTo(obj, targetPos);
                        }
                    }
                    else
                    {
                        TriggerUtil.MoveObjTo(obj, targetPos);
                    }
                }
                return(true);
            }
            else
            {
                Vector3 diff = m_TargetPos - obj.transform.position;
                if (diff.sqrMagnitude > 0.01f)
                {
                    Vector3 targetPos = m_TargetPos;
                    if (!m_IsFreeMove)
                    {
                        if (!TriggerUtil.RaycastNavmesh(obj.transform.position, targetPos))
                        {
                            TriggerUtil.MoveObjTo(obj, targetPos);
                        }
                        else
                        {
                            targetPos = TriggerUtil.GetGroundPos(targetPos);
                            TriggerUtil.MoveObjTo(obj, targetPos);
                        }
                    }
                    else
                    {
                        TriggerUtil.MoveObjTo(obj, targetPos);
                    }
                }
                return(false);
            }
        }
        public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
        {
            GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;

            if (null == senderObj)
            {
                return(false);
            }
            GameObject obj = senderObj.GfxObj;

            if (null == obj)
            {
                return(false);
            }
            if (null != senderObj.TrackEffectObj)
            {
                obj = senderObj.TrackEffectObj;
            }
            if (curSectionTime < StartTime)
            {
                return(true);
            }
            if (!m_IsCurveMoving)
            {
                return(false);
            }
            if (!m_IsInited)
            {
                Init(senderObj, instance);
            }
            if (m_SectionListCopy.Count == 0)
            {
                m_IsCurveMoving = false;
                return(false);
            }
            m_Now += TriggerUtil.ConvertToSecond((long)(instance.OriginalDelta * instance.MoveScale));
            MoveSectionInfo cur_section = m_SectionListCopy[0];

            if (m_Now - cur_section.startTime > cur_section.moveTime)
            {
                float end_time  = cur_section.startTime + cur_section.moveTime;
                float used_time = end_time - cur_section.lastUpdateTime;
                cur_section.curSpeedVect = Move(obj, cur_section.curSpeedVect, cur_section.accelVect, used_time);
                m_SectionListCopy.RemoveAt(0);
                if (m_SectionListCopy.Count > 0)
                {
                    cur_section                = m_SectionListCopy[0];
                    cur_section.startTime      = end_time;
                    cur_section.lastUpdateTime = end_time;
                    cur_section.curSpeedVect   = cur_section.speedVect;
                }
                else
                {
                    m_IsCurveMoving = false;
                }
            }
            else
            {
                cur_section.curSpeedVect   = Move(obj, cur_section.curSpeedVect, cur_section.accelVect, m_Now - cur_section.lastUpdateTime);
                cur_section.lastUpdateTime = m_Now;
            }
            return(true);
        }
Beispiel #15
0
    public SkillInstance NewSkillINstance(int skillBaseId)
    {
        SkillInstance skillInstance = new SkillInstance(mDic_BaseSkillInstance[skillBaseId]);

        return(skillInstance);
    }
Beispiel #16
0
 public void RemoveInstance(SkillInstance ins)
 {
     mSkillIns.Remove(ins);
 }
        public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
        {
            GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;

            if (null == senderObj)
            {
                return(false);
            }
            GameObject obj = senderObj.GfxObj;

            if (null == obj)
            {
                return(false);
            }
            if (curSectionTime < StartTime)
            {
                return(true);
            }
            if (0 == m_Type.CompareTo("anim"))
            {
                Animator animator = obj.GetComponentInChildren <Animator>();
                if (null != animator)
                {
                    float length     = 0;
                    int   layerCount = animator.layerCount;
                    for (int i = 0; i < layerCount; ++i)
                    {
                        AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(i);
                        //LogSystem.Info("adjustsectionduration anim, skill id:{0} dsl skill id:{1}, length:{2} normalized time:{3} loop:{4} layer:{5} layer count:{6}", senderObj.SkillId, instance.DslSkillId, stateInfo.length, stateInfo.normalizedTime, stateInfo.loop, i, layerCount);

                        if (length < stateInfo.length && !float.IsInfinity(stateInfo.length))
                        {
                            length = stateInfo.length;
                        }
                    }
                    if (length > Geometry.c_FloatPrecision)
                    {
                        long newDuration = (long)(length * 1000) + m_DeltaTime;
                        if (instance.CurSectionDuration < newDuration)
                        {
                            instance.SetCurSectionDuration(newDuration);
                        }
                    }
                    else
                    {
                        //LogSystem.Warn("adjustsectionduration anim length is 0, skill id:{0} dsl skill id:{1}", senderObj.SkillId, instance.DslSkillId);
                        return(true);
                    }
                }
            }
            else if (0 == m_Type.CompareTo("impact"))
            {
                int time = EntityController.Instance.GetImpactDuration(senderObj.ActorId, senderObj.SkillId, senderObj.Seq);
                if (time > 0)
                {
                    long newDuration = (long)time + m_DeltaTime;
                    if (instance.CurSectionDuration < newDuration)
                    {
                        instance.SetCurSectionDuration(newDuration);
                    }
                }
                else
                {
                    LogSystem.Warn("adjustsectionduration impact duration is 0, skill id:{0} dsl skill id:{1}", senderObj.SkillId, instance.DslSkillId);
                }
            }
            else
            {
                bool     handled  = false;
                Animator animator = obj.GetComponentInChildren <Animator>();
                if (null != animator && null != animator.runtimeAnimatorController)
                {
                    float length = 0;
                    var   clips  = animator.runtimeAnimatorController.animationClips;
                    for (int i = 0; i < clips.Length; ++i)
                    {
                        if (clips[i].name == m_Type)
                        {
                            length  = clips[i].length;
                            handled = true;
                            break;
                        }
                    }
                    if (length > Geometry.c_FloatPrecision)
                    {
                        long newDuration = (long)(length * 1000) + m_DeltaTime;
                        if (instance.CurSectionDuration < newDuration)
                        {
                            instance.SetCurSectionDuration(newDuration);
                        }
                    }
                    else
                    {
                        LogSystem.Warn("adjustsectionduration variable time is 0, skill id:{0} dsl skill id:{1} type:{2}", senderObj.SkillId, instance.DslSkillId, m_Type);
                    }
                }
                if (!handled)
                {
                    int time = TryGetTimeFromConfig(instance);
                    if (time > 0)
                    {
                        long newDuration = (long)time + m_DeltaTime;
                        if (instance.CurSectionDuration < newDuration)
                        {
                            instance.SetCurSectionDuration(newDuration);
                        }
                    }
                    else
                    {
                        LogSystem.Warn("adjustsectionduration variable time is 0, skill id:{0} dsl skill id:{1} type:{2}", senderObj.SkillId, instance.DslSkillId, m_Type);
                    }
                }
            }
            return(false);
        }
        private void Load(ScriptableDataFile dataFile)
        {
            lock (m_Lock)
            {
                foreach (ScriptableDataInfo info in dataFile.ScriptableDatas)
                {
                    if (info.GetId() == "skill")
                    {
                        FunctionData funcData = info.First;
                        if (null != funcData)
                        {
                            CallData callData = funcData.Call;
                            if (null != callData && callData.HaveParam())
                            {
                                int id = int.Parse(callData.GetParamId(0));
                                if (!m_SkillInstances.ContainsKey(id))
                                {
                                    SkillInstance instance = new SkillInstance();
                                    instance.Init(info);
                                    m_SkillInstances.Add(id, instance);

                                    Logger.Info("ParseSkill {0}", id);
                                }
                                else
                                {
                                    //repeated skill config.
                                }
                            }
                        }
                    }
                }
            }
        }
Beispiel #19
0
 public void AddSkill(SkillInstance skill)
 {
     m_Skills.Add(skill);
     skill.AttachToCharacter(this);
 }
    public void ExcecuteSkillInstance(SkillInstance si)
    {
        GameObject go = ColliderManager.Instance.SpawnCollider (si.ColliderName_);
        TriggerEventObject teObj = go.AddComponent<TriggerEventObject> ();
        teObj.Owner = this;

        TrackMovement trackMovement = SkillManager.Instance.AddTrackComponent (go, si.TrackClass_);
        trackMovement.Target = gameObject;
        trackMovement.Switch = true;

        if (!m_SkillTriggerObjectList.Contains (go))
        {
            m_SkillTriggerObjectList.Add (go);
        }
    }
Beispiel #21
0
 public void LoadFuncData(Dsl.FunctionData funcData, SkillInstance instance)
 {
 }
Beispiel #22
0
 public virtual void Analyze(object sender, SkillInstance instance)
 {
 }
Beispiel #23
0
 public void LoadStatementData(Dsl.StatementData statementData, SkillInstance instance)
 {
 }
Beispiel #24
0
    public bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
    {
        GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;

        if (null == senderObj)
        {
            return(false);
        }
        if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
        {
            return(false);//track只能在impact或buff里使用
        }
        GameObject obj = senderObj.GfxObj;

        if (null != obj)
        {
            if (curSectionTime >= m_TriggerProxy.StartTime)
            {
                if (!m_IsStarted)
                {
                    m_IsStarted = true;

                    Vector3 dest;
                    string  trackBone = m_TrackBone.Get(instance);
                    m_BoneTransform = Utility.FindChildRecursive(obj.transform, trackBone);
                    if (null != m_BoneTransform)
                    {
                        dest = m_BoneTransform.position;
                    }
                    else
                    {
                        dest    = obj.transform.position;
                        dest.y += 1.5f;
                        LogSystem.Warn("[skill:{0} dsl skill id:{1}] trackbullet bone {2} can't find.", senderObj.SkillId, instance.DslSkillId, trackBone);
                    }
                    m_StartPos = EntityController.Instance.GetImpactSenderPosition(senderObj.ActorId, senderObj.SkillId, senderObj.Seq);
                    object speedObj;
                    if (instance.Variables.TryGetValue("emitSpeed", out speedObj))
                    {
                        m_Speed = (float)speedObj;
                    }
                    else
                    {
                        return(false);
                    }
                    long duration = m_Duration.Get(instance);
                    m_Lifetime = duration / 1000.0f;
                    if (Geometry.DistanceSquare(m_StartPos.x, m_StartPos.z, dest.x, dest.z) > 0.01f)
                    {
                        m_TargetPos = Utility.FrontOfTarget(dest, m_StartPos, m_Speed * m_Lifetime);
                    }
                    else
                    {
                        m_TargetPos = obj.transform.TransformPoint(0, 0, m_Speed * m_Lifetime);
                    }

                    long newSectionDuration = m_TriggerProxy.StartTime + (long)(m_Lifetime * 1000);
                    if (instance.CurSectionDuration < newSectionDuration)
                    {
                        instance.SetCurSectionDuration(newSectionDuration);
                    }
                    Quaternion dir;
                    object     dirObj;
                    if (instance.Variables.TryGetValue("emitDir", out dirObj))
                    {
                        dir = (Quaternion)dirObj;
                    }
                    else
                    {
                        dir = Quaternion.identity;
                    }
                    Vector3 scale;
                    object  scaleObj;
                    if (instance.Variables.TryGetValue("emitScale", out scaleObj))
                    {
                        scale = (Vector3)scaleObj;
                    }
                    else
                    {
                        scale = Vector3.one;
                    }
                    Vector3    lookDir = dest - m_StartPos;
                    Quaternion q       = Quaternion.LookRotation(lookDir);
                    m_ControlPos = m_StartPos + Vector3.Scale(q * dir * Vector3.forward, scale * lookDir.magnitude * 0.5f);
                    string effectPath = SkillParamUtility.RefixResourceVariable("emitEffect", instance, senderObj.ConfigData.resources);
                    m_Effect = ResourceSystem.Instance.NewObject(effectPath, m_Lifetime) as GameObject;
                    if (null != m_Effect)
                    {
                        senderObj.TrackEffectObj = m_Effect;
                        TriggerUtil.SetObjVisible(m_Effect, true);
                        m_Effect.SetActive(false);
                        m_Effect.transform.position      = m_StartPos;
                        m_Effect.transform.localRotation = q;
                        m_Effect.SetActive(true);

                        EffectManager em = instance.CustomDatas.GetData <EffectManager>();
                        if (em == null)
                        {
                            em = new EffectManager();
                            instance.CustomDatas.AddData <EffectManager>(em);
                        }
                        em.AddEffect(m_Effect);
                        em.SetParticleSpeed(instance.EffectScale);
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(effectPath))
                        {
                            LogSystem.Warn("[skill:{0} dsl skill id:{1}] trackbullet effect is empty.", senderObj.SkillId, instance.DslSkillId);
                        }
                        else
                        {
                            LogSystem.Warn("[skill:{0} dsl skill id:{1}] trackbullet effect {2} can't find.", senderObj.SkillId, instance.DslSkillId, effectPath);
                        }
                    }
                }
                else if (null != m_Effect)
                {
                    Vector3 dest;
                    if (null != m_BoneTransform)
                    {
                        dest = m_BoneTransform.position;
                    }
                    else
                    {
                        dest    = obj.transform.position;
                        dest.y += 1.5f;
                    }
                    dest = Utility.FrontOfTarget(m_StartPos, dest, 0.1f);
                    //m_Effect.transform.position = Vector3.MoveTowards(m_Effect.transform.position, m_TargetPos, m_RealSpeed * Time.deltaTime);
                    m_Effect.transform.position = Utility.GetBezierPoint(m_StartPos, m_ControlPos, m_TargetPos, (curSectionTime - m_TriggerProxy.StartTime) / 1000.0f / m_Lifetime);
                    var pos = m_Effect.transform.position;
                    if (!m_IsHit)
                    {
                        float distSqr = float.MaxValue;
                        if (m_LastPos.sqrMagnitude > Geometry.c_FloatPrecision)
                        {
                            ScriptRuntime.Vector2 np;
                            ScriptRuntime.Vector2 targetPos = new ScriptRuntime.Vector2(dest.x, dest.z);
                            ScriptRuntime.Vector2 lastPos   = new ScriptRuntime.Vector2(m_LastPos.x, m_LastPos.z);
                            distSqr = Geometry.PointToLineSegmentDistanceSquare(targetPos, lastPos, new ScriptRuntime.Vector2(pos.x, pos.z), out np);
                        }
                        else
                        {
                            distSqr = (dest - pos).sqrMagnitude;
                        }
                        m_LastPos = pos;
                        if (distSqr <= m_BulletRadiusSquare)
                        {
                            float curTime  = Time.time;
                            float interval = m_DamageInterval.Get(instance) / 1000.0f;
                            if (m_LastTime + interval <= curTime)
                            {
                                m_LastTime = curTime;

                                m_HitEffectRotation = Quaternion.LookRotation(m_StartPos - dest);
                                int impactId = TriggerUtil.GetSkillImpactId(instance.Variables, senderObj.ConfigData);
                                Dictionary <string, object> args;
                                TriggerUtil.CalcImpactConfig(0, impactId, instance, senderObj.ConfigData, out args);
                                if (args.ContainsKey("hitEffectRotation"))
                                {
                                    args["hitEffectRotation"] = m_HitEffectRotation;
                                }
                                else
                                {
                                    args.Add("hitEffectRotation", m_HitEffectRotation);
                                }
                                EntityController.Instance.TrackSendImpact(senderObj.ActorId, senderObj.SkillId, senderObj.Seq, impactId, args);
                                //m_IsHit = true;
                            }
                        }
                    }
                    if (curSectionTime > m_TriggerProxy.StartTime + m_Lifetime * 1000)
                    {
                        m_Effect.SetActive(false);
                        ResourceSystem.Instance.RecycleObject(m_Effect);
                        m_Effect = null;
                        instance.StopCurSection();
                        return(false);
                    }
                }
                else
                {
                    return(false);
                }
                return(true);
            }
            else
            {
                return(true);
            }
        }
        else
        {
            instance.StopCurSection();
            return(false);
        }
    }
Beispiel #25
0
    protected void _UpdatePassiveStateTransaction(SkillInstance newSkill)
    {
        if (newSkill == null)
        {
            return;
        }

        //Debug.Log(m_player.m_id + " Execute skill " + newSkill.skill.id + " " + newSkill.skill.name);
        Command cmd = (Command)newSkill.skill.action_type;

        if (!IsCommandValid(cmd))
        {
            Debug.Log("Command " + cmd + " invalid. State: " + m_eState);
            return;
        }

        switch (cmd)
        {
        case Command.Shoot:
            ShootHelper.ShootByInput(m_player);
            break;

        case Command.Block:
            m_stateMachine.SetState(PlayerState.State.eBlock, true);
            break;

        case Command.CrossOver:
            m_stateMachine.SetState(PlayerState.State.eCrossOver, true);
            break;

        case Command.Dunk:
            m_stateMachine.SetState(PlayerState.State.eDunk, true);
            break;

        case Command.Layup:
            m_stateMachine.SetState(PlayerState.State.eLayup, true);
            break;

        case Command.MoveStep:
            m_stateMachine.SetState(PlayerState.State.eMoveStep, true);
            break;

        case Command.Boxout:
            m_stateMachine.SetState(PlayerState.State.eStand);
            break;

        case Command.Steal:
            m_stateMachine.SetState(PlayerState.State.eSteal, true);
            break;

        case Command.Pass:
        {
            if (m_player.m_passTarget == null)
            {
                m_player.m_passTarget = PassHelper.ChoosePassTarget(m_player);
            }
            if (m_player.m_passTarget != null)
            {
                m_stateMachine.SetState(PlayerState.State.ePass, true);
            }
        }
        break;

        case Command.Rebound:
            m_stateMachine.SetState(PlayerState.State.eRebound, true);
            break;

        case Command.RequireBall:
            m_stateMachine.SetState(PlayerState.State.eRequireBall);
            break;

        case Command.CutIn:
            m_stateMachine.SetState(PlayerState.State.eCutIn);
            break;

        case Command.BodyThrowCatch:
            m_stateMachine.SetState(PlayerState.State.eBodyThrowCatch);
            break;

        case Command.BackToBack:
            m_stateMachine.SetState(PlayerState.State.eBackToBack);
            break;

        case Command.PickAndRoll:
            m_stateMachine.SetState(PlayerState.State.ePickAndRoll);
            break;

        case Command.Defense:
            m_stateMachine.SetState(PlayerState.State.eDefense);
            break;

        case Command.Interception:
            m_stateMachine.SetState(PlayerState.State.eInterception);
            break;

        default:
            m_stateMachine.SetState(PlayerState.State.eStand);
            break;
        }
    }
Beispiel #26
0
 protected bool InAttackRange(SkillInstance skill)
 {
     return DistToTarget() <= skill.BaseSkill.Range;
 }
Beispiel #27
0
        public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
        {
            GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;

            if (null == senderObj)
            {
                return(false);
            }
            Scene      scene = senderObj.Scene;
            EntityInfo obj   = senderObj.GfxObj;

            if (null == obj)
            {
                return(false);
            }
            if (curSectionTime < StartTime)
            {
                return(true);
            }
            if (m_IsExecuted && curSectionTime > (StartTime + m_RemainTime))
            {
                return(false);
            }

            Vector3    pos    = obj.GetMovementStateInfo().GetPosition3D();
            EntityInfo target = senderObj.TargetGfxObj;

            if (!m_IsExecuted && (null == target || !string.IsNullOrEmpty(m_SelectTargetType)))
            {
                if (string.IsNullOrEmpty(m_SelectTargetType))
                {
                    int targetType = scene.EntityController.GetTargetType(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
                    if (targetType == (int)SkillTargetType.Friend || targetType == (int)SkillTargetType.RandFriend)
                    {
                        m_RealSelectTargetType = "randfriend";
                    }
                    else
                    {
                        m_RealSelectTargetType = "randenemy";
                    }
                }
                TargetManager mgr = instance.CustomDatas.GetData <TargetManager>();
                if (null == mgr)
                {
                    mgr = new TargetManager();
                    instance.CustomDatas.AddData(mgr);
                }
                int targetId = scene.EntityController.SelectTargetForSkill(m_RealSelectTargetType, senderObj.ActorId, senderObj.ConfigData, senderObj.Seq, mgr.Targets);
                if (targetId > 0)
                {
                    mgr.Add(targetId);
                    target = scene.EntityController.GetGameObject(targetId);
                    senderObj.TargetActorId = targetId;
                    senderObj.TargetGfxObj  = target;
                }
            }
            if (null != target)
            {
                m_IsExecuted = true;
                if (!m_IsHaveRotateSpeed || m_RotateSpeed.Y == 0)
                {
                    TriggerUtil.Lookat(scene, obj, target.GetMovementStateInfo().GetPosition3D());
                }
                else
                {
                    float maxRotateDelta = m_RotateSpeed.Y * TriggerUtil.ConvertToSecond(delta);
                    TriggerUtil.Lookat(scene, obj, target.GetMovementStateInfo().GetPosition3D(), maxRotateDelta);
                }
            }
            return(true);
        }