Esempio n. 1
0
    public IEnumerator MoveToEntity(TPS_Entity targetEntity, float speed)
    {
        yield return(Time.deltaTime);

        float distance  = Vector3.Distance(transform.position, targetEntity.transform.position);
        float timeScale = speed / distance;

        transform.position = Vector3.Lerp(transform.position, targetEntity.transform.position, timeScale);

        if (distance > 5.0f)
        {
            StartCoroutine(MoveToEntity(targetEntity, speed));
        }

        else
        {
            disableControls = false;
        }
    }
    // #########################################################
    // -------------------- INITIALIZATION ------------------- #
    // #########################################################

    protected override void Awake()
    {
        base.Awake();

        entity     = GetComponent <TPS_Entity>();
        controller = GetComponent <CharacterController>();

        // Values
        isFalling = true;

        if (owner != null)
        {
            // Cursor
            Cursor.lockState = CursorLockMode.Locked;
            Cursor.visible   = false;
        }

        else
        {
            guiCanvas.enabled = false;
        }
    }
Esempio n. 3
0
    // #########################################################
    // -------------------- INITIALIZATION ------------------- #
    // #########################################################

    protected override void Awake()
    {
        base.Awake();

        entity     = GetComponent <TPS_Entity>();
        controller = GetComponent <CharacterController>();
        hotbar     = GetComponent <TPS_Hotbar>();

        // Values
        isFalling = true;

        if (owner != null)
        {
            // Cursor
            Cursor.lockState = CursorLockMode.Locked;
            Cursor.visible   = false;
        }

        else
        {
            guiCanvas.enabled = false;
        }

        switch (selectClass)
        {
        default:
        case RPG3_ClassList.Warrior:
            currentClass = ScriptableObject.CreateInstance <RPG3_Warrior>();
            break;

        case RPG3_ClassList.Rogue:
            currentClass = ScriptableObject.CreateInstance <RPG3_Rogue>();
            break;

        case RPG3_ClassList.Mage:
            currentClass = ScriptableObject.CreateInstance <RPG3_Mage>();
            break;
        }

        for (int i = 0; i < currentClass.abilities.Count; i++)
        {
            abilityManager.GetComponent <RPG3_AbilityPanel>().Initialize(this, currentClass.abilities[i]);
        }

        switch (currentClass.resourceType)
        {
        case RPG3_ResourceType.Rage:
            resourceBar.color  = Color.red;
            entity.maxHealth   = currentClass.baseHealth + (currentClass.stamina * 8);
            entity.maxResource = currentClass.baseResource;
            entity.resource    = 0;
            break;

        case RPG3_ResourceType.Mana:
            resourceBar.color  = Color.blue;
            entity.maxHealth   = currentClass.baseHealth + (currentClass.stamina * 8);
            entity.maxResource = currentClass.baseResource + (currentClass.intellect * 8);
            entity.resource    = entity.maxResource;
            break;

        case RPG3_ResourceType.Energy:
            resourceBar.color  = Color.yellow;
            entity.maxHealth   = currentClass.baseHealth + (currentClass.stamina * 8);
            entity.maxResource = currentClass.baseResource;
            entity.resource    = entity.maxResource;
            break;

        default: break;
        }

        currentClass.entity = entity;
        characterInfo.GetComponent <RPG3_CharacterInfoManager>().controller = this;
        //hotbar.UpdateIcons();
    }
