Beispiel #1
0
        void LateUpdate()
        {
            if (!Ready || e == null)
            {
                return;
            }
            if (e.State == GAME_STATE.STATE_WORLD && e.getUI().KState == UI_KEYBOARD_STATE.STATE_FREE && e.getScene().State == SCENE_STATE.STATE_READY)
            {
                _MovementInput.x = Input.GetAxis("Horizontal");
                _MovementInput.z = Input.GetAxis("Vertical");

                _Animator.SetFloat("InputFB", _MovementInput.z);
                _Animator.SetFloat("InputLR", _MovementInput.x);


                if (Input.GetButtonDown("Jump"))
                {
                    if (_isGrounded && !_isJumping)
                    {
                        _JumpTimer = _JumpAirTime;
                        _isJumping = true;

                        /*
                         * if (_rigidbody.velocity.magnitude < 1)
                         *  animator.CrossFadeInFixedTime("Jump", 0.1f);
                         * else
                         *  animator.CrossFadeInFixedTime("JumpMove", 0.2f);
                         */
                    }
                }
                if (Input.GetMouseButtonDown(1))
                {
                    _isStrafing = true;
                    _Animator.SetBool("Strafe", true);
                }
                else if (Input.GetMouseButtonUp(1))
                {
                    _isStrafing = false;
                    _Animator.SetBool("Strafe", false);
                }

                if (Input.GetKeyDown(KeyCode.LeftShift))
                {
                    _isSprinting = true;
                    _Animator.SetBool("Sprint", true);
                }
                else if (Input.GetKeyUp(KeyCode.LeftShift))
                {
                    _isSprinting = false;
                    _Animator.SetBool("Sprint", false);
                }
            }
        }
        private IEnumerator scene_LoadLevelEnum(string level)
        {
            e.getUI().ui_ShowLoading(true);

            if (SceneManager.GetActiveScene().name == "Startup_Client")
            {
                e.getUI().ui_login_ShowUI(false);
                e.getUI().ui_lobby_HideCharacterSelect();
            }
            State = SCENE_STATE.STATE_LOADING;
            AsyncOperation asyncOp = SceneManager.LoadSceneAsync(level);

            while (!asyncOp.isDone)
            {
                e.getUI().ui_UpdateLoading(asyncOp.progress);
                yield return(null);
            }
        }
Beispiel #3
0
        public void world_SpawnPlayerSelf(S2GC_PlayerSpawn s)
        {
            Player_Self                 = GameObject.Instantiate(playerSelfPrefab).GetComponent <PlayerData_Self>();
            Player_Self.AccountName     = Self_Acc;
            Player_Self.PlayerID        = Self_ID;
            Player_Self.CharacterName   = s.SpawnData.CharacterName;
            Player_Self.gameObject.name = s.SpawnData.CharacterName;
            Player_Self.gameObject.transform.position = s.SpawnData.Position.V3;
            Player_Self.gameObject.transform.rotation = Quaternion.Euler(s.SpawnData.Rotation.V3);
            Player_Self.Level      = s.SpawnData.Level;
            Player_Self.EXP        = s.SpawnData.Experience;
            Player_Self.statPoints = s.SpawnData.StatPoints;
            Player_Self.Agility    = s.SpawnData.Agility;
            Player_Self.Intellect  = s.SpawnData.Intellect;
            Player_Self.Stamina    = s.SpawnData.Stamina;
            Player_Self.Strength   = s.SpawnData.Strength;
            Player_Self.Health     = s.SpawnData.HP;
            Player_Self.maxHealth  = s.SpawnData.MaxHP;
            Player_Self.Energy     = s.SpawnData.Energy;
            Player_Self.maxEnergy  = s.SpawnData.MaxEnergy;
            if (s.SpawnData.hasActiveQuests)
            {
                Player_Self.ActiveQuests = s.SpawnData.ActiveQuests;
            }
            else
            {
                Player_Self.ActiveQuests = new List <QuestData>();
            }

            if (s.SpawnData.hasFinishedQuests)
            {
                Player_Self.FinishedQuests = s.SpawnData.FinishedQuests;
            }
            else
            {
                Player_Self.FinishedQuests = new List <string>();
            }
            Player_Self.CharacterGender    = s.SpawnData.CharacterGender;
            Player_Self.CharacterEyeShape  = s.SpawnData.CharacterEyeShape;
            Player_Self.CharacterEyeType   = s.SpawnData.CharacterEyeType;
            Player_Self.CharacterEyeColor  = s.SpawnData.CharacterEyeColor.V4;
            Player_Self.CharacterFrontHair = s.SpawnData.CharacterFrontHair;
            Player_Self.CharacterBackHair  = s.SpawnData.CharacterBackHair;
            Player_Self.CharacterHairColor = s.SpawnData.CharacterHairColor.V4;


            Player_Self.Init(e);

            e.updateGameState(GAME_STATE.STATE_WORLD);
            e.getUI().ui_ShowLoading(false);
            e.getUI().ui_world_ShowUI();
        }
