Beispiel #1
0
        /// <summary>
        /// 重置
        /// </summary>
        public void Restore()
        {
            CacheSkin();
            //要在他们之前清理,因为动态脚本是依赖静态脚本的
            DestroyDynamicCommopnent();
            if (skinControl)
            {
                skinControl.Clear();
                skinControl = null;
            }
            if (m_property)
            {
                m_property.Restore();
                m_property = null;
            }

            if (m_stateMachine)
            {
                m_stateMachine.Clear();
                m_stateMachine.ResetAllMembers();
                m_stateMachine = null;
            }
            if (m_LightEffectManager)
            {
                m_LightEffectManager.Clear();
                m_LightEffectManager.Restore();
                m_LightEffectManager = null;
            }
            m_SkillCtrl = null;
            UBloodManager.Instance.DestroyBlood(ID);
            commands.Clear();
            //commands = null;
        }
Beispiel #2
0
        public void OnContinueOpenBtn()
        {
            LightingEffectManager lem = EntityFactory.EffectGroup.GetComponent <LightingEffectManager>();

            if (lem != null && m_camEffectID > 0)
            {
                lem.RemoveLightingImmediate(m_camEffectID);
            }

            resultPageObj.SetActive(false);

            Clear();

            //卸载动画场景
            SceneManager.Instance.UnLoadTreasureBoxAwardViewScene();

            //开启主界面UI
            chestPageObj.SetActive(true);
            closeBtn.gameObject.SetActive(true);

            RefreshChest();

            currentView  = EMPrizeChestView.EMView_Main;
            bEnableClose = true;

            // 如果没有宝箱了就直接返回游戏主城界面
            if (m_reaminingChestCount <= 0)
            {
                OnCloseBtn();
            }
        }
Beispiel #3
0
    public static bool Play(ref U3D_Render.EntityView ev, int effectID, cmd_creature_skillview cmdInfo)
    {
        //光效开关
        if (!Initialize.Instance || !OptimitzedControlPlane.Instance.EnabledLightingEffect)
        {
            return(true);
        }

        LightEffectParam param = new LightEffectParam();

        param.nFeedbackID     = cmdInfo.nFeedBackID;
        param.bIsHero         = ev.IsHero;
        param.nSrcEntityID    = ev.ID;
        param.nTargetEntityID = cmdInfo.nTargetEntityID;
        param.srcObject       = ev.gameObject;
        param.nCreatorSide    = cmdInfo.nCreatorSide;
        if (cmdInfo.nSrcEntityID > 0)
        {
            param.nSrcEntityID = cmdInfo.nSrcEntityID;
            param.srcObject    = EntityFactory.getEntityGameObjectByID(cmdInfo.nSrcEntityID);
        }
        param.fDistance    = cmdInfo.fDistance;
        param.fAttackRange = cmdInfo.fAttackRange;
        param.speed        = cmdInfo.fPASD;
        if (cmdInfo.nTargetEntityID != 0)
        {
            param.targetObject = EntityFactory.getEntityGameObjectByID(cmdInfo.nTargetEntityID);
        }
        param.targetPos = new Vector3(cmdInfo.fTargetPos_x, cmdInfo.fTargetPos_y, cmdInfo.fTargetPos_z);
        if (cmdInfo.bFlyToTargetPos != 0)
        {
            param.nEffectFlag |= (int)LightEffectParam.EFFECT_FLAG.FlyToTargetPos;
        }

        param.sourcePos = new Vector3(cmdInfo.fSrcPos_x, cmdInfo.fSrcPos_y, cmdInfo.fSrcPos_z);
        if (cmdInfo.bFromSrcPos != 0)
        {
            param.nEffectFlag |= (int)LightEffectParam.EFFECT_FLAG.CustomSourcePos;
        }

        LightingEffectManager manager = ev.LightingEffectManager;

        if (manager == null)
        {
            return(false);
        }

        // 开始光效
        manager.AddLighting(effectID, param);

        // 输出光效信息
        if (manager.showLog)
        {
            Trace.Log("Add Lighting" + effectID + ". Entity Id=" + ev.ID + " SrcID=" + param.nSrcEntityID);
            Trace.Log("TargetID=" + cmdInfo.nTargetEntityID + ". TargetPos=(" + cmdInfo.fTargetPos_x + "," + cmdInfo.fTargetPos_y + "," + cmdInfo.fTargetPos_z + ").");
        }

        return(true);
    }
Beispiel #4
0
        /// <summary>
        /// 绑定其他游戏组件对象
        /// </summary>
        /// <returns></returns>
        private bool BindGameCompent()
        {
            // 添加必要组件
            LightingEffectManager effectViewManager = m_gameObject.GetComponent <LightingEffectManager>();

            effectViewManager.Init();
            AttackedCollisionGroup attackedCollision = m_gameObject.GetComponent <AttackedCollisionGroup>();

            if (attackedCollision != null)
            {
                attackedCollision.nEntityID = ID;
            }

            // 初始化状态机数据
            StateMachine.entityID = ID;

            // 创建皮肤控制器
            BuildSkinControl();

            bool bRet = false;

            // 不同实体类型加载
            switch (Type)
            {
            case ENTITY_TYPE.TYPE_PLAYER_ROLE:
            {
                if (IsHero)
                {
                    bRet = BindHeroComponent();
                }
                else
                {
                    bRet = BindPlayerComponent();
                }
            }
            break;

            case ENTITY_TYPE.TYPE_MONSTER:
            {
                bRet = BindMonsterComponent();
            }
            break;

            case ENTITY_TYPE.TYPE_TANK:
            {
                bRet = BindTankComponent();
            }
            break;

            default:
            {
                Trace.Error("不能识别的类型,id=" + ID + ", type=" + (byte)Type);
            }
            break;
            }
            return(bRet);
        }
