//::///////////////////////////////////////////////
//:: script(file)name: cas_inc_rndloc
//:: Type: includefile
//:://////////////////////////////////////////////
/*
  Generates random Locations v1.0
  Notes: To be refined and functions added.
*/
//:://////////////////////////////////////////////
//:: Created By: Hikade (nick: agem)
//:://////////////////////////////////////////////
// * (CONSTANTS) VARIABLES >
// NOTE: Only Vars here because i think editing the
// nwscript.nss is pointless due to the PATCH issue.
// Sorry this makes Function Declaration(s) less
// transparent, but this is the it is...
/* values form the nwscript.nss
int SHAPE_SPELLCYLINDER = 0;
int SHAPE_CONE = 1;
int SHAPE_CUBE = 2;
int SHAPE_SPELLCONE = 3;
int SHAPE_SPHERE = 4;
*/
int BASE_SHAPE_CONE = SHAPE_CONE;           // :=1
int BASE_SHAPE_BOX = SHAPE_CUBE;            // :=2
int BASE_SHAPE_CIRCLE = SHAPE_SPHERE;       // :=4
int BASE_SHAPE_STAR = SHAPE_SPELLCYLINDER;  // :=3
int DIMENSION_2D                        = 0;
int DIMENSION_HEMISPHERE                = 1;
int DIMENSION_HEMISPHERE_PLUS           = 2;
int DIMENSION_3D                        = 3;
int DIMENSION_3D_PLUS                   = 4;
// * (CONSTANTS) VARIABLES <

// * Function Declaration(s) >
// NOTE: These are also necassary to make descriptions visible

// Creates an Random Location in BASE_SHAPE_* (see Variables)
// - lTarget: Starting location from where to generate random location
// - iMaxRange : Maximal distance allowed for generated location
// - iMinRange : Minimal distance allowed for generated location
//          -> When iMinRange=0 generated location can be on startingpoint
//          -> When iMinRange=iMaxRange then generated location is always at Maximal Distance e.g. a empty circle
// - Shape : BASE_SHAPE_BOX = SHAPE_CUBE :=2 is Default (others see var BASE_SHAPE_*)
// - fAngle: Only used for certain BASE_SHAPE_*(see following)
//          -> BASE_SHAPE_CONE Sets the center angle off Cone (Half Cone)
//          -> BASE_SHAPE_STAR Sets Staring angel for first Starpoint
// - fAngle: Only used for certain BASE_SHAPE_*(see following)
//          -> BASE_SHAPE_CONE +- angel of Cone center angel
//          -> BASE_SHAPE_STAR Set value for ammount of Starpoints e.g. 5.0f = FIVE STAR
// - nDimension: Set Dimesion Type (see var DIMENSION_*)
//          -> DIMENSION_2D :normal 2D you will most commonly use e.g. full circle
//          -> DIMENSION_HEMISPHERE :Top Part of halfsphere, special: location z-value are porportional distance
//          -> DIMENSION_HEMISPHERE_PLUS : Top Part of halfsphere and z-values will always be visible
//          -> DIMENSION_3D: Full Sphere, ideal for floating things, special: location z-value are porportional distance
//          -> DIMENSION_3D_Plus : Full Sphere, ideal for floating things, and z-values will mostly be visible
// Handy special cases:
//          -> BASE_SHAPE_STAR with only 1 Starpoint is a Line with one direction.
//          -> BASE_SHAPE_STAR with 2 Starpoints is a Line with a middlepoint that has in an left/right property
location RndLoc(location lTarget,int iMaxRange,int iMinRange=0,int nShape_Type=2,float fAngle=0.0f, float fAngleWidth=90.0f,int nDimension=0);
/*
float SetFacingType(float fDirection,location lTarget,object oSource=OBJECT_SELF);
*/
void FillArea();
// Creates an Random Sign 1/-1
int RndSign();
// Creates an Random Float
float RndFloat(int nMaxFloat);
// Creates an Random Angle
float RndAngle(int iDeg=360);
// Creates an Random Unit Vector
vector RndUnitVector();
// Create an Random z-value for an vector based on DIMENSION_*
float RndZCoor(float fZCoor,int iMaxRange,int iMinRange,int nDimension=0);
// * Function Implementation >
// Creates an Random Sign 1/-1
int RndSign()
{
int iRndSign;
if(Random(2)) iRndSign = -1; else iRndSign =1;
return iRndSign;
}
// Creates an Random Float
float RndFloat(int nMaxFloat)
{
float fRandom;
int iPrefixPoint = Random(nMaxFloat);//+1;
int iSufixPoint = Random(10)+1;
return fRandom = IntToFloat(iPrefixPoint)+(IntToFloat(iSufixPoint)/10);
}
// Creates an Random Angle
float RndAngle(int iDeg=360)
{
float fAngle;
int iRndDeg = Random(iDeg)+1;
int iRndMinute = Random(10)+1;
return fAngle = IntToFloat(iRndDeg)+(IntToFloat(iRndMinute)/10);
}
// Creates an Random Unit Vector
vector RndUnitVector()
{
vector vRndUnitVector = AngleToVector(RndAngle());
return vRndUnitVector;
}
/*
float SetFacingType(float fDirection,location lTarget,object oSource=OBJECT_SELF)
{
vector vTarget = GetPositionFromLocation(lTarget);
vector vSource =GetPosition(oSource);
 vector vDirection = AngleToVector(fDurection);
float fFacing = VectorToAngle(vTarget-vSource)+ fDirection;
return fFacing;
}
*/
// Create an Random z-value for an vector based on DIMENSION_*
float RndZCoor(float fZCoor,int iMaxRange,int iMinRange,int nDimension)
{
float fRndZCoor;
switch (nDimension)
    {
     //DIMENSION_HEMISPHERE
    case 1 :
        {
        int zOffSet = Random(iMaxRange-iMinRange);
        fZCoor = fZCoor + (zOffSet + iMinRange);
        }break;
     // DIMENSION_HEMISPHERE_PLUS
    case 2 :
        {
        int zOffSet = Random(12);
        fZCoor = fZCoor + (zOffSet);
        }break;
     // DIMENSION_3D
    case 3 :
        {
        int zOffSet = Random(iMaxRange-iMinRange);
        fZCoor =fZCoor + (zOffSet + iMinRange)*RndSign();
        }break;
     //DIMENSION_3D_PLUS
    case 4 :
        {
        int zOffSet = Random(8);
        fZCoor = fZCoor + (zOffSet)*RndSign();
        }break;
    default: break;
}
return fRndZCoor=fZCoor;
}

