Ejemplo n.º 1
0
    public void SetSize(GameObject bullseye, SizeOfBullseye size)
    {
        switch (size)
        {
        case SizeOfBullseye.S:
            bullseye.transform.localScale = new Vector3(this.BullseyeSmallSize, 1f, this.BullseyeSmallSize);
            break;

        case SizeOfBullseye.M:
            bullseye.transform.localScale = new Vector3(this.BullseyeMediumSize, 1f, this.BullseyeMediumSize);
            break;

        case SizeOfBullseye.L:
            bullseye.transform.localScale = new Vector3(this.BullseyeLargeSize, 1f, this.BullseyeLargeSize);
            break;
        }
    }
Ejemplo n.º 2
0
    public GameObject CreateBullseye()
    {
        Vector3 position = Vector3.zero;

        GameObject bullseye = (GameObject)GameObject.Instantiate(BullseyePrefab, position, Quaternion.identity);

        //tamaño
        SizeOfBullseye size = defSize[Mathf.FloorToInt(UnityEngine.Random.Range(0f, 1f) * defSize.Length)];

        if (Habilidades.IsActiveSkill(Habilidades.Skills.Vista_halcon))
        {
            if (size == SizeOfBullseye.S)
            {
                size = SizeOfBullseye.M;
            }
            else if (size == SizeOfBullseye.M)
            {
                size = SizeOfBullseye.L;
            }
        }
        SetSize(bullseye, size);
        float radius = bullseye.GetComponent <Bullseye>().radiusOfBullseye;

        //altura
        int maxheight = 0;
        int minheight = 10;

        foreach (HeightOfBullseye h in defHeight)
        {
            int heightInt = (int)h;
            if (maxheight < heightInt)
            {
                maxheight = heightInt;
            }
            if (minheight > heightInt)
            {
                minheight = heightInt;
            }
        }
        position.y = UnityEngine.Random.Range(minheight * (2.25f + radius) / 3f, (maxheight + 1) * (2.25f - radius) / 3f);

        //posicion horizontal
        if (defZone == ZoneOfBullseye.Centro)
        {
            position.x = UnityEngine.Random.Range(-1.5f, 1.5f);
        }
        else
        {
            position.x = UnityEngine.Random.Range(1.5f, 3.4f - radius) * ((UnityEngine.Random.Range(0f, 1f) > 0.5f) ? 1f : -1f);
        }
        position.z = Porteria.instance.transform.position.z;
        bullseye.transform.position = position;

        ////bullseye.transform.LookAt( this.CameraReference.transform.position );
        bullseye.transform.Rotate(new Vector3(90, 0, 0));

        // velocidad
        bullseye.transform.GetComponent <Bullseye>().vel = new Vector3(
            defInitialSpeed.x * (UnityEngine.Random.Range(0, 2) == 1 ? -1 : 1),
            defInitialSpeed.y * (UnityEngine.Random.Range(0, 2) == 1 ? -1 : 1),
            defInitialSpeed.z);

        bullseye.transform.GetComponent <Bullseye>().staticSize = staticSize;

        bullseye.GetComponent <Bullseye>().Init(new int[] {
            (int)ScoreManager.BullsEyeScore.Red,
            (int)ScoreManager.BullsEyeScore.Yellow,
            (int)ScoreManager.BullsEyeScore.Blue,
            (int)ScoreManager.BullsEyeScore.White
        });

        return(bullseye);
    }
Ejemplo n.º 3
0
    /// <summary>
    /// Comprueba como se deben pintar las dianas
    /// </summary>
    /// <param name="_hayPortero">Indica si hay portero para este tiro</param>
    /// <returns></returns>
    private void SetBullEyes(bool _hayPortero)
    {
        if (currentBullseye != null)
        {
            GameObject.Destroy(currentBullseye);
        }

        // SI ES TIRADOR
        if (GameplayService.initialGameMode == GameMode.Shooter)
        {
            // si no hay portero
            if (!_hayPortero)
            {
                // si no es una fase en la que hay portero pero no debe haber dianas expresamente
                if (!(GameplayService.modoJuego.tipoModo == ModoJuego.TipoModo.EXPERTO && fase == 0))
                {
                    SizeOfBullseye[]   sizes            = { };
                    HeightOfBullseye[] heights          = { };
                    ZoneOfBullseye     zone             = ZoneOfBullseye.Centro;
                    Vector3            velocidadInicial = Vector3.zero;

                    // usar esta variable para asegurar que a partir de la fase 9 las fases se ciclan
                    int auxFase = fase;
                    if (auxFase > 10)
                    {
                        if (fase % 2 == 1)
                        {
                            // si la fase es impar => como la 9
                            auxFase = 9;
                        }
                        else
                        {
                            // si la fase es par => como la 10
                            auxFase = 10;
                        }
                    }
                    // definir la posicion inicial de las dianas
                    switch (auxFase)
                    {
                    case 0:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.L, SizeOfBullseye.M };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Baja };
                        zone    = ZoneOfBullseye.Centro;
                        break;

                    case 1:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.L };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Baja };
                        zone    = ZoneOfBullseye.Centro;
                        break;

                    case 2:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.L, SizeOfBullseye.M };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Baja };
                        zone    = ZoneOfBullseye.Centro;
                        break;

                    case 3:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.L };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Baja };
                        zone    = ZoneOfBullseye.Centro;
                        break;

                    case 4:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.S };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Media, HeightOfBullseye.Alta };
                        zone    = ZoneOfBullseye.Centro;
                        break;

                    case 5:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.S };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Media, HeightOfBullseye.Alta };
                        zone    = ZoneOfBullseye.Centro;
                        break;

                    case 6:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.M };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Media, HeightOfBullseye.Alta };
                        zone    = ZoneOfBullseye.Centro;
                        break;

                    case 7:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.S };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Media, HeightOfBullseye.Alta };
                        zone    = ZoneOfBullseye.Lados;
                        break;

                    case 8:
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.S };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Media, HeightOfBullseye.Alta };
                        zone    = ZoneOfBullseye.Lados;
                        break;

                    case 9:   // NOTA: a partir de la fase 9, las fases impares se ejecutan de esta manera
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.S };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Media, HeightOfBullseye.Alta };
                        zone    = ZoneOfBullseye.Lados;
                        break;

                    case 10:   // NOTA: a partir de la fase 10, las fases pares se ejecutan de esta manera
                        sizes   = new SizeOfBullseye[] { SizeOfBullseye.S };
                        heights = new HeightOfBullseye[] { HeightOfBullseye.Media, HeightOfBullseye.Alta };
                        zone    = ZoneOfBullseye.Lados;
                        break;
                    }

                    // asignar velocidad a las dianas
                    // NOTA: si las dianas se mueven => hacer que su tamaño sea grande
                    if (GameplayService.modoJuego.tipoModo == ModoJuego.TipoModo.LEYENDA && (auxFase == 0 || auxFase == 1 || auxFase == 3 || auxFase == 4 || auxFase == 6 || auxFase == 7 || auxFase == 9))
                    {
                        velocidadInicial = new Vector3(0.3f, 0.3f, 0.0f);
                        sizes            = new SizeOfBullseye[] { SizeOfBullseye.L };
                    }

                    BullseyeManager.Instance.defSize         = sizes;
                    BullseyeManager.Instance.defHeight       = heights;
                    BullseyeManager.Instance.defZone         = zone;
                    BullseyeManager.Instance.defInitialSpeed = velocidadInicial;

                    // crear la diana
                    currentBullseye = BullseyeManager.Instance.CreateBullseye();
                }
            }
        }
    }