Beispiel #5
0
        //强行终止宝箱动画,关闭整个UI
        //此方法供游戏匹配进入时调用
        public void StopPrizeChest()
        {
            KillAllTimer();
            if (currentView == EMPrizeChestView.EMView_Award)
            {
                LightingEffectManager lem = EntityFactory.EffectGroup.GetComponent <LightingEffectManager>();
                if (lem != null && m_camEffectID > 0)
                {
                    lem.RemoveLightingImmediate(m_camEffectID);
                }

                Clear();
                resultPageObj.SetActive(false);
                //卸载动画场景
                SceneManager.Instance.UnLoadTreasureBoxAwardViewScene();
                currentView  = EMPrizeChestView.EMView_Main;
                bEnableClose = true;
            }
            OnCloseBtn();
        }
Beispiel #6
0
    public void EnableAccelerate(bool acc, float speed)
    {
        if (!m_bWing) //不是翅膀不加速
        {
            return;
        }
        if (accelerate != acc)
        {
            if (m_pFSM.animator)
            {
                m_pFSM.animator.SetBool("AccelerateFloat", acc);
            }
            if (wingAnimator)
            {
                wingAnimator.SetBool("AccelerateFloat", acc);
            }

            if (m_pFSM.isHero)
            {
                if (acc)
                {
                    ImageEffects.ImageEffectManager.API_EnableImageEffect <ImageEffects.RadialBlur>();
                    LightingEffectManager lightEffect = m_pFSM.GetComponent <LightingEffectManager>();
                    lightEffect.BindLighting(99998); //加速飞行默认99998号光效
                    lightEffect.BindLighting(281);   //加速飞行默认281号光效
                    lightEffect.BindLighting(282);   //加速飞行默认282号光效
                }
                else
                {
                    ImageEffects.ImageEffectManager.API_DisableImageEffect <ImageEffects.RadialBlur>();
                    LightingEffectManager lightEffect = m_pFSM.GetComponent <LightingEffectManager>();
                    lightEffect.RemoveLighting(99998);
                    lightEffect.RemoveLighting(281);
                    lightEffect.RemoveLighting(282);
                }
            }
        }

        m_maxSpeed = speed;
        accelerate = acc;
    }
Beispiel #7
0
        private void OnNextChestBtnClicked()
        {
            LightingEffectManager lem = EntityFactory.EffectGroup.GetComponent <LightingEffectManager>();

            if (lem != null && m_camEffectID > 0)
            {
                lem.RemoveLightingImmediate(m_camEffectID);
            }

            foreach (PrizeResultItem item in prizeResultList)
            {
                item.Clear();
            }
            m_isFromNextChestBtn = true;
            resultPageObj.SetActive(false);
            nextChestBtn.interactable = false;
            nextChestBtn.gameObject.SetActive(false);
            nextChestHint.gameObject.SetActive(false);
            continueOpenBtn.interactable = false;
            LogicDataCenter.prizeChestDataManager.RequestOpenChest(m_nextChestId);
        }
Beispiel #8
0
    /// <summary>
    /// 播放开头动画(最快下一帧开始播放)
    /// </summary>
    private void PlayBattleMovie()
    {
        LightingEffectManager lem = EntityFactory.EffectGroup.GetComponent <LightingEffectManager>();

        if (lem != null)
        {
            LightEffectParam param = new LightEffectParam();
            param.srcObject = MainHerpObj;
            param.sourcePos = MainHerpObj.transform.position;
            param.targetPos = MainHerpObj.transform.position;

            lem.AddLighting(343, param);
            //lem.RegisterEffectComplete(343, OnMovieFinished);
        }
        LightingEffectManager lem2 = EntityFactory.GloabaleManager;

        if (lem2 != null)
        {
            EffectHelper.Play(ref MainHerpEv, 333, MainHerpEv.ID, 0, MainHerpObj.transform.position);
            lem2.RegisterEffectStart(333, OnMovieStart);
            lem2.RegisterEffectComplete(333, OnMovieFinished);
        }
    }
Beispiel #9
0
    public static void Init()
    {
        EntityViewCommandHandler.Start();

        GameObject go = new GameObject("EntityFactory");

        DontDestroyOnLoad(go);
        go.AddComponent <EntityFactory>();


        EffectGroup     = new GameObject("EffectGroup");
        GloabaleManager = EffectGroup.AddComponent <LightingEffectManager>(); //这里放全局光效
        GloabaleManager.Init();
        GloabaleManager.isGlobal = true;

        DontDestroyOnLoad(EffectGroup);


        SkinCacheGroup = new GameObject("SkinCacheGroup");
        DontDestroyOnLoad(SkinCacheGroup);


        Trace.Log("==================initialize EntityView Factory===================");
    }