Esempio n. 4
0
    // #########################################################
    // # ---------------------- UPDATE ----------------------- #
    // #########################################################

    public override void Tick()
    {
        base.Tick();

        if (owner != null)
        {
            if (!owner.gm.isPaused)
            {
                if (!disableControls)
                {
                    Motion();
                }


                // TARGETING SYSTEM
                if (activeTargetIndicator != null)
                {
                    Ray ray = cam.ScreenPointToRay(Input.mousePosition);

                    RaycastHit hitInfo;
                    if (Physics.Raycast(ray, out hitInfo))
                    {
                        // Get Collision Data
                        ///////////////////////////////////////////////////////////////////////////////////////////////

                        activeTargetIndicator.transform.position = hitInfo.point + hitInfo.normal * 0.1f;
                    }
                }

                // CHANNELLING
                if (channelledAbility != null)
                {
                    channelingBar.enabled  = true;
                    channelingText.enabled = true;

                    if (channelTimer > 0)
                    {
                        channelTimer -= Time.deltaTime;
                        isChanneling  = true;

                        channelingText.text      = channelledAbility.GetName() + " : " + Mathf.Round(channelTimer * 100) / 100;
                        channelingBar.fillAmount = (channelTimer / 2.5f);
                    }

                    if (channelTimer <= 0)
                    {
                        RPG3_AbilitySettings settings = new RPG3_AbilitySettings();
                        switch (channelledAbility.GetAbilityMode())
                        {
                        case RPG3_AbilityMode.Targeted:
                            settings = RPG3_AbilitySettings.Initialize(this, channelTarget);
                            break;

                        case RPG3_AbilityMode.Positional:
                            settings = RPG3_AbilitySettings.Initialize(this, abilityTargetPoint);
                            break;

                        case RPG3_AbilityMode.Self:
                            settings = RPG3_AbilitySettings.Initialize(this, channelTarget);
                            break;
                        }

                        channelledAbility.Effect(settings);

                        channelledAbility      = null;
                        channelTarget          = null;
                        channelingBar.enabled  = false;
                        channelingText.enabled = false;
                    }
                }

                hotbar.HotkeyTracker();

                if (Input.GetKeyDown(KeyCode.Mouse0))
                {
                    // If a UI element was pressed, break out.
                    if (uiRaycaster.Raycast().Count > 0)
                    {
                        return;
                    }

                    if (abilityBeingTargeted == null)
                    {
                        // Clear the active target if worldspace was clicked
                        if (targetController != null || targetEntity != null)
                        {
                            targetController = null;
                            targetEntity     = null;
                        }
                    }


                    // if the UI was not pressed, raycast to world position
                    Ray ray = cam.ScreenPointToRay(Input.mousePosition);

                    RaycastHit hitInfo;
                    if (Physics.Raycast(ray, out hitInfo))
                    {
                        // Get Collision Data
                        ///////////////////////////////////////////////////////////////////////////////////////////////

                        GameObject targetHit = hitInfo.collider.gameObject;
                        Debug.Log(targetHit);

                        // Activate an ability that's being targeted
                        if (abilityBeingTargeted != null)
                        {
                            if (activeTargetIndicator != null)
                            {
                                Destroy(activeTargetIndicator);
                                activeTargetIndicator = null;
                            }

                            RPG3_AbilitySettings settings = RPG3_AbilitySettings.Initialize(this, hitInfo.point);
                            abilityBeingTargeted.Activate(settings);

                            abilityTargetPoint = hitInfo.point;
                            abilityBeingTargeted.isTargeting = false;
                            abilityBeingTargeted             = null;
                        }


                        // Selection Command
                        if (targetHit.GetComponentInParent <TPS_Controller>() != null)
                        {
                            targetController = targetHit.GetComponentInParent <TPS_Controller>();
                        }

                        if (targetHit.GetComponentInParent <TPS_Entity>() != null)
                        {
                            //Debug.Log(hitInfo.collider.gameObject.name + " selected");

                            targetEntity = targetHit.GetComponentInParent <TPS_Entity>();

                            ///////////////////////////////////////////////////////////////////////////////////////////////
                        }
                    }
                }

                if (Input.GetKeyDown(KeyCode.Mouse1))
                {
                    // Activate an ability that's being targeted
                    if (abilityBeingTargeted != null)
                    {
                        if (!isChanneling)
                        {
                            if (activeTargetIndicator != null)
                            {
                                Destroy(activeTargetIndicator);
                                activeTargetIndicator = null;
                            }

                            abilityTargetPoint = Vector3.zero;
                            abilityBeingTargeted.isTargeting = false;
                            abilityBeingTargeted             = null;
                        }
                    }
                }

                // Update Canvas
                if (guiCanvas.enabled)
                {
                    // Health
                    healthText.text = entity.GetCurrentHealth() + " / " + entity.GetMaxHealth();

                    float currentHealth = entity.GetCurrentHealth();
                    float maxHealth     = entity.GetMaxHealth();
                    healthBar.fillAmount = currentHealth / maxHealth;

                    // Resource
                    resourceText.text = entity.GetCurrentResource() + " / " + entity.GetMaxResource();

                    float currentResource = entity.GetCurrentResource();
                    float maxResource     = entity.GetMaxResource();
                    resourceBar.fillAmount = currentResource / maxResource;

                    // Target System
                    if (targetEntity != null)
                    {
                        if (!targetInfoDisplay.activeInHierarchy)
                        {
                            targetInfoDisplay.SetActive(true);
                        }

                        // Health
                        targetHealthText.text = targetEntity.GetCurrentHealth() + " / " + targetEntity.GetMaxHealth();

                        float currentTargetHealth = targetEntity.GetCurrentHealth();
                        float maxTargetHealth     = targetEntity.GetMaxHealth();
                        targetHealthBar.fillAmount = currentTargetHealth / maxTargetHealth;

                        // Resource
                        targetResourceText.text = targetEntity.GetCurrentResource() + " / " + targetEntity.GetMaxResource();

                        float currentTargetResource = targetEntity.GetCurrentResource();
                        float maxTargetResource     = targetEntity.GetMaxResource();
                        targetResourceBar.fillAmount = currentTargetResource / maxTargetResource;
                    }

                    else
                    {
                        if (targetInfoDisplay.activeInHierarchy)
                        {
                            targetInfoDisplay.SetActive(false);
                        }
                    }
                }
            }
        }
    }