Beispiel #1
0
    // Orient for objects relative to parent
    public virtual void Orient(PlatformObject parent, Vector3 position, Quaternion rotation)
    {
        thisTransform.parent = parent.GetTransform();
        Vector3 pos    = Vector3.zero;
        float   yAngle = rotation.eulerAngles.y;

        pos.Set(startPosition.x * Mathf.Cos(yAngle * Mathf.Deg2Rad) + startPosition.z * Mathf.Sin(yAngle * Mathf.Deg2Rad), startPosition.y,
                -startPosition.x * Mathf.Sin(yAngle * Mathf.Deg2Rad) + startPosition.z * Mathf.Cos(yAngle * Mathf.Deg2Rad));
        pos += position;
        thisTransform.localPosition = parent.GetTransform().InverseTransformPoint(pos);
        thisTransform.rotation      = startRotation;
        thisTransform.Rotate(0, rotation.eulerAngles.y, 0, Space.World);
    }
Beispiel #2
0
        public Vector3 GetTurnOffset()
        {
            // add an offset so the character is always in the correct slot after a turn
            PlatformObject topPlatform      = infiniteObjectHistory.GetTopInfiniteObject(ObjectLocation.Center, false) as PlatformObject;
            Vector3        offset           = Vector3.zero;
            Vector3        position         = topPlatform.GetTransform().position;
            int            topPlatformIndex = infiniteObjectHistory.GetLastLocalIndex(ObjectLocation.Center, ObjectType.Platform);
            Quaternion     lookRotation     = Quaternion.LookRotation(spawnDirection);

            offset.x = (position.x + platformStartPosition[topPlatformIndex].x * (spawnDirection.z > 0 ? -1 : 1)) * -Mathf.Cos(lookRotation.eulerAngles.y * Mathf.Deg2Rad) * (spawnDirection.z > 0 ? -1 : 1);
            offset.z = (position.z + platformStartPosition[topPlatformIndex].x * (spawnDirection.x < 0 ? -1 : 1)) * Mathf.Sin(lookRotation.eulerAngles.y * Mathf.Deg2Rad) * (spawnDirection.x < 0 ? -1 : 1);
            return(offset);
        }
Beispiel #3
0
    // returns true if there is still space on the platform for a collidable object to spawn
    private void SpawnCollidable(ObjectType objectType, Vector3 position, Vector3 direction, Direction locationDirection,
                                 PlatformObject platform, int platformLocalIndex, bool activateImmediately)
    {
        int collidablePositions = platform.numCollidables;

        // can't do anything if the platform doesn't accept any collidable object spawns
        if (collidablePositions == 0)
        {
            return;
        }

        Vector3 offset = platformSizes[platformLocalIndex] * 0.1f;
        float   zDelta = platformSizes[platformLocalIndex].z * .8f / (1 + collidablePositions);

        for (int i = 0; i < collidablePositions; ++i)
        {
            if (platform.CanSpawnCollidable(i))
            {
                spawnData.slotPositions = platform.GetSlotsAvailable();
                int localIndex = ObjectPool.instance.GetNextObjectIndex(objectType, spawnData);
                if (localIndex != -1)
                {
                    CollidableObject collidable   = ObjectPool.instance.GetObjectFromPool(localIndex, objectType) as CollidableObject;
                    Quaternion       lookRotation = Quaternion.LookRotation(direction);
                    Vector3          spawnSlot    = collidable.GetSpawnSlot(platform.GetTransform().right *slotDistance, spawnData.slotPositions);
                    collidable.Orient(platform, position + (offset.z + ((i + 1) * zDelta)) * direction + spawnSlot, lookRotation);
                    if (activateImmediately)
                    {
                        collidable.Activate();
                    }

                    int objectIndex = ObjectPool.instance.GetObjectIndexFromLocalIndex(localIndex, objectType);
                    ObjectHistory.instance.ObjectSpawned(objectIndex, (offset.z + ((i + 1) * zDelta)), locationDirection,
                                                         lookRotation.eulerAngles.y, objectType);
                    platform.SpawnCollidable(i);

                    // don't allow any more of the same collidable type if we are forcing a different collidable
                    if (platform.hasDifferentCollidables)
                    {
                        break;
                    }
                }
            }
        }
        spawnData.slotPositions = 0;
    }
    // Turn left or right
    public bool Turn(bool rightTurn)
    {
        // prevent two turns from occurring really close to each other (for example, to prevent a 180 degree turn)
        if (Time.time - turnTime < simultaneousTurnPreventionTime)
        {
            return(false);
        }

        RaycastHit hit;

        // ensure we are over the correct platform
        if (Physics.Raycast(thisTransform.position + colliderCenterOffset, -thisTransform.up, out hit, Mathf.Infinity, platformLayer))
        {
            PlatformObject platform    = null;
            bool           hasPlatform = (platform = hit.transform.GetComponent <PlatformObject>()) != null ||
                                         (platform = hit.transform.parent.GetComponent <PlatformObject>()) != null;
            // update the platform object
            if (hasPlatform && platform != platformObject)
            {
                platformObject = platform;
            }
        }
        bool isAboveTurn = AboveTurn();

        // if we are restricting a turn, don't turn unless we are above a turn platform
        if (restrictTurns && (!isAboveTurn || restrictTurnsToTurnTrigger))
        {
            return(false);
        }

        turnTime = Time.time;
        Vector3 direction = platformObject.GetTransform().right *(rightTurn ? 1 : -1);

        prevTurnOffset    = turnOffset;
        canUpdatePosition = ObjectGenerator.instance.UpdateSpawnDirection(direction, rightTurn, isAboveTurn, out turnOffset);
        targetRotation    = Quaternion.LookRotation(direction);
        curveOffset.x     = (thisTransform.position.x - (startPosition.x + turnOffset.x)) * Mathf.Abs(Mathf.Sin(targetRotation.eulerAngles.y * Mathf.Deg2Rad));
        curveOffset.z     = (thisTransform.position.z - (startPosition.z + turnOffset.z)) * Mathf.Abs(Mathf.Cos(targetRotation.eulerAngles.y * Mathf.Deg2Rad));
        if (isAboveTurn)
        {
            UpdateTargetPosition(targetRotation.eulerAngles.y);
        }

        return(true);
    }