Beispiel #10
0
    ///// <summary>
    ///// 死亡前的碰撞层
    ///// </summary>
    //private int nOldCollisionLayer = -1;
    // 进入状态
    public bool OnEnter(IntPtr lParam)
    {
        //退出假死状态
        if (m_pFSM != null && m_pFSM.animatorCtrl != null)
        {
            m_pFSM.animatorCtrl.Dying = false;
        }

        Debug.Log("on OnEnter CreaturePosture_Dead " + this.m_pFSM.name);
        if (m_pFSM.showLog)
        {
            Trace.Log(m_pFSM.name + "=======OnEnter CreaturePosture_Dead======");
        }

        cmd_creature_die context = IntPtrHelper.toData <cmd_creature_die>(lParam);

        if (m_pFSM.showLog)
        {
            Trace.Log("DeadInterval:" + context.nDeadInterval);
            Trace.Log("reborn second:" + context.nInterval);
        }



        m_pFSM.rebornTick = context.nInterval - context.nDeadInterval;
        if (m_pFSM.rebornTick <= 0)
        {
            Trace.Log("rebornTick <= 0!");
            //return false;                   吃鸡地图,这个时差是0,所以先不要返回
        }
        m_nDeadInterval = context.nDeadInterval;

        //暂时让角色死亡不让射线检测该层
        //if (!m_pFSM.isHero)
        //{
        //    nOldLayer = m_pFSM.gameObject.layer;
        //    if (m_pFSM.gameObject.layer != LayerMask.NameToLayer(Config.LayerTransparentFX))
        //    {
        //        GameUtil.SetLayer(LayerMask.NameToLayer(Config.LayerNeutrality), m_pFSM.gameObject, true);
        //    }

        //    //m_pFSM.gameObject.layer = LayerMask.NameToLayer(Config.LayerPlayerFriend);
        //    //if (m_pFSM.SkinConfig.ScreenCastObject != null)
        //    //{
        //    //    m_pFSM.SkinConfig.ScreenCastObject.layer = LayerMask.NameToLayer(Config.LayerPlayerFriend);
        //    //}
        //}

        SkillCtrl sk = m_pFSM.GetComponent <SkillCtrl>();

        if (sk)
        {
            sk.enabled = false;
        }

        SoldierController sco = m_pFSM.GetComponent <SoldierController>();

        if (sco)
        {
            sco.dead = true;
        }

        if (m_pFSM.animator)
        {
            m_pFSM.animator.SetTrigger("Dead");

            m_pFSM.animator.ResetTrigger("Reborn");
        }

        //关闭死亡时要求关闭的光效
        LightingEffectManager light = m_pFSM.GetComponent <LightingEffectManager>();

        if (light)
        {
            light.CloseLightingWhenDead();
        }

        startTick = GameLogicAPI.getSyncTickCount(); // GameLogicAPI.getTickCount();
        endTick   = startTick + (uint)m_pFSM.rebornTick;
        tick_cameraSwitchAfterDead = startTick + m_pFSM.cameraSwitchAfterDead;

        if (m_pFSM.isHero)
        {
            //GFxGameHud hud = SFGFxMovieManager.GetWindow<GFxGameHud>();
            //if (SFGFxMovieManager.CheckTheMovieCanUse(hud))
            //{
            //    hud.ShowReliveTime(((float)m_pFSM.rebornTick));
            //}
            ScreenREC.GetInstance().SwitchRECState(ScreenREC.EMRECState.EMREC_STOP);

            //ImageEffects.ImageEffectManager.API_EnableImageEffect<ImageEffects.FullScreenGray>();
            if (ImageSetting.GetData().currImageQuality == ImageQuality.Fastest)
            {
                LightingEffectFactory.EnableDeadEffect();
                ImageEffects.ImageEffectManager.API_DisableImageEffect <ImageEffects.FullScreenSaturation>();
                ImageEffects.ImageEffectManager.API_DisableImageEffect <ImageEffects.DepthOfFieldScatter>();
            }
            else
            {
                LightingEffectFactory.DisableDeadEffect();
                ImageEffects.ImageEffectManager.API_EnableImageEffect <ImageEffects.FullScreenSaturation>();
                ImageEffects.ImageEffectManager.API_DisableImageEffect <ImageEffects.DepthOfFieldScatter>();
            }
        }

        //死亡不碰撞
        if (m_pFSM.controller)
        {
            //nOldCollisionLayer = m_pFSM.gameObject.layer;
            //m_pFSM.gameObject.layer = LayerMask.NameToLayer(Config.LayerIngoreRayCast);
            m_pFSM.pickableCount = 0;
        }

        int nEntityID = m_pFSM.entityID;

        U3D_Render.EntityView ev = EntityFactory.getPlayerViewByID(nEntityID);

        //添加金币掉落光效
        if (GameLogicAPI.isInWarScene() > 0)
        {
            addMoneyEffect(ev, context.uMurderID);
        }

        USpeedUI.Blood.UBloodManager.Instance.OnEntityDead(m_pFSM.entityID, ENTITY_TYPE.TYPE_PLAYER_ROLE);
        // 小地图隐藏
//         U3D_Render.EntityView objev = EntityFactory.getEntityViewByID(m_pFSM.entityID);
//         if (objev != null && GFxMinimapManager.Instance != null)
//         {
//             GFxMinimapManager.Instance.SetObjectVisible(m_pFSM.entityID, objev.createinfo.nMinimapIcon, 0);
//         }
        return(true);
    }
