コード例 #1
0
    public OrbitMath.OrbitPrediction DynamicPrediction(OrbitMath.OrbitPrediction prediction, float mass = 1)
    {
        //Set Prediction to this type
        prediction.ChangeSystem(this);

        //Outside of system
        if (prediction.localPosition.magnitude > radiusOfInfluence && parentSystem)
        {
            return(parentSystem.DynamicPrediction(prediction, mass));
        }

        //Inside of child system
        foreach (GravitySystem childSystem in childSystems)
        {
            if (childSystem.IsInSystem(prediction.time, prediction.localPosition))
            {
                return(childSystem.DynamicPrediction(prediction, mass));
            }
        }

        //Calculate Gravity
        prediction.localGravity = TotalGravity(prediction.time, prediction.localPosition, mass);

        return(prediction);
    }
コード例 #2
0
    public void DrawPathA(OrbitMath.OrbitPrediction[] predictions, int curI, int maxI)
    {
        OrbitMath.OrbitPrediction enterPrediction = predictions[curI];
        Vector2 lastPosition = enterPrediction.gravitySystem.PointToWorld(enterPrediction.time, enterPrediction.localPosition);
        int     switches     = 0;

        for (int steps = 0; steps < ModuloDistance(curI, maxI, predictions.Length) - 1; steps++)
        {
            int i     = (steps + curI) % predictions.Length;
            int prevI = (i - 1 + predictions.Length) % predictions.Length;

            if (predictions[prevI].gravitySystem != predictions[i].gravitySystem)
            {
                enterPrediction = predictions[i];
                switches++;

                if (switches > 1)
                {
                    break;
                }
            }

            Vector2 worldPositionL = enterPrediction.gravitySystem.PointToWorld(enterPrediction.time, predictions[i].localPosition);
            Vector2 worldPositionW = enterPrediction.gravitySystem.PointToWorld(predictions[i].time, predictions[i].localPosition);
            Vector2 worldPosition  = showLocal ? worldPositionL : worldPositionW;
            if (predictions[prevI].gravitySystem == predictions[i].gravitySystem)
            {
                Debug.DrawLine(lastPosition, worldPosition, enterPrediction.gravitySystem.renderer.color);
            }
            lastPosition = worldPosition;
        }
    }
コード例 #3
0
    public void FixedUpdate()
    {
        //Predict path
        int currentPredictionCount = ModuloDistance(currentIndex, maxIndex, predictions.Length);
        int newPredictionCount     = Mathf.Max(100 - currentPredictionCount, 10);

        if (ModuloDistance(currentIndex, maxIndex, predictions.Length) < predictions.Length - newPredictionCount - 2)
        {
            predictions = PredictPath(predictions, maxIndex, newPredictionCount);
            maxIndex    = (maxIndex + newPredictionCount) % predictions.Length;
        }

        //
        currentIndex = (currentIndex + 1) % predictions.Length;
        OrbitMath.OrbitPrediction prediction = predictions[currentIndex];

        transform.parent        = prediction.gravitySystem.transform;
        transform.localPosition = prediction.localPosition;

        DrawPath(predictions, currentIndex, maxIndex);


        Grapher.Log(prediction.localGravity.magnitude, "Gravity", prediction.time);
        Grapher.Log(prediction.localGravity.magnitude, prediction.gravitySystem.name, prediction.gravitySystem.renderer.color, prediction.time);
    }
コード例 #4
0
    public void PretendAddVelocity(Vector2 velocity)
    {
        OrbitMath.OrbitPrediction[] path = new OrbitMath.OrbitPrediction[500];
        path[0] = predictions[currentIndex].Clone();
        path[0].localVelocity += velocity;

        path = PredictPath(path, 0, 499);
        DrawPath(path, 0, 499);
    }
コード例 #5
0
        public void ChangeSystem(GravitySystem newSystem)
        {
            // Same System
            if (gravitySystem == newSystem)
            {
                return;
            }

            if (!newSystem)
            {
                return;
            }

            OrbitPrediction newSystemPrediction = newSystem.GetPrediction(time);

            // From World Space
            if (!gravitySystem)
            {
                if (!newSystem.parentSystem)
                {
                    //Sun
                    gravitySystem = newSystem;
                    return;
                }
                else
                {
                    //
                    localPosition -= newSystemPrediction.localPosition;
                    localVelocity -= newSystemPrediction.localVelocity;
                    gravitySystem  = newSystem;
                    return;
                }
            }

            // From ParentSystem
            if (gravitySystem == newSystem.parentSystem)
            {
                localPosition -= newSystemPrediction.localPosition;
                localVelocity -= newSystemPrediction.localVelocity;
                gravitySystem  = newSystem;
                return;
            }
            // From Child System
            if (gravitySystem.parentSystem = newSystem)
            {
                OrbitMath.OrbitPrediction childPrediction = gravitySystem.GetPrediction(time);
                localPosition += childPrediction.localPosition;
                localVelocity += childPrediction.localVelocity;
                gravitySystem  = newSystem;

                return;
            }

            gravitySystem = newSystem;
        }