Beispiel #5
0
        // An object run contains many platforms strung together with collidables: obstacles, power ups, and coins. If spawnObjectRun encounters a turn,
        // it will spawn the objects in the correct direction
        public void SpawnObjectRun(bool activateImmediately)
        {
            // spawn the center objects
            InfiniteObject prevPlatform = infiniteObjectHistory.GetTopInfiniteObject(ObjectLocation.Center, false);

            while ((prevPlatform == null || (Vector3.Scale(prevPlatform.GetTransform().position, spawnDirection)).sqrMagnitude < sqrHorizon) && (turnPlatform[(int)ObjectLocation.Center] == null || turnPlatform[(int)ObjectLocation.Center].straight))
            {
                Vector3 position = Vector3.zero;
                if (prevPlatform != null)
                {
                    int prevPlatformIndex = infiniteObjectHistory.GetLastLocalIndex(ObjectLocation.Center, ObjectType.Platform);
                    position = prevPlatform.GetTransform().position - GetPrevPlatformStartPosition(prevPlatform, prevPlatformIndex, spawnDirection) + platformSizes[prevPlatformIndex].z / 2 * spawnDirection + platformSizes[prevPlatformIndex].y * Vector3.up;
                }
                PlatformObject platform = SpawnObjects(ObjectLocation.Center, position, spawnDirection, activateImmediately);

                if (platform == null)
                {
                    return;
                }

                PlatformSpawned(platform, ObjectLocation.Center, spawnDirection, activateImmediately);
                prevPlatform = infiniteObjectHistory.GetTopInfiniteObject(ObjectLocation.Center, false);

                if (spawnFullLength)
                {
                    SpawnObjectRun(activateImmediately);
                }
            }

            // spawn the left and right objects
            if (turnPlatform[(int)ObjectLocation.Center] != null)
            {
                Vector3 turnDirection = turnPlatform[(int)ObjectLocation.Center].GetTransform().right;

                // spawn the platform and scene objects for the left and right turns
                for (int i = 0; i < 2; ++i)
                {
                    ObjectLocation location = (i == 0 ? ObjectLocation.Right : ObjectLocation.Left);

                    bool canSpawn = (location == ObjectLocation.Right && turnPlatform[(int)ObjectLocation.Center].rightTurn) ||
                                    (location == ObjectLocation.Left && turnPlatform[(int)ObjectLocation.Center].leftTurn);
                    if (canSpawn && turnPlatform[(int)location] == null)
                    {
                        prevPlatform = infiniteObjectHistory.GetTopInfiniteObject(location, false);
                        if (prevPlatform == null || (Vector3.Scale(prevPlatform.GetTransform().position, turnDirection)).sqrMagnitude < sqrHorizon)
                        {
                            infiniteObjectHistory.SetActiveLocation(location);
                            Vector3 position = Vector3.zero;
                            if (prevPlatform != null)
                            {
                                int prevPlatformIndex = infiniteObjectHistory.GetLastLocalIndex(location, ObjectType.Platform);
                                position = prevPlatform.GetTransform().position - GetPrevPlatformStartPosition(prevPlatform, prevPlatformIndex, turnDirection) +
                                           platformSizes[prevPlatformIndex].z / 2 * turnDirection + platformSizes[prevPlatformIndex].y * Vector3.up;
                            }
                            else
                            {
                                PlatformObject centerTurn      = turnPlatform[(int)ObjectLocation.Center];
                                int            centerTurnIndex = turnIndex[(int)ObjectLocation.Center];
                                position = centerTurn.GetTransform().position - platformStartPosition[centerTurnIndex].x * turnDirection - Vector3.up * platformStartPosition[centerTurnIndex].y -
                                           platformStartPosition[centerTurnIndex].z * spawnDirection + centerTurn.centerOffset.x * turnDirection + centerTurn.centerOffset.z * spawnDirection +
                                           platformSizes[centerTurnIndex].y * Vector3.up;
                            }

                            PlatformObject platform = SpawnObjects(location, position, turnDirection, activateImmediately);
                            if (platform == null)
                            {
                                return;
                            }

                            PlatformSpawned(platform, location, turnDirection, activateImmediately);
                        }
                    }
                    turnDirection *= -1;
                }

                // reset
                infiniteObjectHistory.SetActiveLocation(ObjectLocation.Center);
            }
        }