Beispiel #11
0
    private void OnAICommand()
    {
        int targetID = 0;

        if (raycast.targetID > 0)
        {
            EntityView evTarget       = EntityFactory.getEntityViewByID(raycast.targetID);
            EntityView evMainHeroView = EntityFactory.MainHeroView;
            if (evTarget != null && evTarget.IsValid)
            {
                if (evTarget.CampFlag == CampFlag.CampFlag_Friend && evTarget.Type == ENTITY_TYPE.TYPE_PLAYER_ROLE)
                {
                    // 1.发送服务器要(1)控制或(2)解除或   暂时没有该功能//(3)移交targetID的友方英雄单位
                    if (evTarget.Property.GetNumProp(ENTITY_PROPERTY.PROPERTY_AI_SCHEME_ID) > 0)
                    {
                        targetID = raycast.targetID;
                        if (!LogicDataCenter.teamRightWndDataManager.MyTeamUIDTable.ContainsKey(targetID))
                        {
                            return;
                        }
                        TeamRightInfo teamRightInfo = LogicDataCenter.teamRightWndDataManager.MyTeamUIDTable[targetID] as TeamRightInfo;

                        int       groundLightEffectID     = 0;
                        const int helpmeSignLightEffectID = 13;
                        const int dangerSignLightEffectID = 12;
                        if (LogicDataCenter.teamRightWndDataManager.BIsJoinFollow[teamRightInfo.nSlotId])
                        {
                            cmd_war_ai_command_break_follow data = new cmd_war_ai_command_break_follow();
                            data.uidTarget = targetID;
                            EntityEventHelper.Instance.SendCommand <cmd_war_ai_command_break_follow>(EntityFactory.MainHeroID, EntityLogicDef.ENTITY_CMD_AI_COMMAND_BREAK_FOLLOW, ref data);

                            groundLightEffectID = dangerSignLightEffectID;
                        }
                        else
                        {
                            cmd_war_ai_command_follow data = new cmd_war_ai_command_follow();
                            data.uidTarget = targetID;
                            EntityEventHelper.Instance.SendCommand <cmd_war_ai_command_follow>(EntityFactory.MainHeroID, EntityLogicDef.ENTITY_CMD_AI_COMMAND_FOLLOW, ref data);

                            groundLightEffectID = helpmeSignLightEffectID;
                        }
                        LogicDataCenter.teamRightWndDataManager.BIsJoinFollow[teamRightInfo.nSlotId] = !LogicDataCenter.teamRightWndDataManager.BIsJoinFollow[teamRightInfo.nSlotId];

                        // 添加地面光效
                        Vector3 pos = new Vector3();
                        if (MouseRaycastToGround(ref pos))
                        {
                            int        LayerMaskOnPos   = (1 << LayerMask.NameToLayer(Config.LayerDefault) | 1 << LayerMask.NameToLayer(Config.LayerBuilding));
                            Ray        PointToGroundRay = new Ray(pos + new Vector3(0, 0.5f, 0), new Vector3(0, -1, 0));
                            RaycastHit projectInfo;
                            Physics.Raycast(PointToGroundRay, out projectInfo, 100, LayerMaskOnPos);
                            pos = projectInfo.point;

                            LightEffectParam param = new LightEffectParam();
                            param.nSrcEntityID = evMainHeroView.ID;
                            param.sourcePos    = pos;
                            param.targetPos    = pos;
                            LightingEffectManager lem = evMainHeroView.LightingEffectManager;
                            if (lem != null && lem)
                            {
                                lem.AddLighting(groundLightEffectID, param);
                            }
                        }
                    }
                }
            }
        }
    }
