View difference between Paste ID: NPHTYFgv and JqiQLiB6

 //-----------------------------------------------------------------------------
 // Torque Game Engine
 // Copyright (C) GarageGames.com, Inc.
 //-----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------------------------------------------
 // Library Functions v2.1
 //----------------------------------------------------------------------------------------------------------------
 // These are nifty lil functions that are usefull for other things then solely supporting the functions they
 // were written to help.
 
 //*************************************************************************************
 //torque engine tidbits
 //
 // The rotation value returned for the z axis of an object in torque, is specified by
 // the last 2 words.(it can be made a single value by: getWord(%rot, 2) * getWord(%rot, 3))
 // This value will remain positive until the angle is larger than 4.18879 radians OR 240
 // degrees, any angle larger than this will revert to a negative value.
 // GOing clockwise around the torque compass there are the following degree values...
 //
 // North -  0 deg, 0 Rad
 // East  - 90 deg, 1.5707963 rad
 // South- 180 deg, 3.1415926 rad
 //        240 deg, 4.18879 rad (changeover point, 30 degrees past south)
 // West - 270 deg, -1.5707963 rad (the negative value for due east)
 //
 //  pi = 3.1415926 (3.14159265358979323846)
 // 2pi = 6.2831853 (6.28318530717958647692)
 //
 // Table X degrees = X radians
 //  1d = 0.0174532
 //  5d = 0.0872664
 // 10d = 0.1745329
 // 45d = 0.785398
 // 60d = 1.0471974
 // 90d = 1.5707963
 //180d = 3.1415926
 //
 // when getting a rotation via an objects ID.rotation, the final word of the rotation
 // is in degrees, NOT radians!
 // ID.rotation = x y z amount(in degrees)
 
 
 // getWorldBox returns box.min.x, box.min.y, box.min.z, box.max.x, box.max.y, box.max.z
 // which are two diagonaly opposiing corners of the box
 
 // Just thought someone might find this usefull :D  -Founder
 //*************************************************************************************
 
 //-------------------------------------------------------------------------------------
 // Rotations, positions, vectors, and Matricies OH MY!
 //-------------------------------------------------------------------------------------
 //set some usefull globals
 $Pi = 3.14159;
 $TwoPi = 6.28319;
 
 $North   = 0;
 $NE      = 0.785398; //45
 $East    = 1.5708;   //90
 $SE      = 2.35619;  //135
 $South   = $Pi;      //180
 $SW      = 3.92699;  //225
 $West    = 4.71239;  //270
 $NW      = 5.49779;  //315
 
 //----Vectors----
 
 //this function serves a similar purpose to vectorScale, except instead of scaling it
 //makes the specified vector.length equal to the number provided
 function setVectorLength(%vec, %desiredLength)
 {
    error("setVectorLength vec:" SPC %vec SPC "desiredLength" SPC %desiredLength);
    //this only works if we start with a unit vector so we have the relative valuse for x y and z
    %vecNorm = vectorLen(%vec) > 1 ? vectorNormalize(%vec) : %vec;
 
    // x + y + z = the number to devide the length by in order to get the proper scale by which to
    //multiply the vector elements
    %nl = mAbs(getWord(%vecNorm, 0)) + mAbs(getWord(%vecNorm, 1)) + mAbs(getWord(%vecNorm, 2));
    %scale = %desiredLength / %nl;
    //now vector scale it and send it back
    %newVec = vectorScale(%vecNorm, %scale);
    error("finalVec:" SPC %newVec);
    return %newVec;
 }
 
 //----common transform utilities----
 function posFromRaycast(%transform)
 {
    // the 2nd, 3rd, and 4th words returned from a successful raycast call are the position of the point
    %position = getWord(%transform, 1) SPC getWord(%transform, 2) SPC getWord(%transform, 3);
    return %position;
 }
 
 function normalFromRaycast(%transform)
 {
    // the	5th,	6th and 7th words returned from a successful	raycast call are the normal of the	surface
    %norm = getWord(%transform, 4) SPC getWord(%transform, 5) SPC getWord(%transform, 6);
    return %norm;
 }
 
 // these stay, since having to type %rot = %obj.rotFromTransform(%transform); after already having the transform is
 // just way too much.
 function posFromTransform(%transform)
 {
    // the first three words of an object's transform are the object's position
    %position = getWord(%transform, 0) SPC getWord(%transform, 1) SPC getWord(%transform, 2);
    return %position;
 }
 
 function rotFromTransform(%transform)
 {
    // the last four words of an object's transform are the object's rotation
    %rotation = getWord(%transform, 3) SPC getWord(%transform, 4) SPC getWord(%transform, 5) SPC getWord(%transform, 6);
    return %rotation;
 }
 
 //if we are going to make these inherited functions, might as welllet them get the transform as well
 function SceneObject::posFromTransform(%obj, %transform)
 {
    if(%transform $= "")
       %transform = %obj.getTransForm();
    // the first three words of an object's transform are the object's position
    %position = getWord(%transform, 0) SPC getWord(%transform, 1) SPC getWord(%transform, 2);
    return %position;
 }
 
 function SceneObject::rotFromTransform(%obj, %transform)
 {
    if(%transform $= "")
       %transform = %obj.getTransForm();
    // the last four words of an object's transform are the object's rotation
    %rotation = getWord(%transform, 3) SPC getWord(%transform, 4) SPC getWord(%transform, 5) SPC getWord(%transform, 6);
    return %rotation;
 }
 
 //this finds the terrain height for the position and sets it x meters above the terrain
 function bumpZ(%pos, %heightMod)
 {
    %x = getword(%pos, 0);
    %y = getword(%pos, 1);
    %height = getTerrainHeight(%x SPC %y);
 
    return %x SPC %y SPC %height + %heightMod;
 }
 
 //this function merely zeroes the z of a pos, not used anymore
 function gimpPosition(%pos)
 {
    return getword(%pos, 0) SPC getword(%pos, 1) SPC "0";
 }
 
 function getAngleDifferance(%angleOne, %angleTwo)
 {
    //we need the smallest angle from angle one to angle two
 
    //First ensure both angles are positive
    %angleOne = %angleOne < 0 ? $TwoPi + %angleOne : %angleOne;
    %angleTwo = %angleTwo < 0 ? $TwoPi + %angleTwo : %angleTwo;
 
    %diff = %angleTwo - %angleOne;
 
    %diff = %diff > $Pi ? $TwoPi - %diff : %diff;
    %diff = %diff < -$Pi ? -$TwoPi - %diff : %diff;
 
    return %diff;
 }
 
 //---Directional (compass) functions----
 
 function getClosestCompassTick(%angle)
 {
    %value = "";
 
    %angle = %angle < 0 ? $TwoPi + %angle : %angle;
 
    if(%angle >= mDegToRad(337.5) || %angle < mDegToRad(22.5))
       %value = "North" SPC $North;
    else if(%angle >= mDegToRad(22.5) && %angle < mDegToRad(67.5))
       %value = "NorthEast" SPC $NE;
    else if(%angle >= mDegToRad(67.5) && %angle < mDegToRad(112.5))
       %value = "East" SPC $East;
    else if(%angle >= mDegToRad(112.5) && %angle < mDegToRad(157.5))
       %value = "SouthEast" SPC $SE;
    else if(%angle >= mDegToRad(157.5) && %angle < mDegToRad(202.5))
       %value = "South" SPC $South;
    else if(%angle >= mDegToRad(202.5) && %angle < mDegToRad(247.5))
       %value = "SouthWest" SPC $SW;
    else if(%angle >= mDegToRad(247.5) && %angle < mDegToRad(292.5))
       %value = "West" SPC $West;
    else if(%angle >= mDegToRad(292.5) && %angle < mDegToRad(337.5))
       %value = "NorthWest" SPC $NW;
 
    return %value;
 }
 
 function getClosestCardinal(%angle)
 {
    %value = "";
 
    %angle = %angle < 0 ? $TwoPi + %angle : %angle;
    %angle = %angle > $TwoPi ? %angle - $TwoPi : %angle;
 
    if(%angle >= mDegToRad(315) || %angle < mDegToRad(45))
       %value = "North" SPC $North;
    else if(%angle >= mDegToRad(45) && %angle < mDegToRad(135))
       %value = "East" SPC $East;
    else if(%angle >= mDegToRad(135) && %angle < mDegToRad(225))
       %value = "South" SPC $South;
    else if(%angle >= mDegToRad(225) && %angle < mDegToRad(315))
       %value = "West" SPC $West;
 
 
    //error("getClosestCardinal Value:" SPC %value);
    return %value;
 }
 
 //----angles and rotations----
 
 function invertDegAngle(%angle)
 {
    if(%angle > 0)
       %angle = -(180 - %angle);
    else
       %angle = mAbs(%angle + 180);
 
    return %angle;
 }
 
 function invertAngle(%angle)
 {
    //add pi, then cap
    %angle += $PI;
    %angle = %angle > $TwoPi ? %angle - $TwoPi : %angle;
 
    return %angle;
 }
 
 function getAnglefromRot(%rot)
 {
    //return a positive z angle in radians
    %angle = getWord(%rot, 2) * getWord(%rot, 3);
    %angle = %angle < 0 ? $TwoPi + %angle : %angle;
    return %angle;
 }
 
 function getDegAnglefromRot(%rot)
 {
    //return the rot's z angle in positive degrees
    %angleOne = mRadtoDeg(getWord(%rot, 2) * getWord(%rot, 3));
    %angle = %angleOne < 0 ? 360 + %angleOne : %angleOne;
    return %angle;
 }
 
 function getZangle(%posOne, %posTwo)
 {
    %vec = VectorSub(%posTwo, %posOne);
    //get the angle
    %rotAngleZ = mATan( firstWord(%vec), getWord(%vec, 1) );
    //add pi to the angle
    //%rotAngleZ += $Pi;
 
    //make this rotation a proper torque game value, anything more than 240 degrees is negative
    //if(%rotAngleZ > 4.18879)
       //subtract 2pi from the value, then make sure its positive
      // %rotAngleZ = -(mAbs(%rotAngleZ - $TwoPi));
 
    return %rotAngleZ;
 }
 
 function absRot(%rot)
 {
    %rot = %rot < 0 ? %rot + $TwoPi : %rot;
 
    return %rot;
 }
 
 function adjustRot(%rot, %rotAdjust)
 {
    %angle = getWord(%rot, 2) * getWord(%rot, 3);
    //%rotAdjust = ((%rotAdjust >= 4.18879) ? (($TwoPi - %rotAdjust) * -1) : %rotAdjust);
 
    %rotAdjust = %rotAdjust < 0 ? $TwoPi + %rotAdjust : %rotAdjust;
 
    //now add the angle adjustment to the refrence rot
    %adjust = %angle + %rotAdjust;
    //bring in back in line with the torque world
    %adjust = ((%adjust >= 4.18879) ? (%adjust - $TwoPi) : %adjust);
    //if it's negative we'll stuff it into the vector and leave the angle value unchanged
    %rotZ = ((%adjust >= 0) ? 1 : (-1));
    %adjust = mAbs(%adjust);
    %rot = getWord(%rot, 0) SPC getWord(%rot, 1)  SPC %rotZ SPC %adjust;
    return %rot;
 }
 
 // This lil function generates the rotation required for an object at PosOne to point at PosTwo (z rot only)
 function pointToXYPos(%posOne, %posTwo)
 {
    %vec = VectorSub(%posOne, %posTwo);
    //get the angle
    %rotAngleZ = mATan( firstWord(%vec), getWord(%vec, 1) );
    //add pi to the angle
    %rotAngleZ += $Pi;
 
    //make this rotation a proper torque game value, anything more than 240 degrees is negative
    if(%rotAngleZ > 4.18879)
    {
       //the rotation scale is seldom negative, instead make the axis value negative
       %modifier = -1;
       //subtract 2pi from the value, then make sure its positive
       %rotAngleZ = mAbs(%rotAngleZ - $TwoPi);
       //sigh, if only this were all true
    }
    else
       %modifier = 1;
 
    //assemble the rotation and send it back
    return "0 0" SPC %modifier SPC %rotAngleZ;
 }
 
 // And this lil function generates the rotation required for an object at posOne to
 // point at PosTwo for X, Y And Z axis.
 function pointToPos(%posOne, %posTwo)
 {
    //sub the two positions so we get a vector pointing from the origin in the direction we want our object to face
    %vec = VectorSub(%posTwo, %posOne);
 
    // pull the values out of the vector
    %x = firstWord(%vec);
    %y = getWord(%vec, 1);
    %z = getWord(%vec, 2);
 
    //this finds the distance from origin to our point
    %len = vectorLen(%vec);
 
    //---------X-----------------
    //given the rise and length of our vector this will give us the angle in radians
    %rotAngleX = mATan( %z, %len );
 
    //---------Z-----------------
    //get the angle for the z axis
    %rotAngleZ = mATan( %x, %y );
 
    //create 2 matrices, one for the z rotation, the other for the x rotation
    %matrix = MatrixCreateFromEuler("0 0" SPC %rotAngleZ * -1);
    %matrix2 = MatrixCreateFromEuler(%rotAngleX SPC "0 0");
 
    //now multiply them together so we end up with the rotation we want
    %finalMat = MatrixMultiply(%matrix, %matrix2);
 
    //we're done, send the proper numbers back
    return getWords(%finalMat, 3, 6);
 }
 
 function getXYAngle(%posOne, %posTwo)
 {
    //sub the two positions so we get a vector pointing from the origin in the direction we want our object to face
    %vec = VectorSub(%posTwo, %posOne);
 
    // pull the values out of the vector
    %x = firstWord(%vec);
    %y = getWord(%vec, 1);
    %z = getWord(%vec, 2);
 
    //this finds the distance from origin to our point
    %len = vectorLen(%vec);
 
    //---------XY-----------------
    //given the rise and length of our vector this will give us the angle in radians
    %rotAngleXY = mATan( %z, %len );
    //%rotAngleXY+=$Pi;
    return %rotAngleXY;
 }
 
 function getXYangleFromRot(%rot)
 {
    %a = getWord(%rot, 3);
 
    %x = firstWord(%rot) * %a;
    %y = getWord(%rot, 1) * %a;
    %z = getWord(%rot, 2) * %a;
 
 
    %xy = mSqrt((%x * %x) + (%y * %y));
    %rotAngleXY = mATan( %xy, mAbs(%z) );
    return %rotAngleXY;
 }
 
 function getZrise(%rot, %posOne, %posTwo)
 {
    %XYAngle = getXYangleFromRot(%rot);
 
    %vec = VectorSub(%posTwo, %posOne);
 
     //this finds the distance from origin to our point
    %len = vectorLen(%vec);
 
    //pythagorian theroem says right triangle sides: a squared + b squared = c squared
    //we need to find the rise amount based on the angle and length
    // c^2 - a^2 = b^2
    //the height of the right triangle equals the tangent of the angle times the length of the base
    //%zmod = mTan(%XYAngle + $Pi) * (%len + $Pi);
    %zmod = mTan(%XYAngle) * (%len - $Pi);
    return %zmod;
 }
 
 //--------------------------------------------------------------------------------------------
 // Spline functions
 //--------------------------------------------------------------------------------------------
 
 // These functions draw a curve from the first point to the last point, going near any middle points at time t.
 // t represents the percentage of distance between the first and last point that you want the curve point for
 // They can be used to draw a 3-d spline when all three axis are run through the function.
 
 // %t = (position Of Desired Spline Point) / (distance Between First And Last Points)
 // %curvePoint1.x = get3PointCurveValue(%point1.x, %point2.x, %point3.x, %t)
 // %curvePoint1.y = get3PointCurveValue(%point1.y, %point2.y, %point3.y, %t)
 // %curvePoint1.z = get3PointCurveValue(%point1.z, %point2.z, %point3.z, %t)
 
 // this lil guy doesn't actually draw a curve, but rather a line, however it is very usefull for mixing
 // two values together based on a percentage of time or distance
 function get2PointLineValue(%point1, %point2, %t)
 {
    %pd = ( %point1 * (1-%t)) + (%point2 * %t);
    return %pd;
 }
 
 function get3PointCurveValue(%point1, %point2, %point3, %t)
 {
    %step1 = %point1 * ((1-%t) * (1-%t));
    %step2 = %point2 * 2 * %t * (1 - %t);
    %step3 = %point3 * (%t * %t);
    %pd = %step1 + %step2 + %step3;
    return %pd;
 }
 
 function get4PointCurveValue(%point1, %point2, %point3, %point4, %t)
 {
    %step1 = %point1 * ( (1 - %t)*(1 - %t)*(1 - %t) );
    %step2 = %point2 * 3 * %t * ( (1 - %t)*(1 - %t) );
    %step3 = %point3 * 3 * (%t * %t) * (1 - %t);
    %step4 = %point4 * (%t * %t * %t);
    %pd = %step1 + %step2 + %step3 + %step4;
    return %pd;
 }
 
 //---------------------------------------------------------------------------------------------------------------
 // functions dealing with terrain
 //---------------------------------------------------------------------------------------------------------------
 
 //this takes the provided position, and sets it to the position of the earest terrain vertex
 function findNearestTerrainPoint(%pos)
 {
    %x = findGridPoint(firstWord(%pos));
    %y = findGridPoint(getWord(%pos, 1));
    %z = getWord(%pos, 2);
 
    return(%x SPC %y SPC %z);
 }
 
 function findGridPoint(%axis)
 {
    if(%axis == 0)
       return 0;
    %axis = mFloor(%axis);
    %remainder = %axis % Terrain.squareSize;
 
    if(%remainder >= (Terrain.squareSize / 2))
    {
       while(%axis % Terrain.squareSize != 0)
          %axis++;
    }
    else
    {
       while(%axis % Terrain.squareSize != 0)
          %axis--;
    }
    return %axis;
 }
 
 //Takes the pos provided, and sets the z value to the surface height
 function getTerrainSurfacePoint(%pos)
 {
    %x = getword(%pos, 0);
    %y = getword(%pos, 1);
    %height = getTerrainHeight(%x SPC %y);
    return %x SPC %y SPC %height;
 }
 
 //in a box with the given max and min x and y extents, this will find the average height value
 function getAverageTerrainHeight(%minX, %maxX, %minY, %maxY, %squareSize)
 {
    %total = 0;
    %count = 0;
    for(%x = %minX; %x <= %maxX; %x += %squareSize)
    {
       //we are already looping through x, so loop through Y while we're at it
       for(%y = %minY; %y <= %maxY; %y += %squareSize)
       {
          %total += getTerrainHeight(%x SPC %y);
          %count++;
       }
    }
    return %total / %count;
 }
 
 function getTerrainAngle(%point)
 {
    %angleRad = mACos(vectorDot(%point, "0 0 1"));
    %angleDeg = mRadtoDeg(%angleRad);
    return %angleDeg;
 }
 
 function getTerrainLevel(%pos, %rad)
 {
    while(%retries < 500)
    {
       %x = getWord(%pos, 0) + mFloor(getRandom(%rad * 2) - %rad);
       %y = getWord(%pos, 1) + mFloor(getRandom(%rad * 2) - %rad);
       %z = getWord(%pos, 2) + mFloor(getRandom(%rad * 2) - %rad);
 
       %start = %x @ " " @ %y @ " 5000";
       %end = %x @ " " @ %y @ " -1";
       %ground = containerRayCast(%start, %end, $TypeMasks::TerrainObjectType, 0);
       %z = getWord(%ground, 3);
 
       %z += 3.5;
       %position = %x @ " " @ %y @ " " @ %z;
 
       %mask = ( $TypeMasks::ShapeBaseObjectType | $TypeMasks::MoveableObjectType |
                 $TypeMasks::StaticShapeObjectType | $TypeMasks::WaterObjectType |
                 $TypeMasks::InteriorObjectType );
 
       InitContainerRadiusSearch( %position, 3.5, %mask );
       if(containerSearchNext() == 0)
       {
          //error ("Position Is Good");
          return %position;
       }
       else
          %retries++;
    }
    return( %pos );
 }
 
 //---------------------------------------------------------------------------------------------------------------
 // Functions for moving objects
 //---------------------------------------------------------------------------------------------------------------
 function SceneObject::setOnTerrain(%obj, %pos, %calcOnly)
 {
    if(%pos $= "")
       %pos = %obj.position;
    %terHeight = getTerrainHeight(%pos);
    %offset = %obj.GetHeightOffset();
    %newPos = firstWord(%pos) SPC getWord(%pos, 1) SPC %terHeight + %offset;
    if(%calcOnly)
       return %newPos;
    else
       %obj.setTransform(%newPos SPC %obj.rotFromTransform());
 }
 
 function SceneObject::alignTransforms(%obj, %pos, %rot, %rotAdjust, %xAngle, %yRadius, %zMod, %invert, %calc)
 {
    //rotation hack - these rots just aren't natural!
    if(%rot $= "0 0 1 0" || %rot $= "0 1 0 0"  || %rot $= "1 0 0 0")
       %rot = "0.0001 0.00001 0.99 0.001";
 
    //get the angle of the refrence object(rot) so we know what direction to go to find the new position
    %angle = getWord(%rot, 2) * getWord(%rot, 3);
 
    //this is the angle to find the position at, relative to the refrence point
    %xAngle = mDegToRad(%xAngle);
    //now adjust it to be compatible with the refrence rotation
    %xAngleMod = ((%angle < 0) ? (-1 * %xAngle) : %xAngle);
 
    //generate a vector to the adjusted position
    %matrix = VectorOrthoBasis(getXYangleFromRot(%rot) SPC getWords(%rot,1,2) SPC getWord(%rot, 3) + %xAngleMod);
    //%matrix = VectorOrthoBasis(getWords(%rot,0,2) SPC getWord(%rot, 3) + %xAngleMod);
    %yRot = getWords(%matrix, 3, 5);
 
    //now scale from our current position the yRadius amount to get our new position
    %zPos = vectorAdd(%pos, vectorScale(%yRot, %yRadius));
    %bPos = firstWord(%zPos) SPC getWord(%zPos, 1) SPC (getWord(%zPos, 2) + %zMod);
 
    //right now our new position is on the horizontal plane of world space, if the refrence rot is tilted
    //we need to move the pos up or down to account for it.
    //do wee need to adjust the Z hieght position to account for objects rotated on an x or y axis?
    %XYAngle = getXYangleFromRot(%rot);
    //only add to the Z if the angle is more then 1 deg (Otherwise the rotation hack above will try to bump the target up)
    if(mAbs(%XYAngle) > 0.0174533)
    {
       %zRise = getZrise(%rot, %bpos, %pos);// + $Pi;
       %bPos = getWords(%bPos, 0, 1) SPC getword(%bPos, 2) + %zRise;
    }
 
    //lets try using the trusty ole matrix to take care of any tilt
    //so first thing is to subtract the target position from the ref position.
 
 
 
    //it would probably more accurate to calculate this on the surface of a shpere instead of a circle then adjusting
    //the hieght, but since I don't know how to do that just now we'll go this route, which is plenty damned acurate
 
    //if the generated position needs to point in a certain direction relative to the refrence, then generate it's rot
    if(%rotAdjust !$= "" && %rotAdjust != 0)
    {
       //convert the adjustment to radians, then make it a valid torque world angle
       %rotAdjust = mDegToRad(%rotAdjust);
       %rotAdjust = ((%rotAdjust >= 4.18879) ? (($TwoPi - %rotAdjust) * -1) : %rotAdjust);
 
       //now add the angle adjustment to the refrence rot
       %adjust = %angle + %rotAdjust;
       //bring in back in line with the torque world
       %adjust = ((%adjust >= 4.18879) ? (%adjust - $TwoPi) : %adjust);
       //if it's negative we'll stuff it into the vector and leave the angle value unchanged
       %rotZ = ((%adjust >= 0) ? 1 : (-1));
       %adjust = mAbs(%adjust);
       %rot = getWord(%rot, 0) SPC getWord(%rot, 1)  SPC %rotZ SPC %adjust;
       %angle = getWord(%rot, 2) * getWord(%rot, 3);
    }
    if(%invert)
    {
       //this is for turning the generated position upside down, wonder if this and the above are broken
       //for tilted refrence rotations?
       %angleR = -1 * %angle;
       %Mrot = MatrixCreateFromEuler("0 3.14" SPC %angleR);
       %rot = getWord(%Mrot, 3) SPC getWord(%Mrot, 4) SPC getWord(%Mrot, 5) SPC getWord(%Mrot, 6);
    }
 
    //we're done, get the hell outta here!
    %transForm = %bPos SPC %rot;
    if(%calc)
       return %transForm;
    else
    {
       %obj.setTransform(%transForm);
       return;
    }
 }
 
 //--------------------------------------------------------------------------------------------
 //
 //	SceneObject::alignTransforms() -by Founder
 //
 //--------------------------------------------------------------------------------------------
 // Here it is!! THE mother of all functions!! AMAZING!!
 //
 // usage: %objectID.alignTransforms(%pos, %rot, %rotAdjust, %xAngle, %yRadius, %zMod, %invert, %calc);
 //
 //	%pos is the position of the object(or point) around which to move the (%objectID)
 //	%rot is the final rotation you want %objectID to face
 //	%rotAdjust is for making a rotational offset of %objectID relative to the provided %rot
 //		valid values go from 0 to 360; going clockwise from north(0), east(90)
 //		south(180), west(270) etc. 360 will work, but I don't know what kind of
 //		dumbass would rotate an object by 360 degrees in the z.
 //	%xAngle and %yRadius are vars for adjusting %objectID's position relative to %pos
 //		%yRadius describes a circle of (%yRadius) in size, along which you wish %objectID to be
 //		placed. %xAngle is the relative angle in degrees (0 - 360) from %pos. Where this
 //		angle intersects the circle is the position the object will be placed.
 //
 //	%zMod is how far up you want to move the object relative to %pos
 //	%invert is weather or not you want to turn %objectID upside down.
 //		true and 1 will invert it, 0, false, or giveing it no value will not.
 //	%calc will have the function return the calculated transform instead of actually moving
 //		the object.
 // if for any option you do not want to make an adjustment fill the spot with a 0(zero)
 // negative values will subtract from x y and z axis, but negative values are not valid for
 // the %rotAdjust value
 // examples:
 //              %deplObj.alignTransforms(%pos, %rot, 270, 0, 0, 8, true);
 //              %deplObj.alignTransforms(%dPos, %rot, 0, 0, 0.7, -0.05);
 //
 //
 //
 //                               --
 //                          -          X
 //                         -            -
 //                               P
 //                         -            -
 //                          -          -
 //                               --
 //
 //
 //  In the diagram above, P equals the position of the player or the position generated by the
 //  deploy code or the postion of the reference object. The circle made up of (-)'s represents
 //  a %yRadius of 5 meters. Or if you prefer, a circle which represents the distance
 //  away from P that you want this object to be. X represents the object for whom we are
 //  generating the new position, and where we want it. X is at an approximately 45 degree angle
 //  from P, which is the northEast tick on the Torque compass. In order to keep X's position relative
 //  to P, no matter what direction P faces you would use the following line of code:
 //         %ObjectID.alignTransforms(%pos(of P), %rot(of P), 0, 45, 5, 0);
 //--------------------------------------------------------------------------------------------
 
 function SceneObject::alignGroupRot(%obj, %pos, %rot, %rotAdjust, %xAngle, %yRadius, %zMod, %invert, %calc)
 {
    %vAngle = getWord(%rot, 3);
    %angle = getWord(%rot, 2) * getWord(%rot, 3);
    %xAngle = mDegToRad(%xAngle);
    %xAngleMod = ((%angle < 0) ? (-1 * %xAngle) : %xAngle);
    %vRot =  getWords(%rot,0,2);
    %matrix = VectorOrthoBasis(%vRot SPC %vAngle + %xAngleMod);
    %yRot = getWords(%matrix, 3, 5);
    %zPos = vectorAdd(%pos, vectorScale(%yRot, %yRadius));
    %bPos = firstWord(%zPos) SPC getWord(%zPos, 1) SPC (getWord(%zPos, 2) + %zMod);
    if(%rotAdjust !$= "" && %rotAdjust != 0)
    {
       %deg = mRadtoDeg(%angle);
       %rotAdjust = ((%rotAdjust >= 240) ? ((360 - %rotAdjust) * -1) : %rotAdjust);
       %adjust = %deg + %rotAdjust;
       %adjust = ((%adjust >= 240) ? (%adjust - 360) : %adjust);
       %rotZ = ((%adjust >= 0) ? 1 : (-1));
       %adjust = mAbs(%adjust);
       %finAngle = mDegToRad(%adjust);
       %rot = getWord(%rot, 0) SPC getWord(%rot, 1)  SPC %rotZ SPC %finAngle;
       %angle = getWord(%rot, 2) * getWord(%rot, 3);
    }
    if(%invert)
    {
       %angleR = -1 * %angle;
       %Mrot = MatrixCreateFromEuler("0 3.14" SPC %angleR);
       %rot = getWord(%Mrot, 3) SPC getWord(%Mrot, 4) SPC getWord(%Mrot, 5) SPC getWord(%Mrot, 6);
    }
    %transForm = %bPos SPC %rot;
    if(%calc)
       return %transForm;
    else
    {
       %obj.setTransform(%transForm);
       return;
    }
 }
 
 function SceneObject::StartMoveObject(%obj, %endpos, %time, %smoothness, %delay)
 {
    if(isObject(%obj))
    {
       %startpos = %obj.getTransform();
       %diff = VectorSub(%endpos, %startpos);
       %numsteps = (%time/1000) * %smoothness;
       %interval = 1000 / %smoothness;
       %stepvec = VectorScale(%diff, (1/%numsteps));
       %numstepsleft = %numsteps;
       %currpos = %startpos;
       %obj.MoveObject(%startpos, %endpos, %numsteps, %numstepsleft, %stepvec, %currpos, %interval, %delay);
    }
 }
 
 function SceneObject::MoveObject(%obj, %startpos, %endpos, %numsteps, %numstepsleft, %stepvec, %currpos, %interval, %delay)
 {
    %rot = rotFromTransform(%obj.getTransform());
    %currpos = VectorAdd(%currpos, %stepvec);
 
    %obj.setTransForm(%currpos SPC %rot);
    %numstepsleft--;
    if(%numstepsleft < 1)
       return;
    else
       %obj.schedule(%interval, "MoveObject", %startpos, %endpos, %numsteps, %numstepsleft, %stepvec, %currpos, %interval, %delay);
 }
 
 function getObjectTypeMask(%obj)
 {
    if(%obj.getType() & $TypeMasks::StaticObjectType)
     error("\c4Type is: $TypeMasks::StaticObjectType");
    else if(%obj.getType() & $TypeMasks::EnvironmentObjectType)
     error("\c4Type is: $TypeMasks::EnvironmentObjectType");
    else if(%obj.getType() & $TypeMasks::TerrainObjectType)
     error("\c4Type is: $TypeMasks::TerrainObjectType");
    else if(%obj.getType() & $TypeMasks::InteriorObjectType)
     error("\c4Type is: $TypeMasks::InteriorObjectType");
    else if(%obj.getType() & $TypeMasks::WaterObjectType)
     error("\c4Type is: $TypeMasks::WaterObjectType");
    else if(%obj.getType() & $TypeMasks::TriggerObjectType)
     error("\c4Type is: $TypeMasks::TriggerObjectType");
    else if(%obj.getType() & $TypeMasks::MarkerObjectType)
     error("\c4Type is: $TypeMasks::MarkerObjectType");
    else if(%obj.getType() & $TypeMasks::GameBaseObjectType)
     error("\c4Type is: $TypeMasks::GameBaseObjectType");
    else if(%obj.getType() & $TypeMasks::ShapeBaseObjectType)
     error("\c4Type is: $TypeMasks::ShapeBaseObjectType");
    else if(%obj.getType() & $TypeMasks::CameraObjectType)
     error("\c4Type is: $TypeMasks::CameraObjectType");
    else if(%obj.getType() & $TypeMasks::StaticShapeObjectType)
     error("\c4Type is: $TypeMasks::StaticShapeObjectType");
    else if(%obj.getType() & $TypeMasks::PlayerObjectType)
     error("\c4Type is: $TypeMasks::PlayerObjectType");
    else if(%obj.getType() & $TypeMasks::ItemObjectType)
     error("\c4Type is: $TypeMasks::ItemObjectType");
    else if(%obj.getType() & $TypeMasks::VehicleObjectType)
     error("\c4Type is: $TypeMasks::VehicleObjectType");
    else if(%obj.getType() & $TypeMasks::VehicleBlockerObjectType)
     error("\c4Type is: $TypeMasks::VehicleBlockerObjectType");
    else if(%obj.getType() & $TypeMasks::ProjectileObjectType)
     error("\c4Type is: $TypeMasks::ProjectileObjectType");
    else if(%obj.getType() & $TypeMasks::ExplosionObjectType)
     error("\c4Type is: $TypeMasks::ExplosionObjectType");
    else if(%obj.getType() & $TypeMasks::CorpseObjectType)
     error("\c4Type is: $TypeMasks::CorpseObjectType");
    else if(%obj.getType() & $TypeMasks::DebrisObjectType)
     error("\c4Type is: $TypeMasks::DebrisObjectType");
    else if(%obj.getType() & $TypeMasks::PhysicalZoneObjectType)
     error("\c4Type is: $TypeMasks::PhysicalZoneObjectType");
    else if(%obj.getType() & $TypeMasks::StaticTSObjectType)
     error("\c4Type is: $TypeMasks::StaticTSObjectType");
    else if(%obj.getType() & $TypeMasks::StaticRenderedObjectType)
     error("\c4Type is: $TypeMasks::StaticRenderedObjectType");
    else if(%obj.getType() & $TypeMasks::DamagableItemObjectType)
     error("\c4Type is: $TypeMasks::DamagableItemObjectType");
    else
       error("\c4Object type is: UNKNOWN");
 }
 
 // Founder: Apply kickbak to anything
 function SceneObject::applyKickback(%obj, %kick)
 {
    %dir = %obj.getVectorFromTransform( %obj.getTransform(), "reverse" );
    %force = vectorScale( %dir, %kick );
    %obj.applyImpulse( %obj.posFromTransform(), %force );
 }
 
 // ZOD: Modified version of above to allow different directions
 function SceneObject::applyKick(%obj, %amt, %velCap, %dir)
 {
    %vec = %obj.getVectorFromTransform( %obj.getTransform(), %dir );
    %data = %obj.getDataBlock();
    %pos = %obj.posFromTransform();
    %velocity = %obj.getVelocity();
    %normal = VectorDot( %velocity, VectorNormalize( %velocity ) );
 
    if( %velCap != 0 && %normal > %velCap) // Whatever cap we wish..
    {
       %kick = %amt / %Normal; // Reduce impulse.
       //retrun; // Or apply no impulse at all and exit out.
    }
    else
       %kick = %amt;
 
    %impulse = VectorScale( %vec, %data.mass * %kick );
    %obj.applyImpulse(%pos, %impulse);
 }
 
 //--------------------------------------------------------------------------------------------
 // Taken from Harold Paul /*Wedge*/ DElia's post in the GG mod forums
 // http://www.garagegames.com/mg/forums/result.thread.php?qt=50109
 function SceneObject::getVectorFromTransform(%obj, %transform, %vector)
 {
    %aa = getWords(%transform, 3, 6);
    %tmat = VectorOrthoBasis(%aa);
 
    %rv = getWords(%tMat, 0, 2);
    %fv = getWords(%tMat, 3, 5);
    %uv = getWords(%tMat, 6, 8);
 
    if(%vector $= "up")
       return %uv;
 
    if(%vector $= "down")
       return VectorScale(%uv, -1);
 
    if(%vector $= "left")
       return VectorScale(%rv, -1);
 
    if(%vector $= "right")
       return %rv;
 
    if(%vector $= "forward")
       return %fv;
 
    if(%vector $= "reverse")
      return VectorScale(%fv, -1);
 }
 
 //--------------------------------------------------------------------------------------------
 
 function stripTaggedVar(%var)
 {
    return stripChars( detag( getTaggedString( %var ) ), "\cp\co\c6\c7\c8\c9" );
 }
 
 //------------------------------------------------------------------------------------
 // Object Box functions
 //------------------------------------------------------------------------------------
 //box = min.x min.y min.z max.x max.y max.z
 
 //parse out a particular element
 function getBoxMinX(%box){ return getWord(%box, 0); }
 function getBoxMinY(%box){ return getWord(%box, 1); }
 function getBoxMinZ(%box){ return getWord(%box, 2); }
 function getBoxMaxX(%box){ return getWord(%box, 3); }
 function getBoxMaxY(%box){ return getWord(%box, 4); }
 function getBoxMaxZ(%box){ return getWord(%box, 5); }
 
 function SceneObject::getWorldBoxMin(%obj)
 {
    %box = %obj.getObjectBox();
    %matrix = %obj.getTransForm();
    return MatrixMulPoint(%matrix, getWords(%box, 0, 2));
 }
 
 function SceneObject::getWorldBoxMax(%obj)
 {
    %box = %obj.getObjectBox();
    %matrix = %obj.getTransForm();
    return MatrixMulPoint(%matrix, getWords(%box, 3, 5));
 }
 
 function SceneObject::getWorldBoxMinX(%obj) { return getWord(%obj.getWorldBoxMin(), 0); }
 function SceneObject::getWorldBoxMinY(%obj) { return getWord(%obj.getWorldBoxMin(), 1); }
 function SceneObject::getWorldBoxMinZ(%obj) { return getWord(%obj.getWorldBoxMin(), 2); }
 function SceneObject::getWorldBoxMaxX(%obj) { return getWord(%obj.getWorldBoxMax(), 0); }
 function SceneObject::getWorldBoxMaxY(%obj) { return getWord(%obj.getWorldBoxMax(), 1); }
 function SceneObject::getWorldBoxMaxZ(%obj) { return getWord(%obj.getWorldBoxMax(), 2); }
 
 
 //return a box dimension
 function SceneObject::GetBoxWidth(%obj)
 {
    %box = %obj.getObjectBox();
    return mAbs(getBoxMaxX(%box)) + mAbs(getBoxMinX(%box));
 }
 
 function SceneObject::GetBoxLength(%obj)
 {
    %box = %obj.getObjectBox();
    return mAbs(getBoxMaxY(%box)) + mAbs(getBoxMinY(%box));
 }
 
 function SceneObject::GetBoxHeight(%obj)
 {
    %box = %obj.getObjectBox();
    return mAbs(getBoxMaxZ(%box)) + mAbs(getBoxMinZ(%box));
 }
 
 function SceneObject::GetBoxCenter(%obj)
 {
    //box center by default will be 0 0 0, so use a lil matrix math, get it's current world position
    %matrix = %obj.getTransForm();
    %box = %obj.getObjectBox();
    %newBox = MatrixMulPoint(%matrix, getWords(%box, 0, 2));
    %newBox = %newBox SPC MatrixMulPoint(%matrix, getWords(%box, 3, 5));
    %centerX = (getBoxMinX(%newBox) + getBoxMaxX(%newBox)) * 0.5;
    %centerY = (getBoxMinY(%newBox) + getBoxMaxY(%newBox)) * 0.5;
    %centerZ = (getBoxMinZ(%newBox) + getBoxMaxZ(%newBox)) * 0.5;
    return %centerX SPC %centerY SPC %centerZ;
 }
 
 function SceneObject::GetHeightOffset(%obj)
 {
    return mAbs(getWord(%obj.position, 2) - %obj.getWorldBoxMinZ());
 }
 
 //------------------------------------------------------------------------------------
 // Other functionality
 //------------------------------------------------------------------------------------
 
 
 function getValidSpawnSurface(%pos, %rad)
 {
    while(%retries < 500)
    {
       %x = getWord(%pos, 0) + mFloor(getRandom(%rad * 2) - %rad);
       %y = getWord(%pos, 1) + mFloor(getRandom(%rad * 2) - %rad);
 
       %start = %x SPC %y SPC VectorAdd(getWord(%pos, 2), 3.5);
       %end = %x SPC %y SPC "-1";
       %surface = containerRayCast(%start, %end, $TypeMasks::TerrainObjectType | $TypeMasks::InteriorObjectType, 0);
 
       %z = getWord(%surface, 3);
       %position = %x SPC %y SPC %z;
 
       %mask = ( $TypeMasks::ShapeBaseObjectType | $TypeMasks::MoveableObjectType |
                 $TypeMasks::StaticShapeObjectType | $TypeMasks::WaterObjectType );
 
       InitContainerRadiusSearch( %position, 3.5, %mask );
       if ( containerSearchNext() == 0 )
       {
          //error("Random Position Is Good");
          return %position;
       }
       else
          %retries++;
 
    }
    //error("Random Position Is Bad");
    return( %pos );
 }
 
 
 //--------------------------------------------------------------------------------
 //a lil function to mark a position with an object and a default object to use as marker
 
 datablock StaticShapeData(markerObject)
 {
    category = "Misc";
    shapeFile = "~/data/shapes/markers/octahedron.dts";
    dynamicType = $TypeMasks::StaticShapeObjectType;
 };
 
 function markPoint(%pos, %rot, %block, %type, %name)
 {
    if(%block $= "" && %type $= "")
    {
       %type = StaticShape;
       %block = markerObject;
    }
 
    %obj = new (%type)(%name) {
       dataBlock = %block;
    };
    MissionCleanup.add(%obj);
 
    %obj.setTransform(%pos SPC %rot);
 }
 
 function markPointArray(%array)
 {
    %count = %array.count();
    for(%i = 0; %i < %count; %i++)
    {
       markPoint(%array.getValue(%i));
    }
 }
 //--------------------------------------------------------------------------------------------
 // String functions
 //--------------------------------------------------------------------------------------------
 
 // Returns true if a string passed to it consists of nothing but digits and/or decimals.
 // Passes false for strings with more than one decimal, or with a +
 // or - as anything but the first character (+ or - are only allowed as the first character in the string)
 function isCleanNumber(%string)
 {
    %dot = 0;
    for(%i = 0; (%char = getSubStr(%string, %i, 1)) !$= ""; %i++)
    {
       switch$(%char)
       {
          case "0" or "1" or "2" or "3" or "4" or "5" or "6" or "7" or "8" or "9":
             continue;
 
          case ".":
             if(%dot > 1)
                return false;
 
             %dot++;
             continue;
 
          case "-":
             if(%i) // only valid as first character
                return false;
 
             continue;
 
          case "+":
             if(%i) // only valid as first character
                return false;
 
             continue;
 
          default:
             return false;
         }
     }
     // %text passed the test
     return true;
 }
 
 //this function takes a pathed filename (common/missions/blah.mis) and takes out everything excpet the name (blah)
 function cropToName(%filePAth)
 {
    %name = "";
   %length = strlen(%filePAth);
    %dot = 0;
 
    for(%i = 0; %i < %length; %i++)
    {
       if(getSubStr(%filePAth, %i, 1) $= "/")
          %lastDir = %i;
       if(getSubStr(%filePAth, %i, 1) $= ".")
          %dot = %i;
    }
 
    if(%dot > 0)
    {
       if(%lastDir $= "")
          %name = getSubStr(%filePAth, 0, %dot - 1);
       else
          %name = getSubStr(%filePAth, %lastDir + 1, %dot - 1);
    }
 
    else
       %name = getSubStr(%filePAth, %lastDir + 1, %length);
 
   return %name;
 
 }
 
 function cropDecimal(%num)
 {
   %length = strlen(%num);
   %dot = 0;
 
    for(%i = 0; %i < %length; %i++)
    {
       if(getSubStr(%num, %i, 1) $= ".")
          %dot = %i;
    }
 
    if(%dot > 0)
      %name = getSubStr(%num, 0, %dot);
    else
       %name = %num;
 
   return %name;
 }
 
 function messageTest()
 {
    messageAll('MsgTestColors', '\c0Color 0 \c1Color 1 \c2Color 2 \c3 Color 3 \c4 Color 4 \c5 Color 5 \c6 Color 6 \c7Color 7 \c8 Color 8 \c9 Color 9');
    echo("\c0test \c1test \c2test \c3test \c4test \c5test \c6test \c7test \c8test \c9test");
 }
 
 //--------------------------------------------------------------------------------------------
 // Taken from Harold "LabRat" Brown's .plan
 // http://www.garagegames.com/index.php?sec=mg&mod=resource&page=view&qid=10202
 function dec2hex(%val)
 {
    // Converts a decimal number into a 2 digit HEX number
    %digits ="0123456789ABCDEF"; //HEX digit table
 
    // To get the first number we divide by 16 and then round down, using
    // that number as a lookup into our HEX table.
    %firstDigit = getSubStr(%digits,mFloor(%val/16),1);
 
    // To get the second number we do a MOD 16 and using that number as a
    // lookup into our HEX table.
    %secDigit = getSubStr(%digits,%val % 16,1);
 
    // return our two digit HEX number
    return %firstDigit @ %secDigit;
 }
 
 function chrValue(%chr)
 {
    // So we don't have to do any C++ changes we approximate the function
    // to return ASCII Values for a character.  This ignores the first 31
    // characters and the last 128.
 
    // Setup our Character Table.  Starting with ASCII character 32 (SPACE)
    %charTable = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_'abcdefghijklmnopqrstuvwxyz{|}~\t\n\r";
 
    //Find the position in the string for the Character we are looking for the value of
    %value = strpos(%charTable,%chr);
 
    // Add 32 to the value to get the true ASCII value
    %value = %value + 32;
 
    //HACK:  Encode TAB, New Line and Carriage Return
    if (%value >= 127)
    {
       if(%value == 127)
          %value = 9;
       if(%value == 128)
          %value = 10;
       if(%value == 129)
          %value = 13;
    }
    //return the value of the character
    return %value;
 }
 
 function URLEncode(%rawString)
 {
    // Encode strings to be HTTP safe for URL use
 
    // Table of characters that are valid in an HTTP URL
    %validChars = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz:/.?=_-$(){}~&";
 
    // If the string we are encoding has text... start encoding
    if (strlen(%rawString) > 0)
    {
       // Loop through each character in the string
       for(%i=0;%i<strlen(%rawString);%i++)
       {
          // Grab the character at our current index location
          %chrTemp = getSubStr(%rawString,%i,1);
 
          //  If the character is not valid for an HTTP URL... Encode it
          if (strstr(%validChars,%chrTemp) == -1)
          {
             //Get the HEX value for the character
             %chrTemp = dec2hex(chrValue(%chrTemp));
 
             // Is it a space?  Change it to a "+" symbol
             if (%chrTemp $= "20")
             {
                %chrTemp = "+";
             }
             else
             {
                // It's not a space, prepend the HEX value with a %
                %chrTemp = "%" @ %chrTemp;
             }
          }
          // Build our encoded string
          %encodeString = %encodeString @ %chrTemp;
       }
    }
    // Return the encoded string value
    return %encodeString;
 }
 
 //--------------------------------------------------------------------------------------------
 // Zod: A default raycast function
 function ShapeBase::doRaycast(%this, %range, %mask)
 {
    // get the eye vector and eye transform of the player
    %eyeVec   = %this.getEyeVector();
    %eyeTrans = %this.getEyeTransform();
 
    // extract the position of the player's camera from the eye transform (first 3 words)
    %eyePos = posFromTransform(%eyeTrans);
 
    // normalize the eye vector
    %nEyeVec = VectorNormalize(%eyeVec);
 
    // scale (lengthen) the normalized eye vector according to the search range
    %scEyeVec = VectorScale(%nEyeVec, %range);
 
    // add the scaled & normalized eye vector to the position of the camera
    %eyeEnd = VectorAdd(%eyePos, %scEyeVec);
 
    // see if anything gets hit
    %searchResult = containerRayCast(%eyePos, %eyeEnd, %mask, %this);
 
    return %searchResult;
 }