Beispiel #6
0
    // Spawn objects
    public void SpawnObjects(bool activateImmediately)
    {
        // Spawn objects in center direction
        BasicObject prevPlatform          = ObjectHistory.instance.GetTopObject(Direction.Center, IS_PLATFORM);
        bool        isWithinSpawnDistance = prevPlatform == null ||
                                            Vector3.Scale(prevPlatform.GetTransform().position, spawnDirection).sqrMagnitude < sqrHorizon;
        bool hasStraightPath = turnPlatform[(int)Direction.Center] == null || (turnPlatform[(int)Direction.Center].isStraight);

        while (isWithinSpawnDistance && hasStraightPath)
        {
            Vector3 position = Vector3.zero;
            if (prevPlatform != null)
            {
                int prevPlatformIndex = ObjectHistory.instance.GetLastLocalIndex(Direction.Center, ObjectType.Platform);
                position = prevPlatform.GetTransform().position
                           - GetPrevPlatformStartPosition(prevPlatform, prevPlatformIndex, spawnDirection)
                           + platformSizes[prevPlatformIndex].z / 2 * spawnDirection
                           + platformSizes[prevPlatformIndex].y * Vector3.up;
            }
            PlatformObject platform = SpawnPlatformAndCollidables(Direction.Center, position, spawnDirection, activateImmediately);

            if (platform == null)
            {
                return;
            }

            SpawnSceneForPlatform(platform, Direction.Center, spawnDirection, activateImmediately);
            prevPlatform = ObjectHistory.instance.GetTopObject(Direction.Center, IS_PLATFORM);

            // Refresh conditions
            isWithinSpawnDistance = prevPlatform == null ||
                                    Vector3.Scale(prevPlatform.GetTransform().position, spawnDirection).sqrMagnitude < sqrHorizon;
            hasStraightPath = turnPlatform[(int)Direction.Center] == null || turnPlatform[(int)Direction.Center].isStraight;
        }

        // Spawn objects in the left and right direction
        if (turnPlatform[(int)Direction.Center] != null)
        {
            Vector3 turnDirection = turnPlatform[(int)Direction.Center].GetTransform().right;

            // spawn the platform and scene objects for the left and right turns
            for (int i = 0; i < 2; ++i)
            {
                Direction location = (i == 0 ? Direction.Right : Direction.Left);

                bool canSpawn = (location == Direction.Right && turnPlatform[(int)Direction.Center].isRightTurn) ||
                                (location == Direction.Left && turnPlatform[(int)Direction.Center].isLeftTurn);
                if (canSpawn && turnPlatform[(int)location] == null)
                {
                    prevPlatform          = ObjectHistory.instance.GetTopObject(location, IS_PLATFORM);
                    isWithinSpawnDistance = prevPlatform == null ||
                                            Vector3.Scale(prevPlatform.GetTransform().position, turnDirection).sqrMagnitude < sqrHorizon;
                    if (isWithinSpawnDistance)
                    {
                        ObjectHistory.instance.SetActiveDirection(location);
                        Vector3 position = Vector3.zero;
                        if (prevPlatform != null)
                        {
                            int prevPlatformIndex = ObjectHistory.instance.GetLastLocalIndex(location, ObjectType.Platform);
                            position = prevPlatform.GetTransform().position
                                       - GetPrevPlatformStartPosition(prevPlatform, prevPlatformIndex, turnDirection)
                                       + platformSizes[prevPlatformIndex].z / 2 * turnDirection
                                       + platformSizes[prevPlatformIndex].y * Vector3.up;
                        }
                        else
                        {
                            PlatformObject centerTurn      = turnPlatform[(int)Direction.Center];
                            int            centerTurnIndex = platformTurnIndex[(int)Direction.Center];
                            position = centerTurn.GetTransform().position
                                       - platformStartPositions[centerTurnIndex].x * turnDirection
                                       - Vector3.up * platformStartPositions[centerTurnIndex].y
                                       - platformStartPositions[centerTurnIndex].z * spawnDirection
                                       + centerTurn.centerOffset.x * turnDirection + centerTurn.centerOffset.z * spawnDirection
                                       + platformSizes[centerTurnIndex].y * Vector3.up;
                        }

                        PlatformObject platform = SpawnPlatformAndCollidables(location, position, turnDirection, activateImmediately);
                        if (platform == null)
                        {
                            return;
                        }

                        SpawnSceneForPlatform(platform, location, turnDirection, activateImmediately);
                    }
                }
                turnDirection *= -1;
            }

            // Reset
            ObjectHistory.instance.SetActiveDirection(Direction.Center);
        }
    }