Beispiel #12
0
    ////-----------------------------------------------------------------------------------------------------
    ////以下部分主要处理光效跟动作配合的时候,需要检查状态机切换再开始光效的功能
    ////-----------------------------------------------------------------------------------------------------
    //private List<LightingEffect> mDelayEffectList; //延迟挂接的光效,等到状态切换后再开始挂接
    //private int lastestStateNameHash = 0;
    //private void dealWithStateEffect()
    //{
    //    if (animator == null)
    //    {
    //        animator = transform.GetComponent<Animator>();
    //    }

    //    if (animator == null)
    //    {
    //        return;
    //    }
    //    if (animator.layerCount < 2)
    //    {
    //        return;
    //    }
    //    AnimatorStateInfo sta = animator.GetCurrentAnimatorStateInfo(1);
    //    int currentStateNameHash = sta.nameHash;
    //    if (currentStateNameHash == lastestStateNameHash)
    //    {
    //        return;
    //    }

    //    //切换动作了!这里nameHash只做切换时间点的判断,用nameHash和effect.waitState对比老是失败
    //    lastestStateNameHash=currentStateNameHash;
    //    foreach (LightingEffect effect in mDelayEffectList)
    //    {
    //        if (sta.IsName(effect.getWaitState()))
    //        {
    //            if (effect.Begin())
    //            {
    //                mEffectList.Add(effect);
    //            }
    //        }
    //    }

    //    //目前暂定切一次动作就清空一次延迟光效的记录,也就是说光效只能延迟一个动作挂接
    //    mDelayEffectList.Clear();
    //}



    // 添加一个光效
    // @param nID : 光效ID
    // @param nSrcEntityID : 光效源对象ID
    // @param targetObject : 目标对象,可以为空
    // @param targetPos : 目标位置,可以为空
    // @param isHero : 是否是游戏玩家控制的主角
    // @param nFeedbackID : 逻辑层传的ID标识,用于标记、删除和碰撞是返回标识。

    public LightingEffectBehavior AddLightingImpl(int nID, LightEffectParam param)
    {
        //远距离不创建分情况考虑,具体在LightingEffect实现
        //if (LightingEffectFactory.Instance.IsEnabledOptimize())
        //{
        //    //距离超过创建距离,不创建光效了。
        //    Vector3 dis = Initialize.mainCam.transform.position - param.srcObject.transform.position;
        //    if (dis.sqrMagnitude > LightingEffectFactory.CreateDistance * LightingEffectFactory.CreateDistance)
        //    {
        //        return null;
        //    }
        //}

        //处理单一实例的光效
        if (LightingEffectFactory.Instance.IsSingleEffect(nID))
        {
            foreach (LightingEffectBehavior effect in mEffectList)
            {
                if (effect.getID() == nID && effect.EffectConfig.bSingle)
                {
                    if (effect.EffectConfig.bRecoverSingleEffect)
                    {
                        effect.recoverEffectLift(param);
                        return(effect);
                    }
                    else if (effect.EffectParam.nTargetEntityID == param.nTargetEntityID)
                    {
                        effect.extendEffectLift();
                        return(effect);
                    }
                }
            }
        }

        if (LightingEffectFactory.Instance.CheckGolbalEffect(nID) && isGlobal == false)
        {
            LightingEffectManager leManager = EntityFactory.GloabaleManager;
            if (leManager != null && leManager.isGlobal == true)
            {
                leManager.AddLighting(nID, param);
            }
            return(null);
        }

        LightingEffectBehavior newEffect = LightingEffectFactory.Instance.CreateEffect(nID, param);

        if (newEffect == null)
        {
            return(null);
        }

        newEffect.showLog = showLog;
        //string needStateName = newEffect.getWaitState();

        //if (needStateName.Length != 0)
        //{
        //    AnimatorStateInfo sta = animator.GetCurrentAnimatorStateInfo(1);
        //    if (!sta.IsName(needStateName))
        //    {
        //        //等下一个切换状态时再检测
        //        mDelayEffectList.Add(newEffect);
        //        return newEffect;
        //    }
        //}

        //开始失败了,返回null
        if (newEffect.Begin())
        {
            mEffectList.Add(newEffect);

            return(newEffect);
        }
        return(null);
    }
