bool[20000] vector_allocated;
fixed[20000] vector_x;
fixed[20000] vector_y;
fixed[20000] vector_z;
int vector_count = 0;
bool isVectorAllocated(int this) {
    if ((this>=0)&&(this<=1999)){
        return (vector_allocated[this])&&(this<vector_count);
    }
    return false;
}
int vector_createXYZ(fixed x, fixed y, fixed z) {
    int i=0;
    int j=-1;
    while ((i<vector_count)&&(j==-1))
    {
        if (vector_allocated[i])
        {
            i=i+1;
        } else
        {
            j=i;
        }
    }    
    if (j!=-1)
    {
        i=j;
    } else
    {
        i=vector_count;
        vector_count=vector_count+1;
    }
    vector_allocated[i]=true;
    vector_x[i]=x;
    vector_y[i]=y;
    vector_z[i]=z;
    return i;
}
int vector_createPoint(point begin, point end) {
    return vector_createXYZ(PointGetX(end)-PointGetX(begin),PointGetY(end)-PointGetY(begin),WorldHeight(c_heigh​tMapGround,end)-WorldHeight(c_heightMapGround,begin));//PointGetHeight(end)-PointGetHeight(begin)+
}
int vector_createVector(int v) {
    if (isVectorAllocated(v))
    {
        return vector_createXYZ(vector_x[v],vector_y[v],vector_z[v]);
    }
    return -1;
}
void vector_destroy(int this) {
    if (isVectorAllocated(this))
    {
        vector_allocated[this]=false;
        if (this==vector_count-1){vector_count=vector_count-1;}
    }
}
fixed vector_getX(int this) {
    if (isVectorAllocated(this))
    {
        return vector_x[this];
    }
    return 0;
}
bool vector_setX(int this, fixed x) {
    if (isVectorAllocated(this))
    {
        vector_x[this]=x;
    }
    return isVectorAllocated(this);
}
fixed vector_getY(int this) {
    if (isVectorAllocated(this))
    {
        return vector_y[this];
    }
    return 0;
}
bool vector_setY(int this, fixed y) {
    if (isVectorAllocated(this))
    {
        vector_y[this]=y;
    }
    return isVectorAllocated(this);
}
fixed vector_getZ(int this) {
    if (isVectorAllocated(this))
    {
        return vector_z[this];
    }
    return 0;
}
bool vector_setZ(int this, fixed z) {
    if (isVectorAllocated(this))
    {
        vector_z[this]=z;
    }
    return isVectorAllocated(this);
}
bool vector_setXYZ(int this, fixed x, fixed y, fixed z) {
    if (isVectorAllocated(this))
    {
        vector_x[this]=x;
        vector_y[this]=y;
        vector_z[this]=z;
    }   
    return isVectorAllocated(this);
}
int vector_setPoint(int this, point begin, point end) {
    if (isVectorAllocated(this))
    {
        vector_x[this]=PointGetX(end)-PointGetX(begin);
        vector_y[this]=PointGetY(end)-PointGetY(begin);
        vector_z[this]=WorldHeight(c_heightMapGround,end)-WorldHeight(c_heightMapGround,begin);//PointGetHei​ght(end)-PointGetHeight(begin)+
        return this;
    }   
    return -1;
}
fixed vector_getLength(int this) {
    if (isVectorAllocated(this))
    {
        return SquareRoot(vector_x[this]*vector_x[this]+vector_y[this]*vector_y[this]+vector_z[this]*vector_z[this]​);
    }
    return 0;
}
int vector_normalize(int this) {
    fixed l;
    if (isVectorAllocated(this))
    {       
        l=SquareRoot(vector_x[this]*vector_x[this]+vector_y[this]*vector_y[this]+vector_z[this]*vector_z[thi​s]);  
        if (l!=0)
        {  
            vector_x[this]=vector_x[this]/l;
            vector_y[this]=vector_y[this]/l;
            vector_z[this]=vector_z[this]/l;
        }
        return this;
    }
    return -1;
}
int vector_setLength(int this, fixed new_l){
    fixed l;
    if (isVectorAllocated(this))
    {       
        l=SquareRoot(vector_x[this]*vector_x[this]+vector_y[this]*vector_y[this]+vector_z[this]*vector_z[thi​s]);    
        if (l!=0) {
            vector_x[this]=new_l*(vector_x[this]/l);
            vector_y[this]=new_l*(vector_y[this]/l);
            vector_z[this]=new_l*(vector_z[this]/l);
        }
        return this;
    }
    return -1;
}
int vector_realMultiply(int this, fixed r) {
    if (isVectorAllocated(this)) 
    {
        vector_x[this]=r*vector_x[this];
        vector_y[this]=r*vector_y[this];
        vector_z[this]=r*vector_z[this];
        return this;    
    }
    return -1;
}
fixed vector_scalarMultiply(int this, int vect) {
    if ((isVectorAllocated(this)) && (isVectorAllocated(vect)))
    {
        return vector_x[this]*vector_x[vect]+vector_y[this]*vector_y[vect]+vector_z[this]*vector_z[vect];
    }
    return 0;
}
int vector_vectorPlus(int this, int vect) {
    if ((isVectorAllocated(this)) && (isVectorAllocated(vect)))
    {
        vector_x[this]=vector_x[this]+vector_x[vect];
        vector_y[this]=vector_y[this]+vector_y[vect];
        vector_z[this]=vector_z[this]+vector_z[vect];
        return this;
    }
    return -1;
}
int vector_vectorMultiply(int this, int vect)
{   
    fixed x;
    fixed y;
    fixed z;
    if ((isVectorAllocated(this)) && (isVectorAllocated(vect)))
    {
        x = vector_y[this]*vector_z[vect]-vector_y[vect]*vector_z[this];
        y = vector_z[this]*vector_x[vect]-vector_z[vect]*vector_x[this];
        z = vector_x[this]*vector_y[vect]-vector_x[vect]*vector_y[this];
        vector_x[this]=x;
        vector_y[this]=y;
        vector_z[this]=z;
        return this;
    }
    return -1;
}

int vector_createXYZ(fixed x, fixed y, fixed z) {

int vector_createXYZ(fixed x, fixed y, fixed z) {
    int i=0;
    while (isVectorAllocated(i))
    {
            i=i+1;
    }
    vector_allocated[i]=true;
    if(i >= vector_count) {
        vector_count=vector_count+1;
    }
    vector_x[i]=x;
    vector_y[i]=y;
    vector_z[i]=z;
    return i;
}

void vector_destroy(int this) {

bool vector_setY(int this, fixed y) {

int vector_realMultiply(int this, fixed r) { // dot product
fixed vector_scalarMultiply(int this, int vect) { // cross product