Beispiel #7
0
        // Turn left or right
        public bool Turn(bool rightTurn, bool fromInputManager)
        {
            // prevent two turns from occurring really close to each other (for example, to prevent a 180 degree turn)
            if (Time.time - turnTime < simultaneousTurnPreventionTime)
            {
                return(false);
            }

            RaycastHit hit;

            // ensure we are over the correct platform
            if (Physics.Raycast(thisTransform.position + capsuleCollider.center, -thisTransform.up, out hit, Mathf.Infinity, platformLayer))
            {
                PlatformObject platform = null;
                // update the platform object
                if (((platform = hit.transform.GetComponent <PlatformObject>()) != null) || ((platform = hit.transform.parent.GetComponent <PlatformObject>()) != null))
                {
                    if (platform != platformObject)
                    {
                        platformObject = platform;
                        CheckForCurvedPlatform();
                    }
                }
            }
            bool isAboveTurn = AbovePlatform(true);

            // if we are restricting a turn, don't turn unless we are above a turn platform
            if (restrictTurns && (!isAboveTurn || restrictTurnsToTurnTrigger))
            {
                if (fromInputManager)
                {
                    turnRequestTime  = Time.time;
                    turnRightRequest = rightTurn;
                    return(false);
                }

                if (!powerUpManager.IsPowerUpActive(PowerUpTypes.Invincibility) && !powerUpManager.IsPowerUpActive(PowerUpTypes.SpeedIncrease) && !autoTurn && !WithinReviveGracePeriod())
                {
                    // turn in the direction that the player swiped
                    rightTurn = turnRightRequest;

                    // don't turn if restrict turns is on and the player hasn't swipped within the grace period time or if the player isn't above a turn platform
                    if (!gameManager.godMode && (Time.time - turnRequestTime > turnGracePeriod || !isAboveTurn))
                    {
                        return(false);
                    }
                }
            }
            else if (!fromInputManager && !autoTurn && !gameManager.godMode && (!restrictTurns || Time.time - turnRequestTime > turnGracePeriod) &&
                     !powerUpManager.IsPowerUpActive(PowerUpTypes.Invincibility) && !powerUpManager.IsPowerUpActive(PowerUpTypes.SpeedIncrease) &&
                     !WithinReviveGracePeriod())
            {
                return(false);
            }

            turnTime = Time.time;
            Vector3 direction = platformObject.GetTransform().right *(rightTurn ? 1 : -1);

            prevTurnOffset    = turnOffset;
            canUpdatePosition = infiniteObjectGenerator.UpdateSpawnDirection(direction, platformObject.curveLength == 0, rightTurn, isAboveTurn, out turnOffset);
            if (canUpdatePosition && platformObject.curveLength > 0)
            {
                followCurve = true;
            }
            else
            {
                targetRotation = Quaternion.LookRotation(direction);
                curveOffset.x  = (thisTransform.position.x - (startPosition.x + turnOffset.x)) * Mathf.Abs(Mathf.Sin(targetRotation.eulerAngles.y * Mathf.Deg2Rad));
                curveOffset.z  = (thisTransform.position.z - (startPosition.z + turnOffset.z)) * Mathf.Abs(Mathf.Cos(targetRotation.eulerAngles.y * Mathf.Deg2Rad));
                if (isAboveTurn)
                {
                    UpdateTargetPosition(targetRotation.eulerAngles.y);
                }
            }
            return(true);
        }