Beispiel #13
0
    private bool createEffect()
    {
        LightEffectParam newParam = new LightEffectParam();

        EffectParam.ColoneTo(ref newParam);

        float maxDistance = EffectParam.fDistance;
        float effectRad   = EffectParam.fAttackRange;

        Vector3 newSourcePos = newParam.srcObject.transform.position;

        if (sourceTransform != null)
        {
            newSourcePos = sourceTransform.position;
        }


        Vector3 areaTargetPos = EffectParam.targetPos;
        Vector3 newTargetPos  = areaTargetPos;

        //构造一个范围内的随机目标位置
        if (areaConfig.projectOnGround == true)
        {  //构造一个投影到地面的圆形
            int     angle  = Random.Range(0, 360);
            float   _rad   = angle * Mathf.PI / 180.0f;
            Vector3 offset = new Vector3(Mathf.Sin(_rad), 0, Mathf.Cos(_rad));
            float   dis    = Random.Range(0.0f, effectRad);
            offset       *= dis;
            newTargetPos += offset;

            RaycastHit _ClosestHitInfo_Down;
            RaycastHit _ClosestHitInfo_Up;
            float      rayDistance          = maxDistance;
            Ray        PointToGroundRayDown = new Ray(newTargetPos, new Vector3(0, -1, 0));
            Ray        PointToGroundRayUp   = new Ray(newTargetPos, new Vector3(0, 1, 0));
            bool       DownHit     = Physics.Raycast(PointToGroundRayDown, out _ClosestHitInfo_Down, rayDistance, -1);
            bool       UpHit       = Physics.Raycast(PointToGroundRayUp, out _ClosestHitInfo_Up, rayDistance, -1);
            Vector3    recordPos   = newTargetPos;
            float      hitDistance = maxDistance;
            if (DownHit)
            {
                hitDistance  = (_ClosestHitInfo_Down.point - recordPos).magnitude;
                newTargetPos = _ClosestHitInfo_Down.point;
            }

            if (UpHit)
            {
                if ((_ClosestHitInfo_Up.point - recordPos).magnitude < hitDistance)
                {
                    hitDistance  = (_ClosestHitInfo_Up.point - recordPos).magnitude;
                    newTargetPos = _ClosestHitInfo_Up.point;
                }
            }

            newParam.targetPos = newTargetPos;
        }
        else if (effectRad > 0.01f)
        { //构造一个圆锥
            Vector3 normal  = EffectParam.targetPos - newSourcePos;
            Vector3 tangent = new Vector3(0, 0, 1);
            Vector3.OrthoNormalize(ref normal, ref tangent);
            int        angle    = Random.Range(0, 360);
            Quaternion rotation = Quaternion.AngleAxis((float)angle, normal);
            tangent = rotation * tangent;
            float dis = Random.Range(0.0f, effectRad);
            tangent      *= dis;
            newTargetPos += tangent;
            if (areaConfig.extentToMaxDistance)
            {//将目标点拉远,延长用更容易造成与地面的碰撞
                Vector3 dir = newTargetPos - newSourcePos;
                dir.Normalize();
                newTargetPos = newSourcePos + dir * maxDistance;
            }
            newParam.targetPos = newTargetPos;
        }
        else
        {
            if (areaConfig.extentToMaxDistance)
            {//将目标点拉远,延长用更容易造成与地面的碰撞
                Vector3 dir = newTargetPos - newSourcePos;
                dir.Normalize();
                newTargetPos = newSourcePos + dir * maxDistance;
            }
            newParam.targetObject = EffectParam.targetObject;
            newParam.targetPos    = EffectParam.targetPos;
        }

        if (areaConfig.customOffset.sqrMagnitude > 0.001f)
        {
            //有此设置时,变更起始点,变为相对于newParam.targetPos,偏移customOffet
            Vector3 offsetNormal = EffectParam.targetPos - newSourcePos;
            offsetNormal.y = 0;
            offsetNormal.Normalize();
            Vector3 offsetTangent  = new Vector3(0, 1, 0);
            Vector3 offsetBinormal = Vector3.Cross(offsetTangent, offsetNormal);
            //Vector3.OrthoNormalize(ref offsetNormal, ref offsetTangent,ref offsetBinormal);
            Vector3 offSet = newParam.targetPos;
            offSet               += offsetNormal * areaConfig.customOffset.z;
            offSet               += offsetTangent * areaConfig.customOffset.y;
            offSet               += offsetBinormal * areaConfig.customOffset.x;
            newParam.sourcePos    = offSet;
            newParam.nEffectFlag |= (int)LightEffectParam.EFFECT_FLAG.CustomSourcePos;
        }

        LightingEffectManager leManager = EffectParam.srcObject.GetComponent <LightingEffectManager>();

        if (leManager != null)
        {
            ////测试用代码,用来标记检测发射区域是否正确
            //GameObject checkPoint = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            //checkPoint.transform.localScale = new Vector3(0.2f, 0.2f, 0.2f);
            //checkPoint.transform.SetPosition( newParam.targetPos;
            //checkPoint.collider.enabled = false;
            //checkPoint.name = "Point" + mEffectLeftCount.ToString();

            leManager.AddLighting(areaConfig.subEffectID, newParam);
        }

        return(true);
    }
