// ScString library
void debug_msg(string msg) {
    TriggerDebugOutput(2, StringToText(msg), true);
}

fixed   I2F(int a) { return IntToFixed (a); }
string  I2S(int a) { return IntToString (a); }
text    I2T(int a) { return IntToText (a); }
int     F2I(fixed a) { return FixedToInt(a); }
string  F2S(fixed a) { return FixedToString(a, c_fixedPrecisionAny); }
text    F2T(fixed a) { return FixedToText (a, c_fixedPrecisionAny); }
int     S2I(string s) { return StringToInt(s); }
fixed   S2F(string s) { return StringToFixed(s); }


// ScMath library
// by ScorpioT1000; powered by [XGM.ru]

// point as a vector[3]

point NewPoint(fixed x, fixed y, fixed z) {
    point a = Point(x,y);
    PointSetHeight(a,z);
    return a;
}

fixed p2x(point a) {
    return PointGetX(a);
}
fixed p2y(point a) {
    return PointGetY(a);
}
fixed p2z(point a) {
    return PointGetHeight(a);
}
void x2p(point a, fixed x) {
    point b = Point(x,p2y(a));
    PointSet(a,b);
}
void y2p(point a, fixed y) {
    point b = Point(p2x(a),y);
    PointSet(a,b);
}
void z2p(point a, fixed z) {
    PointSetHeight(a,z);
}
void xy2p(point a, fixed x, fixed y) {
    point b = Point(x,y);
    PointSet(a,b);
}

point vector3copy(point a) {
    point b = NewPoint(p2x(a),p2y(a),p2z(a));
    return b;
}
fixed vector3toNum(point a) {
    return (p2x(a) + p2y(a) + p2z(a));
}
fixed vector3dist(point a, point b) {
    fixed result=0;
    fixed t1=p2x(a) - p2x(b);
    fixed t2=p2y(a) - p2y(b);
    fixed t3=p2z(a) - p2z(b);
    result = SquareRoot(t1*t1 + t2*t2 + t3*t3);
    if(result<0) { result=result*(-1); }
    return result;
}
fixed vector3length(point a) { //and module
    return SquareRoot(p2x(a) * p2x(a) + p2y(a) * p2y(a) + p2z(a) * p2z(a));
}
fixed vector3lengthSq(point a) {
    return (p2x(a) * p2x(a) + p2y(a) * p2y(a) + p2z(a) * p2z(a));
}
void vector3add(point a, point b) { //scalar
    xy2p(a,p2x(a)+p2x(b),p2y(a)+p2y(b));
    z2p(a,p2z(a)+p2z(b));
}
void vector3nadd(point a, fixed num) {
    xy2p(a,p2x(a)+num,p2y(a)+num);
    z2p(a,p2z(a)+num);
}
void vector3sub(point a, point b) { //scalar
    xy2p(a,p2x(a)-p2x(b),p2y(a)-p2y(b));
    z2p(a,p2z(a)-p2z(b));
}
void vector3nsub(point a, fixed num) {
    xy2p(a,p2x(a)-num,p2y(a)-num);
    z2p(a,p2z(a)-num);
}
void vector3mult(point a, point b) { //scalar
    xy2p(a,p2x(a)*p2x(b),p2y(a)*p2y(b));
    z2p(a,p2z(a)*p2z(b));
}
void vector3vectorMult(point a, point v) { //vector
    point u = vector3copy(a);
    xy2p(a, (p2y(u) * p2z(v) - p2z(u) * p2y(v)), (p2z(u) * p2x(v) - p2x(u) * p2z(v)));
    z2p(a, (p2x(u) * p2y(v) - p2y(u) * p2x(v)));
}
void vector3nmult(point a, fixed num) {
    xy2p(a,p2x(a)*num,p2y(a)*num);
    z2p(a,p2z(a)*num);
}
void vector3div(point a, point b) { //scalar
    xy2p(a,p2x(a)/p2x(b),p2y(a)/p2y(b));
    z2p(a,p2z(a)/p2z(b));
}
void vector3ndiv(point a, fixed num) {
    xy2p(a,p2x(a)/num,p2y(a)/num);
    z2p(a,p2z(a)/num);
}
void vector3normalize(point a) {
    vector3nmult(a, (1/vector3length(a)));
}
void vector3invert(point a) {
    vector3nmult(a,-1);
}
fixed vector3GetMultiple(point a, point b) { //scalar
    return (p2x(a) * p2x(b) + p2y(a) * p2y(b) + p2z(a) * p2z(b));
}
fixed vector3angle2(point a, point b) { //2d angle
    fixed r = vector3length(a) * vector3length(b);
    r = vector3GetMultiple(a,b) / r;
    return ACos(r);
}
point vector3angle3(point a, point b) { //output: x = alpha, y = beta (3d angle)
    point c = vector3copy(b);
    point out;
    vector3sub(c,a); //c minus a
    //decart to spheric
    out = Point(ATan2(p2y(c), p2x(c)), ATan2(p2z(c), SquareRoot(p2x(c) * p2x(c) + p2y(c) * p2y(c))));
    return out;
}
point vector3angle3decart(point a, point b) { //output: 3d vector
    point out = vector3copy(b); //b to out
    vector3sub(out,a); //out minus a
    return out;
}
// ===============================
// ===============================

fixed GetTerrainZ(point xy) {
    return WorldHeight(c_heightMapGround, xy);
}

point CameraGetEyeDirection(int player) {
    fixed a = CameraGetYaw(player); //rotation
    fixed b = CameraGetPitch(player); //angle
    point v = NewPoint(Cos(a)*Cos(b), Sin(a)*Cos(b), Sin(b));
    //vector3nmult(v,-1); //from eye
    return v;
}

point CameraGetEyePoint(int player, fixed distance) { // second: distance from target to eye
    point y = CameraGetEyeDirection(player);
    point t = CameraGetTarget(player);
    vector3nmult(y,distance); //add offset
    vector3sub(t,y);
    z2p( t, GetTerrainZ(t) + p2z(t) );
    return t;
}

void UnitSetZEx(unit u, fixed value, fixed duration) { //absolute world height
    point x = UnitGetPosition(u);
    UnitSetHeight(u,value - GetTerrainZ(x),duration);
}
void UnitSetZ(unit u, fixed value) { UnitSetZEx(u,value,0); } //absolute world height

// ========= test =========
void FMoveUnitTo(int pl, unit u, fixed distance) {
    point t = CameraGetEyePoint(pl,distance-4);
    UnitSetPosition(u,t,false);
    UnitSetZ(u,p2z(t));
}

UnitSetHeight()