void Awake()
    {
        // Enforce singleton pattern
        if (instance == null)
        {
            instance = this;
        }
        else if (instance != this)
        {
            Destroy(gameObject);
        }

        // Prevent status from being destroyed between levels
        DontDestroyOnLoad(gameObject);
    }
    public void GenerateLevel()
    {
        Instantiate(startObject, startPos, Quaternion.identity);
        YDistance  += startPos.y + YDistanceBetweenObjects;
        rightXLimit = Camera.main.ScreenToWorldPoint(new Vector3(0f, 10, Camera.main.transform.position.z)).x;
        leftXLimit  = Camera.main.ScreenToWorldPoint(new Vector3(Screen.width, 10, Camera.main.transform.position.z)).x;

        GameObject previousObj = startObject;

        for (int i = 0; i < SpawnAmount; i++)
        {
            SpawnPlatform objToSpawn        = platformsToSpawn[UnityEngine.Random.Range(0, platformsToSpawn.Length)];
            float         xPos              = UnityEngine.Random.Range(leftXLimit / 2, rightXLimit / 2);
            float         maxYPosInChildren = getMaxPosYInChildren(previousObj);
            if (maxYPosInChildren != float.MinValue)
            {
                YDistance = YDistanceBetweenObjects + maxYPosInChildren;
            }
            else
            {
                // if there is no children in the previous object, just add the distance and the object's y position
                YDistance = YDistanceBetweenObjects + previousObj.transform.position.y;
            }

            if (objToSpawn.rotations.Length > 0)
            {
                previousObj = Instantiate(objToSpawn.prefab, new Vector3(xPos, YDistance, startPos.z),
                                          Quaternion.Euler(objToSpawn.rotations[UnityEngine.Random.Range(0, objToSpawn.rotations.Length)]));
            }
            else
            {
                previousObj = Instantiate(objToSpawn.prefab, new Vector3(xPos, YDistance, startPos.z), Quaternion.identity);
            }
        }
        // add the last finishing platform after generating the level
        Instantiate(finishObject, new Vector3(0f, previousObj.transform.position.y + YDistanceBetweenObjects + 10f, startPos.z), Quaternion.identity);
    }
Example #3
0
    /* don't want to use, can't set the transform of a sprite, it's not a GameObject
     * public Sprite sprite0;
     * public Sprite sprite1;
     * public Sprite sprite2;
     * public Sprite sprite3;
     * public Sprite sprite4;
     */


    // Use this for initialization
    void Start()
    {
        //see above, slots is obsolete

        /*slots = new int[powerCount];
         * for (int i = 0; i < powerCount; i++)
         *      slots [i] = i * -100;
         */

        sP              = GetComponent <SpawnPlatform> ();
        curPower        = 0;
        powerObjectFabs = new GameObject[powerCount];
        powerObjectActs = new GameObject[powerCount];
        //adds the textures for each power
        //will be modified as powers are added so that the sprite will be pulled directly from the power rather than loaded

        loadPowers();

        sP.setRealPlatform(powerObjectActs [curPower]);


        Vector3 powerPosition = Vector3.zero;
        //Just attatch the sprites and scripts to the object itself, doing it in a script makes no sense

        /*
         * //adds the corresponding sprites to the powerObjects
         * powerObjects [0] = setPowerSprite (powerObjects [0], sprite0);
         * powerObjects [1] = setPowerSprite (powerObjects [1], sprite1);
         * powerObjects [2] = setPowerSprite (powerObjects [2], sprite2);
         * powerObjects [3] = setPowerSprite (powerObjects [3], sprite3);
         * powerObjects [4] = setPowerSprite (powerObjects [4], sprite4);
         */

        /*This loop should be unnessecary, object properties are in the prefabs.
         * for(int i = 0; i < powerCount; i++) {
         *      /*
         *      //add spri	tes to gameObjects so they can be rendered on screen
         *      GameObject powerObject = powerObjects[i];
         *      powerObject.AddComponent<Image>();
         *      Image image = powerObject.GetComponent <Image> ();
         *
         *      //edit John R
         *      //GameObject powerObject = Instantiate (powerObjectFabs[i]) as GameObject;
         *      //Image image = powerObject0.AddComponent<Image>();
         *      //image.sprite = powerObjects [i].GetComponent <Image> ().sprite;
         *      ///end edit
         *
         *      //image.sprite = powerObject.GetComponent <SpriteRenderer> ().sprite;
         *      //make the PowerSelectionMenu the parent of the power
         *
         *      //powerObjects[i].transform.SetParent (selectorObject.transform);
         *      //powerObjects [i].transform.localPosition = powerPosition;
         *      //posistion the powerSprite relavitve to PowerSelectionMenu
         *      //powerObject.transform.localPosition = powerPosition;
         *      //only showing one power at a time:
         *      //powerPosition.x -= 100;
         *      //adjust the scale of each sprite
         *      //powerObjects[i].transform.localScale = new Vector3(1f, 1f, 1f);
         *      //add to the array of powerObjects
         * }
         */

        //sP.setRealPlatform (powerObjects [0]);
        //assigning a power script to power
        //add the spawn platform script to the first power
    }
Example #4
0
 void Start()
 {
     platformScript = Camera.main.GetComponent <SpawnPlatform>();
 }
Example #5
0
    // Update is called once per frame
    void Update()
    {
        //updating the start position
        StartingPos = new Vector3(col.position.x, 0.75f, col.position.z);


        //basic movement (automatic)
        transform.Translate(Vector3.forward * 8f * Time.deltaTime);


        // updating the playtime for point system and putting the text in right place and format
        PlayTime  += Time.deltaTime;
        Score.text = "score: " + points;
        string lastTime = string.Format("{0}:{1:00}", (int)PlayTime / 60, (int)PlayTime % 60);

        time.text = "Time: " + lastTime;

        // variable for rotation when using a/d or arrows
        var x = Input.GetAxis("Horizontal");

        // if statement, so only movement and/or jump when grounded
        if (grounded)
        {
            //rotate
            transform.Rotate(Vector3.up * x * 150f * Time.deltaTime);

            //jump
            if (Input.GetKeyDown(KeyCode.Space))
            {
                Boing.Play();
                Ball.AddForce(Vector3.up * Ball.mass * 400f);
                grounded = false;
            }
        }

        //fall motion logic
        if (Ball.velocity.y < 0)
        {
            Ball.velocity += Vector3.up * Physics.gravity.y * (fallMultiplier - 1) * Time.deltaTime;
        }
        else if (Ball.velocity.y > 0 && !Input.GetKey(KeyCode.Space))
        {
            Ball.velocity += Vector3.up * Physics.gravity.y * (lowJumpMultiplier - 1) * Time.deltaTime;
        }

        // if statement where, if Ball comes under certain place it loses a life,
        // gets placed in the starting position with original rotation and velocity.
        // time get turned off for countDown.
        if (Ball.position.y <= -5f)
        {
            Lives.HP--;
            transform.position         = StartingPos;
            transform.localEulerAngles = Vector3.zero;
            Ball.velocity       = Vector3.zero;
            Ball.freezeRotation = true;
        }

        //if dead
        if (Lives.HP <= 0)
        {
            SpawnPlatform.Destroy();
            Lives.HP                   = 3f;
            points                     = 0f;
            transform.position         = FirstPos;
            transform.localEulerAngles = Vector3.zero;
            Ball.velocity              = Vector3.zero;
            Ball.freezeRotation        = true;
            PlayTime                   = 0;
            Time.timeScale             = 0f;
            CountDown.counter          = 3f;
        }
    }