Beispiel #14
0
    // 进入状态
    public bool OnEnter(IntPtr lParam)
    {
        //if (m_pFSM.animator)
        //{
        //    m_pFSM.animator.SetTrigger("BreakAttack");
        //    m_pFSM.animator.SetBool("isDead", true);
        //   m_pFSM.animator.Play("Dead");

        //}

        cmd_creature_die cmdDie    = IntPtrHelper.toData <cmd_creature_die>(lParam);
        ulong            uMurderID = cmdDie.uMurderID;

        m_pFSM.SetAnimatorTrigger("BreakAttack");
        m_pFSM.SetAnimatorBool("isDead", true);
        m_pFSM.AnimatorPlay("Dead");
        m_pFSM.outLineCount = m_pFSM.outLineCount - 1;
        m_pFSM.setHightLight(false);

        //关闭死亡时要求关闭的光效
        LightingEffectManager light = m_pFSM.GetComponent <LightingEffectManager>();

        if (light)
        {
            light.CloseLightingWhenDead();
        }

        ////暂时让角色死亡不让射线检测该层
        //nOldLayer = m_pFSM.gameObject.layer;
        //GameUtil.SetLayer(LayerMask.NameToLayer(Config.LayerNeutrality), m_pFSM.gameObject, true);

        //if (m_pFSM.SkinConfig)
        //{
        //    if (m_pFSM.SkinConfig.ScreenCastObject)
        //    {
        //        m_pFSM.SkinConfig.ScreenCastObject.layer = LayerMask.NameToLayer(Config.LayerPlayerFriend);
        //    }

        //}
        //else
        //{
        //    Debug.Log(m_pFSM.entityID.ToString());
        //}

        if (m_pFSM.SkinConfig != null && m_pFSM.SkinConfig.ColliderShape != null)
        {
            m_pFSM.SkinConfig.ColliderShape.enabled = false;
        }
        m_pFSM.pickableCount--;

        //GfxBloodManager.OnEntityDead(m_pFSM.entityID,ENTITY_TYPE.TYPE_MONSTER);
        USpeedUI.Blood.UBloodManager.Instance.OnEntityDead(m_pFSM.entityID, ENTITY_TYPE.TYPE_MONSTER);
        //TopNameManager.OnEntityDead(m_pFSM.entityID, ENTITY_TYPE.TYPE_MONSTER);
        isOnThisState      = true;
        MaxDeadTimeCounter = 0.0f;

        int nEntityID = m_pFSM.entityID;

        U3D_Render.EntityView ev = EntityFactory.getMonsterViewByID(nEntityID);
        addMonsterEffect(ev, uMurderID);

        //死亡通知引导,死亡时间不确定,目前只想到在这硬编码了
        if (ev.CampFlag == SPELL.CampFlag.CampFlag_Enemy && ev.Type == ENTITY_TYPE.TYPE_MONSTER && ev.Property.GetNumProp(ENTITY_PROPERTY.PROPERTY_SEX) == (int)MONSTER_TYPE.MONSTER_TYPE_TOWER)
        {
            GUIDE.GuideManager.Instance.SetBBValue(GUIDE.EGuideBBKey.DeadEntityID, ev.ID);
        }

        if (ev != null)
        {
            MapFinderManager.RemoveObject(ref ev);
        }

        return(true);
    }
Beispiel #15
0
    //通过按键进入游戏
    //int state = 0;
    public void Update()
    {
        #region 通过按键进入游戏
        //通过按键进游戏
        //if(Input.GetKeyUp(KeyCode.N))
        //{
        //    switch (state)
        //    {
        //        case 0://denglu
        //            {
        //                // 现在是IP地址
        //                GameLogic.gameview_login data = new GameLogic.gameview_login();
        //                //data.svrip = "172.16.0.169";
        //                data.svrip = "127.0.0.1";
        //                data.account = "s124";
        //                data.password = "******";


        //                IntPtrHelper helper = new IntPtrHelper();
        //                IntPtr ptr = helper.toPtr<GameLogic.gameview_login>(ref data);
        //                int len = Marshal.SizeOf(data);

        //                ViewEventHelper.Instance.SendCommand(GameLogic.GameLogicDef.GVIEWCMD_USER_LOGIN, 1);
        //                state++;
        //                Debug.LogError("登陆");
        //            }

        //            break;
        //        case 1://打开战场大厅
        //            {
        //                ViewEventHelper.Instance.SendCommand(GameLogic.GameLogicDef.GVIEWCMD_MATCH_ENTER_HALL);
        //                state++;
        //                Debug.LogError("打开战场大厅");
        //            }

        //            break;
        //        case 2://打开创建房间
        //            {
        //                ViewEventHelper.Instance.SendCommand(GameLogicDef.GVIEWCMD_MATCH_OPEN_CREATE_ROOM);
        //                state++;
        //                Debug.LogError("打开创建房间");
        //            }
        //            break;
        //        case 3://创建房间
        //            {
        //                cmd_match_create_room data = new cmd_match_create_room();
        //                data.szName = "";
        //                ViewEventHelper.Instance.SendCommand<cmd_match_create_room>(GameLogicDef.GVIEWCMD_MATCH_CREATE_ROOM, ref data);
        //                state++;
        //                Debug.LogError("创建房间");
        //            }

        //            break;

        //        case 4://开始游戏
        //            {
        //                ViewEventHelper.Instance.SendCommand(GameLogicDef.GVIEWCMD_MATCH_START_GAME);
        //                state++;
        //                Debug.LogError("开始游戏");
        //            }
        //            break;
        //        case 5://选英雄
        //            {
        //                //选英雄
        //                ViewEventHelper.Instance.SendCommand(GameLogicDef.GVIEWCMD_MATCH_ROOM_HERO_CHANGE, 10);
        //                state++;
        //                Debug.LogError("选英雄");
        //            }
        //            break;

        //        case 6://确认
        //            {
        //                ViewEventHelper.Instance.SendCommand(GameLogicDef.GVIEWCMD_MATCH_ROOM_CONFIRM_HERO);
        //                state++;
        //                Debug.LogError("确认英雄");
        //            }
        //            break;
        //        case 7://倒计时结束
        //            {
        //                ViewEventHelper.Instance.SendCommand(GameLogicDef.GVIEWCMD_MATCH_READY_TO_FIGHT);
        //                state++;
        //                Debug.LogError("倒计时结束");
        //            }

        //            break;
        //    }
        //}
        #endregion


        LightingEffectManager.UpdateCreateList();
    }