コード例 #6
0
 public Vector2 PointFromParentSystem(float time, Vector2 localPosition)
 {
     OrbitMath.OrbitPrediction prediction = GetPrediction(time);
     if (parentSystem)
     {
         return(localPosition - prediction.localPosition);
     }
     else
     {
         return(localPosition);
     }
 }
コード例 #7
0
 public Vector2 PointToWorld(float time, Vector2 localPosition)
 {
     OrbitMath.OrbitPrediction prediction = GetPrediction(time);
     if (parentSystem)
     {
         return(parentSystem.PointToWorld(time, localPosition + prediction.localPosition));
     }
     else
     {
         return(localPosition);
     }
 }
コード例 #8
0
    public void Start()
    {
        if (startPrediction != null && startPrediction.gravitySystem)
        {
            startPrediction.localPosition = startPrediction.gravitySystem.PointToSystem(0, transform.position);
        }

        predictions = new OrbitMath.OrbitPrediction[predictionCount];
        for (int i = 0; i < predictions.Length; i++)
        {
            predictions[i] = new OrbitMath.OrbitPrediction();
        }
        predictions[0] = startPrediction;
    }
コード例 #9
0
    public OrbitMath.OrbitPrediction CalculateNextPrediction(OrbitMath.OrbitPrediction currentPrediction)
    {
        OrbitMath.OrbitPrediction nextPrediction = currentPrediction.Clone();


        float deltaTime = Time.fixedDeltaTime;

        nextPrediction.time          += deltaTime;
        nextPrediction.localVelocity += nextPrediction.localGravity * deltaTime;
        nextPrediction.localPosition += nextPrediction.localVelocity * deltaTime;

        //TODO Collision

        nextPrediction = nextPrediction.gravitySystem.DynamicPrediction(nextPrediction, mass);

        return(nextPrediction);
    }
コード例 #10
0
    public Vector2 RelativeTimePositionToWorld(OrbitMath.OrbitPrediction curPrediciton, List <OrbitMath.OrbitPrediction> entryPredictions)
    {
        if (curPrediciton.gravitySystem.parentSystem == null)
        {
            return(curPrediciton.localPosition);
        }

        foreach (OrbitMath.OrbitPrediction entryPred in entryPredictions)
        {
            if (curPrediciton.gravitySystem == entryPred.gravitySystem)
            {
                Vector2 relativePosition = entryPred.gravitySystem.PointToParentSystem(entryPred.time, curPrediciton.localPosition);
                OrbitMath.OrbitPrediction relativePred = new OrbitMath.OrbitPrediction(curPrediciton.time, relativePosition, curPrediciton.localVelocity);
                relativePred.gravitySystem = entryPred.gravitySystem.parentSystem;
                return(RelativeTimePositionToWorld(relativePred, entryPredictions));
            }
        }
        return(curPrediciton.gravitySystem.PointToWorld(entryPredictions[0].time, curPrediciton.localPosition));
    }
コード例 #11
0
    public void DrawPath(OrbitMath.OrbitPrediction[] predictions, int curI, int maxI)
    {
        // Predictions in the same system are calculated relative to their entry points!
        List <OrbitMath.OrbitPrediction> entryPredictions = new List <OrbitMath.OrbitPrediction>();
        Vector2 lastPosition = predictions[curI].gravitySystem.PointToWorld(predictions[curI].time, predictions[curI].localPosition);

        for (int steps = 0; steps < ModuloDistance(curI, maxI, predictions.Length) - 1; steps++)
        {
            //Get Index
            int i     = (steps + curI) % predictions.Length;
            int prevI = (i - 1 + predictions.Length) % predictions.Length;

            // Current Prediction
            OrbitMath.OrbitPrediction curPrediction = predictions[i];
            // Find Relative entry Predicion
            OrbitMath.OrbitPrediction entryPrediction = null;
            foreach (OrbitMath.OrbitPrediction pred in entryPredictions)
            {
                if (pred.gravitySystem == curPrediction.gravitySystem)
                {
                    entryPrediction = pred;
                }
            }
            // No entry Prediction Found
            if (entryPrediction == null)
            {
                entryPrediction = curPrediction;
                entryPredictions.Add(curPrediction);
            }

            // Get Relative Position
            Vector2 relativePosition = RelativeTimePositionToWorld(curPrediction, entryPredictions);
            if (predictions[prevI].gravitySystem == predictions[i].gravitySystem)
            {
                Debug.DrawLine(lastPosition, relativePosition, curPrediction.gravitySystem.renderer.color);
            }
            lastPosition = relativePosition;
        }
    }
コード例 #12
0
 public void FixedUpdate()
 {
     OrbitMath.OrbitPrediction prediction = OrbitMath.GetStaticOrbitPrediction(Time.time, this);
     transform.localPosition = prediction.localPosition;
 }