// Creates an Random Location in BASE_SHAPE_*
location RndLoc(location lTarget,int iMaxRange,int iMinRange=0,int nShape_Type=2,
                float fAngle=0.0f, float fAngleWidth=90.0f,int nDimension=0)
{
object oTargetArea = GetAreaFromLocation(lTarget);
vector vTarget = GetPositionFromLocation(lTarget);
float fTargetfacing = GetFacingFromLocation(lTarget);
switch (nShape_Type)
{
    case 2: // BASE_SHAPE_BOX = SHAPE_CUBE :=2
    {
    if(Random(2))
        {
        int xOffSet = Random(iMaxRange-iMinRange);
        int yOffSet = Random(iMaxRange);
        // To enable Q2,Q3,Q4 positions of vector
        vTarget.x = vTarget.x + (xOffSet + iMinRange)*RndSign();
        vTarget.y = vTarget.y + (yOffSet)* RndSign();
        }
    else
        {
        int xOffSet = Random(iMaxRange);
        int yOffSet = Random(iMaxRange-iMinRange);
        // To enable Q2,Q3,Q4 positions of vector
        vTarget.x = vTarget.x + (xOffSet) *RndSign();
        vTarget.y = vTarget.y + (yOffSet + iMinRange)*RndSign();
        }
    // Adds according z-value if demanded
    vTarget.z =RndZCoor(vTarget.z,iMaxRange,iMinRange,nDimension);
    }break;
    case 4: // BASE_SHAPE_CIRCLE = SHAPE_SPHERE :=4
        {
        int iRndRange = Random((iMaxRange+1)-iMinRange);
        vector vRandomUnitVector = RndUnitVector();
        vRandomUnitVector *= IntToFloat(iRndRange+iMinRange);
        vTarget += vRandomUnitVector;
        // Adds according z-value if demanded
        vTarget.z =RndZCoor(vTarget.z,iMaxRange,iMinRange,nDimension);
        }break;
    case 1: // BASE_SHAPE_CONE = SHAPE_CONE :=1
        {
        int iRndRange = Random((iMaxRange+1)-iMinRange);
        float fRndAngle = RndAngle(FloatToInt(fAngleWidth)/2*RndSign());
        fRndAngle += fAngle;
        vector vRndVector = AngleToVector(fRndAngle);
        vRndVector *= IntToFloat(iRndRange+iMinRange);
        vTarget += vRndVector;
        // Adds according z-value if demanded
        vTarget.z =RndZCoor(vTarget.z,iMaxRange,iMinRange,nDimension);
        }break;
 /* //difference to SHAPE_CONE unknown and a CYLINDER can be made by BASE_SHAPE_CIRCLE
    case SHAPE_SPELLCONE:
    {
    }break;
*/
    case 3: // BASE_SHAPE_STAR = SHAPE_SPELLCYLINDER :=3
    {
    int iRndRange = Random((iMaxRange+1)-iMinRange);
    float fStartingAngle = fAngle;
    float fAngleStep = (360.0f/fAngleWidth);
    float fRndAngel = Random(FloatToInt(fAngleWidth)+1)*fAngleStep;
    vector vRandomVector = AngleToVector(fRndAngel)*IntToFloat(iRndRange+iMinRange);
    vTarget += vRandomVector;
    // Adds according z-value if demanded
    vTarget.z =RndZCoor(vTarget.z,iMaxRange,iMinRange,nDimension);
    }break;
default : break;
}
// return Random Location of wished type
return lTarget= Location(oTargetArea,vTarget,fTargetfacing);
}


// Utility function to destroy an object after a delay
object DestroyObjectReturn(object oDestroy, float fDelay = 0.0f)
{
    DestroyObject(oDestroy, fDelay);
    return oDestroy;
}
/*
void main()
{

}             */