Beispiel #16
0
        private void LoadPrizeResultEffectAndSetUIData()
        {
            //获取当前开启的宝箱配置
            prizeChestConfig = ActorPrizeConfig.Instance.GetPrizeChestConfig(m_nResultPageChestType);
            if (prizeChestConfig == null)
            {
                return;
            }

            //创建临时模型
            tempModelID = Mathf.Clamp(prizeChestConfig.nChestModelID - 1, 0, 2);
            if (prizeChestResNodeList[tempModelID] != null)
            {
                GameObject prizeChestObj = prizeChestResNodeList[tempModelID].InstanceMainRes();
                if (prizeChestObj != null)
                {
                    prizeChestObj.transform.SetParent(prizeResultObjContainer);
                    prizeChestObj.transform.localPosition = Vector3.zero;

                    tempPriezeChestModel = prizeChestObj;
                }
            }
            else
            {
                Debug.LogError(String.Format("not find model ID in prizeChestResNodeList[{0}]", tempModelID));
                return;
            }

            //播放模型打开动画的光效
            SceneEffectParamBase openEffectParam = new SceneEffectParamBase(prizeChestConfig.nOpenEffect, tempPriezeChestModel.transform);

            SceneEffectManager.Instance.CreateSceneEffect(ref openEffectParam);

            Data.UISoundConfig.SSchemeUSoundData soundData = new Data.UISoundConfig.SSchemeUSoundData();
            if (Data.UISoundConfig.UISoundConfig.Instance.GetData(SoundFilter_AnimStart, SoundKey_AnimStart, ref soundData))
            {
                SoundManager.CreateUISound(soundData.USoundID);
            }

            Transform[] tempChestModelChilds = tempPriezeChestModel.transform.GetComponentsInChildren <Transform>();

            //挂载摄像机动画
            Transform cmdTr = prizeResultObjContainer.parent.FindChild("CamTarget");

            if (cmdTr != null)
            {
                DestroyObject(cmdTr.gameObject);
            }
            GameObject camTarget = new GameObject();

            camTarget.name = "CamTarget";
            camTarget.transform.SetParent(prizeResultObjContainer.parent);
            camTarget.transform.localPosition    = prizeResultObjContainer.localPosition;
            camTarget.transform.localEulerAngles = Vector3.zero;

            LightingEffectManager lem = EntityFactory.EffectGroup.GetComponent <LightingEffectManager>();

            if (lem != null)
            {
                LightEffectParam param = new LightEffectParam();
                param.srcObject = camTarget;
                param.sourcePos = camTarget.transform.position;
                param.targetPos = camTarget.transform.position;

                m_camEffectID = prizeChestConfig.nCamEffectID;

                lem.AddLighting(prizeChestConfig.nCamEffectID, param);
            }


            List <int> prizeIdList = LogicDataCenter.prizeChestDataManager.PrizeIdList;

            openPrizeCount = 0;
            prizeCount     = Mathf.Clamp(prizeIdList.Count, 0, 7);

            //增加Tooltip
            if (continueOpenBtn != null)
            {
                continueOpenBtn.interactable = prizeCount > 0 ? false : true;
                if (!continueOpenBtn.interactable)
                {
                    UTooltipTrigger tooltip = continueOpenBtn.gameObject.GetComponent <UTooltipTrigger>();
                    if (tooltip == null)
                    {
                        tooltip = continueOpenBtn.gameObject.AddComponent <UTooltipTrigger>(ETooltipStyle.ETS_Default);
                    }
                    tooltip.SetText(UTooltipParamName.BodyText, openTips);
                }
            }

            foreach (PrizeResultItem item in prizeResultList)
            {
                UTooltipTrigger trigger = item.transform.GetComponent <UTooltipTrigger>();
                if (trigger != null)
                {
                    trigger.enabled = false;
                }
            }

            //奖励宝箱模型上挂载光效
            for (int i = 0; i < prizeIdList.Count; ++i)
            {
                //PrizeID必须大于0,界面大小,图标最多放12个
                if (prizeIdList[i] <= 0 || i >= 7)
                {
                    break;
                }

                int nPrizeID = prizeIdList[i];
                SSchemeActorPrizeConfig config = null;

                if (nPrizeID >= RAND_CARD_FIRST_INDEX && nPrizeID < LogicDataCenter.prizeChestDataManager.RandCardIndex)
                {
                    config = LogicDataCenter.prizeChestDataManager.RandCardResult[nPrizeID];
                }
                else
                {
                    config = ActorPrizeConfig.Instance.GetActorPrizeConfig(nPrizeID);
                }

                if (config == null)
                {
                    return;
                }

                //骨骼上挂载奖励光效
                foreach (Transform tr in tempChestModelChilds)
                {
                    if (tr != null && tr.name.Equals(bonesName[i]))
                    {
                        SceneEffectParamBase effectParam = new SceneEffectParamBase(config.nCakeTrailEffectID, tr, null, true, 2700);
                        SceneEffectManager.Instance.CreateSceneEffect(ref effectParam);

                        CakeTrailEffectParamList.Add(effectParam);
                    }
                }
                //奖励UI数据填充
                prizeResultList[i].SetData(this, i, prizeIdList[i], config);
            }
            //开启动画定时器
            TimerManager.SetTimer(this, chestAnimTimer, 4.2f);
        }