Comments and answers for "[MATH] Vectors, magnitudes, and bears; Oh My! -Solved"
http://answers.unity.com/questions/895234/math-vectors-magnitudes-and-bears-oh-my.html
The latest comments and answers for the question "[MATH] Vectors, magnitudes, and bears; Oh My! -Solved"Answer by karma0413
http://answers.unity.com/answers/895810/view.html
#The Solution:
1. While I was testing the variables, I was working in the wrong section of code. This helped contribute to the problem because I was always in a case where I wouldn't see the changes. /BONK
2. Additionally, the other folks replying to my problem were in fact correct about the Debug.DrawRay. While, I thought I had enough drawRays on the screen; I actually was not showing the resulting drawRay each time I did a calculation and therefore was not completely understanding the processes taking place.
3. My calculations were in fact correct, and I haven't changed them. Well except for one minor problem. When I originally did the COUNTER-CLOCKWISE script. I did the inverse calculation of the result after all the changes. More correctly, when I do counter-clockwise I simply needed the INVERSE of the (LeftHand Rule) resulting vector. Now the mathematical inverse is done in the right location.
4. And to finally answer my own original question:**YES,**: When you do an addition between two different Vector3 directions. Their magnitudes will automatically weight it's direction. So we can see here in the updated code I provide now:
We can see to obtain, the left-hand rule calculation ( this is called Cross Product multiplication ) we do the following:
if (orbitDirection == 1) // NORMAL CLOCK-WISE
{
// *** WARNING *** Unity uses the LEFT HAND RULE: http://docs.unity3d.com/ScriptReference/Vector3.Cross.html
Vector3 a = myTarget.transform.position - this.transform.position;
Vector3 b = this.transform.up;
Vector3 c = Vector3.Cross (a,b);
vectorTwo = c;
We already had VectorOne - which was simply go ( towards) or ( awayfrom ) depending if we were shallow of the orbiting optimal range, or if we had exceeded. And now we just found vectorTwo above.
The next thing to do was to define the strengths of each of these Vectors. For example if my optimal orbitting range is 400meters. Then I stated that if the ship was within 80% of that, then lets use this smoothed-navigation-guidance code as below:
float upperEndRange = optimalRange + (optimalRange * 0.80f);
float lowerEndRange = optimalRange - (optimalRange * 0.80f);
And Now we just simply find out the strengths. And to find out how much strength each vector gets; we define it in terms of 100% of how close or far we are from our optimal range. A float number that is between 0-100. [EDIT NOTE:] I could have simply divided the final result by/100 to get a number between 0-1.0. But I found it wasn't needed when computing the final destination direction.
tempStrength : is how much strength to go (towards) or (awayfrom) the target we are orbitting. Obviously is we are closer to the 80% limit on this. then tempStrength will be very near 100
cStrength : is the strength of the tangent Vector that is perpendicular to the object we are orbitting. And as a DIRECT-INVERSE-RELATIONSHIP ; whatever % of 100% is left from tempstrength. we can give it to cStrength. So the closer we are to our optimal range ; then the more cStrength = 100, and our tempStrength becomes close to 0.0
tempStrength = Mathf.Abs (optimalRange - distanceToTarget);
float ratio = 100/ (optimalRange - lowerEndRange); // so here is how we got that ratio multiplyer number... By basically putting it in an aspect in terms of percentage. /100
tempStrength = tempStrength * ratio; // .4166 ONLY if the upper end is 20% of 400 and lower end is 20% of 400, how did we get this number though...Explained one line up..
cStrength = 100 - tempStrength;
//vectorOne = vectorOne.normalized;
vectorOne = vectorOne * tempStrength;
//vectorTwo = vectorTwo.normalized;
vectorTwo = vectorTwo * cStrength;
tempDirection = vectorOne + vectorTwo;
Very Lastly: To find the COUNTER-CLOSEWISE... As I mentioned we just plug in the Inverse of Vector C; which was (looking back), the RESULT of a CrossProduct between Vector a and Vector b. So Now instead of facing LEFT-HAND... we actually turn right and go counter-clockwise (IF WE ARE FACING THE OBJECT)
if (orbitDirection == -1) //ACTUALLY COUNTER-CLOCKWISE
{
Vector3 a = myTarget.transform.position - this.transform.position;
Vector3 b = this.transform.up;
Vector3 c = Vector3.Cross (a,b);
vectorTwo = -c;
float tempStrength;
float cStrength;
tempStrength = Mathf.Abs (optimalRange - distanceToTarget);
float ratio = 100/ (optimalRange - lowerEndRange); // so here is how we got that ratio multiplyer number... By basically putting it in an aspect in terms of percentage. /100
tempStrength = tempStrength * ratio; // .4166 ONLY if the upper end is 20% of 400 and lower end is 20% of 400, how did we get this number though...Explained one line up..
cStrength = 100 - tempStrength;
//vectorOne = vectorOne.normalized;
vectorOne = vectorOne * tempStrength;
//vectorTwo = vectorTwo.normalized;
vectorTwo = vectorTwo * cStrength;
tempDirection = vectorOne + vectorTwo;
//tempDirection = tempDirection;
}
#Oooh, it's fancy, huh?
I figured you all might appreciate a screenshot of the result:
**Do: Control+MouseWheel to zoom into all of its fine glory!**
![alt text][1]
[1]: http://i.share.pho.to/513ff37e_o.pngSat, 07 Feb 2015 14:45:16 GMTkarma0413Comment by tanoshimi on tanoshimi's answer
http://answers.unity.com/comments/895789/view.html
No, I'm assuming that you wanted to calculate the distance from your current point to your ideal orbit position, not to the centre of the planet.Sat, 07 Feb 2015 13:26:33 GMTtanoshimiComment by karma0413 on karma0413's answer
http://answers.unity.com/comments/895772/view.html
Thank you for the time to reply. These mathematical problems scare alot of helpers away :)
I actually went through and reviewed my formuation. The solution you provide will return a DIRECTION with $$anonymous$$agnitude between 2 points. I actually want to find only a FLOAT distance.
According to this website: [$$anonymous$$ATH IS FUN][1]
[1]: http://www.mathsisfun.com/algebra/distance-2-points.html
To obtain the difference between two points in 3d space (Vector3s):
//xd = x2-x1
//yd = y2-y1
//zd = z2-z1
//Distance = SquareRoot(xd*xd + yd*yd + zd*zd)
I simply add in a radius prior to the calculation so that it weighted with the radius. In other words; because my planets and sun already have a collider on them with a "radius"... I just take that radius amount = 0.5 and I weight this distance with that.
Thanks for taking a look, let me know if I missed something else.
**EDIT:**
Actually upon closer inspection of your code. I realized that Unity already has a distance function between two 3D points in space. But, I think you meant this in your code, right?:
Vector3 targetPos = myTarget.transform.position;
Vector3 result = Vector3.Distance(this.transform.position, targetPos);Sat, 07 Feb 2015 12:39:25 GMTkarma0413Answer by tanoshimi
http://answers.unity.com/answers/895641/view.html
Haven't studied in detail, but at first glance this looks wrong to me:
float calcX = (this.transform.position.x - myTarget.transform.position.x) - myTargetsRadius;
float calcY = (this.transform.position.y - myTarget.transform.position.y) - myTargetsRadius;
float calcZ = (this.transform.position.z - myTarget.transform.position.z) - myTargetsRadius;
distanceToTarget = Mathf.Sqrt (calcX*calcX + calcY*calcY + calcZ*calcZ);
Did you not mean:
Vector3 calc = (this.transform.position - myTarget.transform.position).normalized * myTargetsRadius;
distanceToTarget = Vector3.Distance(this.transform.position, calc);
?
But agree with the other commenters - use Debug.Log and OnDrawGizmos to test what values your code is producing/plot them visually in the scene view.Sat, 07 Feb 2015 07:32:03 GMTtanoshimiComment by Owen-Reynolds
http://answers.unity.com/comments/895605/view.html
"addition between two Vector3s keep in mind the $$anonymous$$agnitude"?
No. It's simple pairwise addition. (0,0,1) + (0,1,1) is (0,1,2). $$anonymous$$athematically, it's simply starting the 2nd vector at the tip of the first. The result is purposely not normalized (but you can do it yourself, if needed.)Sat, 07 Feb 2015 05:22:12 GMTOwen-ReynoldsComment by karma0413
http://answers.unity.com/comments/895498/view.html
Thanks to both, I did as both of you suggested and changed around some of the variables so they stay separated. And the (firstVector) in part3, does correctly point awayfrom OR towards the target... and the (secondvector) does correctly point in the LEFT-HAND RULE....
but, the resulting addition vector seems to be erratic. I will continue to research.
But since you both decided to reply to a $$anonymous$$ATH question; I would assume you may know what your talking about. Does a resulting addition between two Vector3s keep in mind the $$anonymous$$agnitude? Furthermore, would that result vector be scewed/ or weighted by the magnitude of the other vector in this addition scenario?Fri, 06 Feb 2015 23:26:18 GMTkarma0413Comment by Owen-Reynolds
http://answers.unity.com/comments/895487/view.html
To second Baste, this sort of thing always comes down to some number you think you should get, and what you're really getting, are different; or realizing your math was just wrong.
If you have to, make tiny red, green, blue balls/lines and position them to represent each thing you're computing. Hand-compute #'s for one case. Then, in code, snap the object there and print those numbers.
At the very least, you'll get down to a command not doing what you think it should, and being able to ask about that one thing.Fri, 06 Feb 2015 22:52:27 GMTOwen-ReynoldsComment by karma0413
http://answers.unity.com/comments/895482/view.html
It would be more beneficial if you provided me with the mathematical logic, or at a minimum the name of the mathematical function I need to use. I don't mind doing the work, I would rather understand this stuff.Fri, 06 Feb 2015 22:40:33 GMTkarma0413Comment by Baste
http://answers.unity.com/comments/895285/view.html
Try to Debug.Log the tempStrength and cStrength, and see how they evolve as you move the ship closer and further from the point of orbit.
I recently did something very similar to this (wolves circling some prey, but the maths should be similar), and I can post how I did that as an answer if you're interested. It's a completely different idea, though - it's based on rotating the vector from the point of orbit to the orbiter around the point of orbit, and then simply following that.Fri, 06 Feb 2015 18:04:00 GMTBaste