Beispiel #4
0
        // Update is called once per frame
        void LateUpdate()
        {
            if (playerCamera == null)
            {
                GameObject o = GameObject.Find("PlayerCamera");
                if (o != null)
                {
                    playerCamera = o.GetComponent <Camera>();
                }
                return;
            }
            if (mainPlayer == null)
            {
                mainPlayer = GameObject.FindWithTag("Player");
                return;
            }

            if (playerTarget != null)
            {
                screenPoint = playerCamera.WorldToViewportPoint(playerTarget.transform.position + targetOffset);
                bool onScreen = (screenPoint.x > 0.0f && screenPoint.x <1.0f && screenPoint.y> 0.0f && screenPoint.y <1.0f && screenPoint.z> 0.0f);
                if (onScreen)
                {
                    targetPos = new Vector3((screenPoint.x - 0.5f) * playerCamera.pixelWidth, (screenPoint.y - 0.5f) * playerCamera.pixelHeight, 0f);

                    if (wasOnScreen)
                    {
                        transform.localPosition = Vector3.Lerp(transform.localPosition, targetPos, lerpSpeed);
                    }
                    else
                    {
                        transform.localPosition = targetPos;
                        wasOnScreen             = true;
                    }


                    Vector3 rayDirection = (playerTarget.transform.position + new Vector3(0f, 0.7f, 0f)) - playerCamera.transform.position;
                    if (Physics.Raycast(playerCamera.transform.position, rayDirection, out hit, 100f, IgnoreLayers))
                    {
                        if (hit.transform.gameObject == playerTarget.gameObject)
                        {
                            Distance = Vector3.Distance(mainPlayer.transform.position, playerTarget.transform.position);
                            if (Distance > 100 && isEnabled)
                            {
                                isEnabled = false;
                                toggleDisplay(false);
                                if (isTargeted && selectedImage.enabled)
                                {
                                    isTargeted            = false;
                                    selectedImage.enabled = false;
                                    e.getUI().ui_world_DeselectTarget();
                                }
                            }
                            else if (Distance < 100 && !isEnabled)
                            {
                                isEnabled = true;
                                toggleDisplay(true);
                            }
                        }
                        else
                        {
                            if (isEnabled)
                            {
                                isEnabled = false;
                                toggleDisplay(false);
                                if (isTargeted && selectedImage.enabled)
                                {
                                    selectedImage.enabled = false;
                                }
                            }
                        }
                    }
                    else
                    {
                        //Didn't hit any colliders
                        if (isEnabled)
                        {
                            isEnabled = false;
                            toggleDisplay(false);
                            if (isTargeted && selectedImage.enabled)
                            {
                                selectedImage.enabled = false;
                            }
                        }
                    }
                }
                else
                {
                    wasOnScreen = false;
                    if (isEnabled)
                    {
                        isEnabled = false;
                        toggleDisplay(false);
                        if (isTargeted && selectedImage.enabled)
                        {
                            selectedImage.enabled = false;
                        }
                    }
                }
            }
        }
        public void combat_attemptCastSkill(BaseSkill s)
        {
            bool validTargetEnemy    = false;
            bool validTargetFriendly = false;
            bool validTargetSelf     = false;

            if (State == COMBAT_STATE.STATE_DEAD)
            {
                e.getUI().ui_ingame_DisplayError("You are dead.");
                return;
            }
            else if (onGlobalCooldown)
            {
                e.getUI().ui_ingame_DisplayError("You can't cast that yet.");
                return;
            }
            else if (s.onCooldown)
            {
                e.getUI().ui_ingame_DisplayError("That skill isn't ready yet.");
                return;
            }
            else if (CombatTarget != null)
            {
                // if(CombatTarget.isNPC)
                // {
                if (CombatTarget.Faction == AI_Faction.Hostile)
                {
                    if (s.allowedTargets.Contains(Skill_Targets.Enemy))
                    {
                        validTargetEnemy = true;
                    }
                    else if (s.allowedTargets.Contains(Skill_Targets.Self))
                    {
                        validTargetSelf = true;
                    }
                    else
                    {
                        e.getUI().ui_ingame_DisplayError("Invalid target.");
                        return;
                    }
                    //Enemy target and non-friendly spell
                }
                else if (CombatTarget.Faction == AI_Faction.Friendly || CombatTarget.Faction == AI_Faction.Neutral)
                {
                    if (s.allowedTargets.Contains(Skill_Targets.Enemy))
                    {
                        e.getUI().ui_ingame_DisplayError("You can't attack that target.");
                        return;
                    }
                    else if (s.allowedTargets.Contains(Skill_Targets.Friendly))
                    {
                        validTargetFriendly = true;
                    }
                    else if (s.allowedTargets.Contains(Skill_Targets.Self))
                    {
                        validTargetSelf = true;
                    }
                    //Enemy target and non-friendly spell
                }
                // }
                // else
                // {
                //     e.getUI().ui_ingame_DisplayError("Invalid target.");
                //     return;
                // }
            }
            else
            {
                e.getUI().ui_ingame_DisplayError("Invalid target.");
                return;
            }

            if (e.getWorld().Player_Self.Energy < s.energyCost)
            {
                e.getUI().ui_ingame_DisplayError("Not enough mana.");
                return;
            }

            if (validTargetFriendly || validTargetEnemy)
            {
                e.StartCoroutine(combat_globalCooldownStart());
                e.getNetwork().net_sendCastSpell(CombatTarget.uniqueID, s.skillID);
                //e.getWorld().world_castSpellFromPlayer();
            }
            else if (validTargetSelf)
            {
                e.StartCoroutine(combat_globalCooldownStart());
                e.getNetwork().net_sendCastSpell(e.getWorld().Player_Self.PlayerID, s.skillID);
            }
            //combat_castSkill(validTargetEnemy, validTargetFriendly, validTargetSelf);
        }
Beispiel #6
0
        private void net_onAskEnterWorldResponse(NetworkMessage netMsg)
        {
            S2GC_EnterWorldResponse Message = netMsg.ReadMessage <S2GC_EnterWorldResponse>();

            if (Message.errorCode == -1)
            {
                e.getScene().scene_LoadLevel("World_Client");
            }
            else
            {
                Client.Disconnect();
                e.getUI().ui_login_Disconnected("Something went wrong...");
            }
        }