Здраствуйте!
Я пытался перенести старенькое заклинание, которое я нашел в Барахолке, в свою карту.
И при сохранении выдает ошибку в коде и карта больше не открывается в Варике...
Помогите исправить для не-Кодировщика!
Not a valid library declaration [{]?
//******************************************************************************************//
//                                                                                          //
//                                  Physical Dynamic Library 1.0                            //
//                                                                                          //
//******************************************************************************************//
// © ____ _._. aka NCrashed 2009, _______ _ __________ XGM.ru
// _______ ________ __________ _______, _______ ___________ ________ ________ ____________ __-
// ______ _ __________. ___ ____________ ______________ ____, ___________ ____, ____ ______, 
// ____ _______ _____ _ ______ ______. _____ _______ ___________ __ ___ ____________ _ _____ 
// _______ _________ ___ ________ _____ ________. _____ ________ _____ _____________ ______,
// _________ _____, ___ ___ __ _______________, ____ ___-__ _______ __ __________.

//#guard PDL

#include "cj_types.j"
//=========================================================================================
//=
//=                                _________ _______  
//=
//=========================================================================================
#define { 
    // _________, _______ __________ ______, _______ _____ __________ _ _______
    MGUI =         false // ___ _________
    MFriction =     true // ______, _____ _ ______
    AllowMov =      true // ___________ _____ _________ __ ______ _______, _______ ________, ___ _________ 
    MCollusion =    true // ______ _______ ____________
    MCustomForces = true // ______ _______ ___ __________, ________ __ _______/___ _ _____ ___
    MKulonForces =  true // ___________ ____
    MSpringes =     true // ______ ______
    
    // _________ _______
    Gi =                                6.673   // *10^(-11)  ______________ __________, _________ _____ ___ _ ________ ___
    Gravitational_acceleration =        9.81    // _________ __________ _______
    Height_max =                      700.      // _______ _____
    KulonFactor =                   90000.      // _____. _ ______ ______
    PDLTimer =                          0.025   // _____ _____ ____________
    SpringRenderingTime =               0.2     // _____ _____ ____________ ______
    PDLMaxSpeed =                   10000.      // ____________ ________
    CliffDist =                        50.      // __________ ___________ _________ ______ _________
    FactorOfResist =                    0.8     // _______ ________ ___ _____ __ _______ _____
    EarthResist =                       0.6     // _______ ________ ___ _____ _ _____ (__ ____ _________ _____)
    CollPlosk =                         1.      // ______ ____________ _______ _________ ___ _____ __ _____ ___ ____
    MaxStackSize =                    100       // ____________ _____ ___ _ _____ _ ___ _____ ____
    AddVFrFactor =                    100.      // _____________ ___________ _______ ______  
    CollBodyMax =                       5       // _____ _________ ___, ___ _______ _____ ___________ ___________ ________ ___ ____________ ___. 
    StopCollSpeed =                    20.      // ________ ____________ ___ ___ ____________
    ForcedCollSpeed =                 300       // ________ ________ ____________
    OrderDistanceStop =                50.      // __________ _________ _____ __ _____ _______
    UnitCanRunMinHeight =             200.      // ______, ___ _______ ____ _____ ______________ ____________
    MaxBodyRad =                      200.      // ____________ ______ ___, _____ ___ _______ ____________
    MinSpringDeformation =              1.      // ____________ __________ _______ ___ _____________ ___
}
//#sysinit

//=========================================================================================
//=
//=                                __________ ___________ ___________  
//=
//=========================================================================================

library PDLtypes
        //define MSpringes = false
        interface CrackedBody
        endinterface
        interface Body
        endinterface
        interface Spring
        endinterface
        
        interface BodyData
                real m = 0               
                real gx = 0 
                real gy = 0
                real gz = -Gravitational_acceleration
                
                real mu = 0 
                real k =  0 
                real r =  0 
                real q =  0 
                
                real elastic = GetRandomReal(0.7,1)
                boolean AllowRest = true 
                
                Body BindedBody = 0
                        
                method onCreate takes Body b returns nothing defaults nothing
                method onGround takes Body b returns nothing defaults nothing
                method onCollusion takes Body b, Body b2 returns nothing defaults nothing
                method onForcedColl takes Body b, Body b2 returns nothing defaults nothing
                method onDestrColl takes Body b, destructable destr returns nothing defaults nothing
                method onUnitColl takes Body b, unit u returns nothing defaults nothing
                method onWorldBound takes Body b returns nothing defaults nothing 
                method onCrack takes Body b, CrackedBody cb returns nothing defaults nothing
                method onTerrainCliff takes Body b returns nothing defaults nothing
                method onRest takes Body b returns nothing defaults nothing
                method onSelect takes Body b returns nothing defaults nothing
                method onDeselect takes Body b returns nothing defaults nothing
                method onDeath takes Body b returns nothing defaults nothing
                method onExit takes Body b returns nothing defaults nothing
                method onPointOrder takes Body b, real TargetX, real TargetY, integer OrdId returns nothing defaults nothing
                method onTargetOrder takes Body b, widget target, integer OrdId returns nothing defaults nothing
                method onOrder takes Body b, integer OrdId returns nothing defaults nothing
                method onStart takes Body b returns nothing defaults nothing
                method onLoop takes Body b returns nothing defaults nothing
                //#if MSpringes
                    method onSpringBinded takes Body a, Body b, Spring sp returns nothing defaults nothing
                    method onSpringUnBinded takes Body a returns nothing defaults nothing
                //#endif
        endinterface
endlibrary


        // ___________ ____
        
        struct icerock extends BodyData {
                real m = 100 // _____
                real r = 50 // ______ ____, _____ ___ ____________
                real elastic = GetRandomReal(0.8,1) // ___________ _________ ____
        }

        struct planet extends BodyData {
                real m = 1000 // _____
                real gz = 0 // _________ __________ _______, ________ __ ___ z
                real r = 50 // ______ ____, _____ ___ ____________
                real elastic = GetRandomReal(0.8,1) // ___________ _________ ____
        }

        struct proton extends BodyData {
                real m = 1 
                real r = 25 
                real gz = 0
                real elastic = 1 
                real q = 1
                boolean AllowRest = false
        }

        struct electron extends BodyData {
                real m = 0.001 
                real r = 5 
                real gz = 0
                real elastic = 1 
                real q = -1
                boolean AllowRest = false
        }
}

library PDL initializer StartEngine { 

//=============================================================================
    // _______ _____, ________________ _ StartEngine
    private real maxX 
    private real maxY
    private real minX 
    private real minY 
    // ___________, ____________ _ _______
    define {
        private msg(t) = BJDebugMsg(t)
    }
//=============================================================================

//=========================================================================================
//=
//=                                _________ _______
//=
//=========================================================================================
scope UPDL {

// _____ _______
   real Module(Vector r) {
        return SquareRoot(r.vx*r.vx+r.vy*r.vy+r.vz*r.vz)
    }

//  _______ ____ _____ _________  
    real CosV(Vector a, Vector b) {
        return (a.vx*b.vx + a.vy*b.vy + a.vz*b.vz)/(Module(a)*Module(b))
    }

//  2_ _______: __________ ____ _____ _______ _ ________
    real AngleBLoc(real xa, real ya, real xb, real yb) {
        return Atan2(yb - ya, xb - xa)
    }
    
//  2_ _______: __________ ____ _____ _______ _ ________  
    real AngleBLocGr(real xa, real ya, real xb, real yb) {
        return 57.29577951 * Atan2(yb - ya, xb - xa)
    }

// ____ _____ _________ _ ________
    real Angle(Vector a, Vector b) {
        return Acos((a.vx*b.vx + a.vy*b.vy + a.vz*b.vz)/(Module(a)*Module(b)))
    }
    
// ____ _____ _________ _ ________
    real AngleGr(Vector a, Vector b)  {
        return Acos((a.vx*b.vx + a.vy*b.vy + a.vz*b.vz)/(Module(a)*Module(b)))*57.29577951
    }

// 2_ __________ _____ _______
    real DistanceBLocs(real ax, real ay, real bx, real by)  {
        return SquareRoot((bx - ax) * (bx - ax) + (by - ay) * (by - ay))
    }
    
// __________ _____ _____ _______ _ ____________    
    real DistanceBL3D(real ax, real ay, real az, real bx, real by, real bz)  {
        return SquareRoot((bx - ax) * (bx - ax) + (by - ay) * (by - ay) + (bz - az) * (bz - az))
    }

// _________ ____________ _______ __ ______    
    real Scalar(Vector a, Vector b)  {
        return a.vx*b.vx + a.vy*b.vy + a.vz*b.vz
    }
    
// _________ _____ ________ _______ __ ______
    real Proj(Vector a, Vector b)  {
        return (a.vx*b.vx + a.vy*b.vy + a.vz*b.vz)/SquareRoot(b.vx*b.vx + b.vy*b.vy + b.vz*b.vz)
    }
    
// _______ ___ ________ ________ _________ _ __________
    real PolarX(real x, real dist, real angle)  {
        return x + dist * Cos(angle * 57.29577951)
    }

    real PolarY(real y, real dist, real angle)  {
        return y + dist * Sin(angle * 57.29577951)
    }
    
// ________ _________ ______ ______ _____
    void UnitFlyMod(unit u) {
        UnitAddAbility(u,'Amrf')
        UnitRemoveAbility(u,'Amrf')  
    }
    
// __________ ______ _____ _________
    location GZL = Location(0,0) 
    
    real GetZ(real X, real Y)  {
        MoveLocation(GZL,X,Y)
        return GetLocationZ(GZL)
    }
    
// __________ ______ ____ ___ _______ ____
// __________ ______ ______ _ __________ ________
    real GetZB(Body b)  {
        MoveLocation(GZL,b.x,b.y)
        return GetLocationZ(GZL)+b.z
    }
    
// __________ __________ ________ _____
    real Abs(real r)  { 
        if r > 0. {return r}
        else {return -r}
    }
    
//  __________ ____ _____
    real Shgn(real r)  {
        if r > 0. {return 1.}
        elseif r < 0. {return -1.}
        else {return 0.}
    }

// _____ _____ __ _______
    int DIV(integer a, integer b ) {
        integer i = 0
        loop {  
            exitwhen a < b
             i++
             a = a - b
        }
        return i
    }
    
// _______ ____ __ _____
    Body FindBody(unit u) {
        integer i = 0
        loop {
            if Stack.S[i].u == u {return Stack.S[i]}
        exitwhen i >= Stack.i
        i++
        }
        
        i = 0
        loop {
            if Stack.BMotionless[i].u == u {return Stack.BMotionless[i]}
        exitwhen i >= Stack.k
        i++
        }

        return 0
    }
    
    //____ _____ ________ ____ __ _____ "_________ ___". ___________ ___ _______
    void SetMotionless(Body b, boolean bb) {
        integer i = 0
        if bb {b.Motionless = true}
        else {
            loop {
                exitwhen i > Stack.k
                if (Stack.BMotionless[i] == b) {
                    Stack.i= Stack.i +1
                    Stack.S[Stack.i] = b
                    Stack.BMotionless[i] = Stack.BMotionless[Stack.k]
                    Stack.BMotionless[Stack.k] =0
                    Stack.k = Stack.k - 1
                }
                i++
            }
        }
    }
    
//_________ ____ _ _____ (x,y,z) __ _________ Speed
    void SendBodyTo(Body b,real x, real y, real z, real Speed) {
        real kz = z - GetZ(b.x,b.y)
        real r = SquareRoot( (x-b.x)*(x-b.x) + (y-b.y)*(y-b.y) + (kz-b.z)*(kz-b.z))
            b.v.vx = (x-b.x)/r*Speed
            b.v.vy = (y-b.y)/r*Speed
            b.v.vz = (kz-b.z)/r*Speed
            b.Motionless = false
    }

//___________ ______ ________ ____ _ scale ___
    void IncreaseBodySpeed(Body b, real scale) {
        b.v.Multiply(scale)
        b.Motionless = false
    }

//___________ ______ ________ ____ __ Spd ___ 
    void IncreaseBodySpeedV(Body b, real Spd) {
        real r = Module(b.v)
        b.v.Multiply(1 + Spd/r)
        b.Motionless = false
    }
    
//_________ __ _____________ ____ _ _______  u, __ __________ ____ ___ _____________ __ _____ _______
    bool IsBodyExt(unit u) {
        integer i = 1
        loop {
            if Stack.S[i].u == u {return true}
        exitwhen i >= Stack.i
        i++
        }
        i = 1
        loop {
            if Stack.BMotionless[i].u == u {return true}
        exitwhen i >= Stack.k
        i++
        }
        return false
    }

//________ ______ ____.
    void CreateDarkHole(Body dh, Body victim, real F) {
            real r = SquareRoot((dh.x-victim.x)*(dh.x-victim.x)+(dh.y-victim.y)*(dh.y-victim.y)+(dh.z-victim.z)*(dh.z-victim.z))
            F = RAbsBJ(F)
            dh.Data.m = r*r*F/(Gi*victim.Data.m)
            dh.AddAttractionForce(victim)
    }

// __________ ______ _ ______ ____
    void AddVictDarkHole(Body dh, Body victim) {
            dh.AddAttractionForce(victim)     
    }
}

//=========================================================================================
//=
//=                                ______ "______"
//=
//=========================================================================================

struct Vector {
    real vx = 0
    real vy = 0
    real vz = 0
    // _____________ ______ __ ____ ______
    void GetFrom2Loc(real x1, real y1, real z1, real x2, real y2,real z2 ) {
         .vx = x2-x1 
         .vy = y2-y1
         .vz = z2-z1
    }
    // ________ ______ __ _____
    void Multiply(real c ) {
         .vx = .vx*c
         .vy = .vy*c
         .vz = .vz*c
    }
    // ______________ _ _______ ______
    void Summ(Vector s ) {
         .vx = .vx + s.vx
         .vy = .vy + s.vy
         .vz = .vz + s.vz           
    }
    // ____________ _______, __ ____ __ __________ _________, k - _____ _____
    void Norm(real k ) {
         .vx = k*.vx/Module(this)
         .vy = k*.vy/Module(this)
         .vz = k*.vz/Module(this)       
    }
    // _________ ______-________ _______ __ ______, _______ ______
    static Vector CreateProj(Vector a, Vector b) {
        Vector v = Vector.create()
        
        v.Multiply((a.vx*b.vx + a.vy*b.vy + a.vz*b.vz)/(b.vx*b.vx + b.vy*b.vy + b.vz*b.vz))
        return v
    }
    // _____ ________, _______ ______   
    static Vector CreateSumm(Vector a, Vector b) {
        Vector S = Vector.create()
         S.vx = a.vx + b.vx
         S.vy = a.vy + b.vy
         S.vz = a.vz + b.vz   
        return S
    }
    // _________ _______ __ _____,_______ ______
    static Vector CreateMultiply(Vector a, real const) {
        Vector c = Vector.create()
         c.vx = a.vx*const
         c.vy = a.vy*const
         c.vz = a.vz*const
        return c
    }
}

//=========================================================================================
//=
//=                                  ______ "____"
//=
//=========================================================================================

struct Force {
    Vector v = 0
    Body a = 0
    Body b = 0
    real cv = 0 // _______ ________
    real at = 0 // ____________ _________
    
    // _______ _______ ____ __________ _____ ______, ______ __ _______
    void Attraction() { 
              Vector r = Vector.create()
              Vector F 
             r.GetFrom2Loc(.a.x,.a.y,.a.z,.b.x,.b.y,.b.z)
             F = Vector.CreateMultiply(r,(Gi*.a.Data.m*.b.Data.m)/((Module(r))*(Module(r))*(Module(r))))
             .v = F
             .a.F.Summ(F)
             F.Multiply(-1)
             .b.F.Summ(F)
             r.destroy()
             F.destroy()
            
             .a.Motionless = false
             .b.Motionless = false
    }
    // _______ __________ ____ _ ______________ _________
    void Circle() {
            Vector an = Vector.create()
            real x = .v.vx - .a.x
            real y = .v.vy - .a.y 
            an.vx = x*.cv*.cv/(x*x + y*y)*.a.Data.m
            an.vy = y*.cv*.cv/(x*x + y*y)*.a.Data.m
            .a.F.Summ(an)
            if .at > 0 {.cv = .cv + .at/(1/PDLTimer)}
            an.destroy()
            .a.Motionless = false
    }
    // ________ ___ ______
    void Remove() { 
            integer j = 0
            integer k = 0
            loop {
                if Stack.F[j] == this {
                    loop {
                         Stack.F[j+k] = Stack.F[j+k+1]
                    exitwhen k >= Stack.j - j - 1
                     k++
                    }
                     k = 0
                     Stack.F[Stack.i] = 0
                     Stack.j = Stack.j - 1
                }
            exitwhen j >= Stack.j
             j++
            }
         .v.destroy()
         .destroy()
    }
}

//=========================================================================================
//=
//=                             ______ "____________ ____"
//=
//=========================================================================================
scope BodyPDL {
    // _________ ________ ___ ___________ _________ _______ _________
        timer SetRadiusPDLT = CreateTimer()
        Body array RadiusPDLB [100]
        real array RadiusPDLR [100]
        integer RadiusPDLI = 0 
        
    // ____ _______ ____________ _______ _______ _____, _____ _____ ___ ________ ____ _ ____ _______ __ _________
    void SetRadiusPDL_Actions() {
        integer i = 0
        integer j = 0
        boolean b = false
    if RadiusPDLI > 0 {
        loop {
            loop {
                if SquareRoot(Stack.S[j].x - RadiusPDLB[i].x)*(Stack.S[j].x - RadiusPDLB[i].x) + (Stack.S[j].y - RadiusPDLB[i].y)*(Stack.S[j].y - RadiusPDLB[i].y) + (Stack.S[j].z - RadiusPDLB[i].z)*(Stack.S[j].z - RadiusPDLB[i].z) < RadiusPDLR[i] + Stack.S[j] {
                     b = true
                }
            exitwhen j >= Stack.i - 1
             j++
            }
            
            if not b {
                 RadiusPDLB[i].Data.r = RadiusPDLR[i]
                 RadiusPDLB[i] = RadiusPDLB[RadiusPDLI-1]
                 RadiusPDLB[RadiusPDLI-1] = 0
                 RadiusPDLI = RadiusPDLI - 1
            }
            
        exitwhen i >= RadiusPDLI - 1
          i++
        }
    }
    }
    

// _______ ______ _______
// ____ ____ ________ _____ _ _________-____, __ ____ __ ________ ______ _________ _ _____
    private void OrderDropA() { 
        Body b  
        if GetIssuedOrderId() == OrderId("smart") or GetIssuedOrderId() == OrderId("attack") or GetIssuedOrderId() == OrderId("move") or GetIssuedOrderId() == OrderId("patrol") or ( (GetIssuedOrderId() == OrderId("load")) and (SquareRoot( (GetWidgetX(GetOrderedUnit()) - GetWidgetX(GetOrderTargetUnit()) )*(GetWidgetX(GetOrderedUnit())- GetWidgetX(GetOrderTargetUnit()) ) + (GetWidgetY(GetOrderedUnit()) - GetWidgetY(GetOrderTargetUnit()) )*(GetWidgetY(GetOrderedUnit()) - GetWidgetY(GetOrderTargetUnit())) ) > 500  ) ) {
            if GetIssuedOrderId() == OrderId("load") {IssuePointOrder( GetOrderTargetUnit() , "move", GetUnitX(GetOrderedUnit()), GetUnitY(GetOrderedUnit()) )}
             PauseUnit(GetOrderedUnit(), true)
             IssueImmediateOrder(GetOrderedUnit(), "stop")
             PauseUnit(GetOrderedUnit(), false)
            } 
    }

    
    // ______ __________ _______ ___ ______-___
    private void OrderDropCanRunA() {
          Body b = FindBody(GetOrderedUnit())
        if (b != 0) {
            if GetIssuedOrderId() == OrderId("smart") or GetIssuedOrderId() == OrderId("attack") or GetIssuedOrderId() == OrderId("move") or GetIssuedOrderId() == OrderId("patrol") or (GetIssuedOrderId() == OrderId("load"))  {
                if  (b.Motionless) {b.Motionless = false}
                 b.OrderX = GetOrderPointX()
                 b.OrderY = GetOrderPointY()
                 b.OrderTarget = GetOrderTargetUnit()
            }
            elseif (GetIssuedOrderId() == OrderId("stop")) or (GetIssuedOrderId() == 851973) {
                 b.OrderX = b.x
                 b.OrderY = b.y
                 b.OrderTarget = null
            }
        }
    }
    
    // _______ ___________ _______
    private void EventTr_Actions() {
        eventid id = GetTriggerEventId()
        Body b
        if id == EVENT_UNIT_DEATH {
            b = FindBody(GetTriggerUnit())
            b.Data.onDeath(b)
        } elseif id == EVENT_UNIT_SELECTED {
            b = FindBody(GetTriggerUnit())
            b.Data.onSelect(b)
        } elseif id == EVENT_UNIT_DESELECTED {
            b = FindBody(GetTriggerUnit())
            b.Data.onDeselect(b)
        } elseif id == EVENT_UNIT_ISSUED_ORDER {
            b = FindBody(GetOrderedUnit())
            b.Data.onOrder(b, GetIssuedOrderId() )
        } elseif id == EVENT_UNIT_ISSUED_POINT_ORDER {
            b = FindBody(GetOrderedUnit())
            b.Data.onPointOrder(b,GetOrderPointX(),GetOrderPointY(), GetIssuedOrderId() )
        } elseif id == EVENT_UNIT_ISSUED_TARGET_ORDER {
            b = FindBody(GetOrderedUnit())
            b.Data.onTargetOrder(b,GetOrderTarget(), GetIssuedOrderId() )
        }
    }
    

struct Body{
    // __________ ____, __________ __ _________ _____
    real x = 0
    real y = 0
    real z = 0
    // __________ __________ ____
    real kx = 0
    real ky = 0
    real kz = 0

    unit u = null // ____, ____________ _________ ____
    trigger OrderDropTr  // _______ ______ ________
    boolean Fixation = false // ___________ ____
    boolean CanRun = false // __________ _____________ _________ ____ __ _________ _____
    real OrderX // __________ _______ ___ ____-_____
    real OrderY  
    widget OrderTarget = null
    real scale = 1 // ________ _______ GetUnitCurrentScale, ____ _______ ______ ______ _____, __ _______ ___ ________
    Vector v = 0 // ______ ________
    Vector a = 0 // ______ _________
    Vector F = 0 // ______ ____, ______ _____ ____, ___ ___ _ _____ __________, __ _________ ____ ___________ _ _________*_____
    
    BodyData Data
    trigger EventTr
    boolean Motionless = false // ____ _________ true, __ ____ _____________ __ _____ _ __________ _ ______ _________ ___
    boolean Stopped = true
    // ____ _____ ________ ____ __ ______ "_________", __ _______ false
    
    // ______ ________ ____
    real Speed(real vx, real vy, real vz ) { 
         .v.vx = vx
         .v.vy = vy
         .v.vz = vz
         .Motionless = false
         return Module(.v)
    }
    // _________ ________ ____
    real AddSpeed(real vx, real vy, real vz ) { 
         .v.vx = .v.vx + vx
         .v.vy = .v.vy + vy
         .v.vz = .v.vz + vz
         .Motionless = false
         return Module(.v)
    }
 
    real SetRandomSpeed(real ModuleVx,real ModuleVy,real ModuleVz) {
         .v.vx = GetRandomReal(-ModuleVx,ModuleVx)
         .v.vy = GetRandomReal(-ModuleVy,ModuleVy)
         .v.vz = GetRandomReal(-ModuleVz,ModuleVz)
         .Motionless = false
        return Module(.v)
    }
    
    real AddRandomSpeed(real ModuleVx,real ModuleVy,real ModuleVz) {
         .v.vx = .v.vx+GetRandomReal(-ModuleVx,ModuleVx)
         .v.vy = .v.vy+GetRandomReal(-ModuleVy,ModuleVy)
         .v.vz = .v.vz+GetRandomReal(-ModuleVz,ModuleVz)
         .Motionless = false
        return Module(.v)
    }
    
    // ______ _________ ____, _____ ____________ __ ________
    real Acceleration(real ax, real ay, real az ) { 
         .a.vx = ax
         .a.vy = ay
         .a.vz = az
         .Motionless = false
         return Module(.a)
    }
    // _________ _________ ____
    real AddAcceleration(real ax, real ay, real az ) { 
         .a.vx = .a.vx + ax
         .a.vy = .a.vx + ay
         .a.vz = .a.vx + az
         .Motionless = false
         return Module(.a)
    }
    // _____ _____________ ____ _ _________ ___ _ ____ 
    // __ _____ ____ __ ______________ ________ IsBodyExt
    void Start() { 
        if FindBody(.u) == 0 {
             Stack.i= Stack.i +1
             Stack.S[Stack.i] = this
             EnableTrigger(this.OrderDropTr)
             .Motionless = false
             .Stopped = false
             .Data.onStart(this)
        }
    }
    // _______ ____ _____________ __________ _____ ______, _______ ______ "____"
    Force AddAttractionForce(Body B) {
         Force F = Force.create()
         F.a = this
         F.b = B
         Stack.j= Stack.j +1
         Stack.F[Stack.j] = F
        return F
    }
    // ______ _________ _______ ___ ________ _ _______, ________ z ___ _____ _________ ________
    void StartCircleSimple(Body b, real z ) {
              real a = Gi*b.Data.m/((b.x-this.x)*(b.x-this.x) + (b.y-this.y)*(b.y-this.y))
              real V = 5*SquareRoot(a*SquareRoot((b.x-this.x)*(b.x-this.x) + (b.y-this.y)*(b.y-this.y)))
         this.Speed(V*(b.x-this.x)/SquareRoot((b.x-this.x)*(b.x-this.x) + (b.y-this.y)*(b.y-this.y)),-V*(b.y-this.y)/SquareRoot((b.x-this.x)*(b.x-this.x) + (b.y-this.y)*(b.y-this.y)),z)
         this.AddAttractionForce(b)
         b.Fixation = true
         this.Motionless = false
    }
    // _______ ____, _________ ____ __ __________, _ _____________ __________ ________ _ ______ __________
    // _____ __________ ______ __________ _ _________ ________
    Force StartCircle(real x, real y, real V, real at) {
         Force F = Force.create()
         F.v = Vector.create()
         this.Speed(5*V*(x-this.x)/SquareRoot((x-this.x)*(x-this.x) + (y-this.y)*(y-this.y)),-5*V*(y-this.y)/SquareRoot((x-this.x)*(x-this.x) + (y-this.y)*(y-this.y)),0)
         F.a = this
         F.cv = V
         F.at = at
         F.v.vx = x
         F.v.vy = y
         Stack.j= Stack.j +1
         Stack.F[Stack.j] = F
        return F 
    }
    //________ __________ _ _____
    void AddG() { 
         this.Data.gz = -Gravitational_acceleration
         this.Data.gx = 0
         this.Data.gy = 0
         this.Motionless = false
    }
    // _________ _____________ __________ _ _____ (____ 9.81)
    void SetCustomG(real gx,real gy,real gz) { 
         this.Data.gx = gx
         this.Data.gy = gy
         this.Data.gz = gz
         this.Motionless = false
    }
    // _________ ______ ______ _ _________ __ ________ __________
    void AddVFriction(real k) { 
        this.Data.k = k*(0.04/PDLTimer)
    }
        // _________ _____ ______ _ _________ __ ________ __________
    void AddFriction(real mu) { 
        this.Data.mu = mu*(0.04/PDLTimer)
    }
    // _____________ ____________ ____ (0,1)
    void Elastic(real e) { 
         this.Data.elastic = e
    }
    // _________ ______ ____________ ____ _ _____________ ____ _______ ___
    // "__________" ___
    void Radius(real r) { 
          integer i = 0
          boolean b = true
    loop {
        if SquareRoot( (Stack.S[i].x - this.x)*(Stack.S[i].x - this.x) + (Stack.S[i].y - this.y)*(Stack.S[i].y - this.y) + (Stack.S[i].z - this.z)*(Stack.S[i].z - this.z) ) <= r + Stack.S[i].Data.r {
             RadiusPDLB[RadiusPDLI] = this
             RadiusPDLR[RadiusPDLI] = r
             RadiusPDLI = RadiusPDLI + 1
             b = false
        }
    exitwhen i >= Stack.i - 1
     i++
    }
    if b {this.Data.r = r}
     this.Motionless = false
    }
    // ___________ ___________ _________ ____ __ _________ _____
    // _____ ______, _________ _____ _________ __ ______ _______
    void SCanRun(boolean b) {
         this.CanRun = b
         TriggerClearActions(this.OrderDropTr)
        if b {
             TriggerAddAction(this.OrderDropTr,function OrderDropCanRunA)
             SetUnitMoveSpeed(this.u,1)
        }
        else {
             TriggerAddAction(this.OrderDropTr,function OrderDropA)
             SetUnitMoveSpeed(this.u,GetUnitDefaultMoveSpeed(this.u))
        }
         this.Motionless = false
    }
    
    // _________ ________ ____
    void SetFix(boolean flag) {
        .Fixation = true
    }
    
    // ___________ ____ __ _____, ________ ___ ____ "_______ ________" _____ _____
    // _____ ______, ____ _____________ __ _______ __ __________
    void Stop() { 
          integer j = 0
          integer k = 0
        .Stopped = true
        loop {
            if Stack.S[j] == this {
                loop {
                     Stack.S[j+k] = Stack.S[j+k+1]
                exitwhen k >= Stack.i - j - 1
                 k++
                }
                 Stack.S[Stack.i] = 0
                 Stack.i = Stack.i - 1
                return
            }
        exitwhen j >= Stack.i
         j = j + 1
        }
        
         j = 1
        loop {
            if Stack.BMotionless[j] == this {
                 Stack.BMotionless[j] = Stack.BMotionless[Stack.k]
                 Stack.BMotionless[Stack.k] =0
                 Stack.k = Stack.k - 1
            }
        exitwhen j >= Stack.k
         j++
        }
         .Data.onExit(this)
         DisableTrigger(.OrderDropTr)
    }
    // __________ ________ ____ ___ ________ ______
    void Remove(boolean DeleteUnit) { 
         this.Stop()
        if DeleteUnit {
             RemoveUnit(this.u)
             this.u = null
        }
         DisableTrigger(this.OrderDropTr)
         TriggerClearActions(this.OrderDropTr)
         DestroyTrigger(this.OrderDropTr)
         
         DisableTrigger(this.EventTr)
         TriggerClearActions(this.EventTr)
         DestroyTrigger(this.EventTr)
         this.v.destroy()
         this.a.destroy()
         this.destroy()
         this.Data.destroy()
    }
    bool IsStopped() {
        return .Stopped
    }
}


// _______ ____ __ _____ _ _____ ____ _ __________ ___
// __ _________ ____ ____ ___ __ ________ ___ ___________
    void RemoveBody(unit u ) {
          integer i = 0
        loop {
            if Stack.S[i].u == u {
                 Stack.S[i].Remove(false)
                 i = Stack.i
            }
        exitwhen i >= Stack.i
         i++
        }
    }
// ________ ____ __ ______ _____, ___________ __________ _ _____, _________ ______ "____________ ____"
    globals
        Body GUI_LastCreatedBody
    endglobals
    
    Body CreateBody(BodyData data,real x, real y, real z, unit u, real m) {
          Body B = Body.create()
          B.Data = data
          B.Data.BindedBody = B
          
         B.x = x
         B.y = y
         B.z = z
         B.u = u
         B.v = Vector.create()
         B.a = Vector.create()
         B.F = Vector.create()
         if m != 0 {
            B.Data.m = m
        }
        
         GUI_LastCreatedBody = B
         UnitFlyMod(u)
         B.OrderDropTr = CreateTrigger()
         TriggerRegisterUnitEvent( B.OrderDropTr,u, EVENT_UNIT_ISSUED_TARGET_ORDER )
         TriggerRegisterUnitEvent( B.OrderDropTr,u, EVENT_UNIT_ISSUED_POINT_ORDER )
         TriggerRegisterUnitEvent( B.OrderDropTr,u, EVENT_UNIT_ISSUED_ORDER )

         TriggerAddAction( B.OrderDropTr, function OrderDropA)
         DisableTrigger(B.OrderDropTr)
         
         B.EventTr = CreateTrigger()
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_ISSUED_TARGET_ORDER )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_ISSUED_POINT_ORDER )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_ISSUED_ORDER )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_SELECTED )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_DESELECTED )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_DEATH )
         
         TriggerAddAction( B.EventTr, function EventTr_Actions) 
         
         B.Data.onCreate(B)
        return B
    }
// ________ ____ __ ______ _____, __________ ________ __ ___________ _____, _______ _____
    Body CreateBodySimple(BodyData data,unit u) {
          Body B = Body.create()
          B.Data = data
          B.Data.BindedBody = B
          
         B.x = GetWidgetX(u)
         B.y = GetWidgetY(u)
         B.z = GetUnitFlyHeight(u)
         B.u = u
         B.v = Vector.create()
         B.a = Vector.create()
         B.F = Vector.create()
         
        
         GUI_LastCreatedBody = B
         UnitFlyMod(u)
         B.OrderDropTr = CreateTrigger()
         TriggerRegisterUnitEvent( B.OrderDropTr,u, EVENT_UNIT_ISSUED_TARGET_ORDER )
         TriggerRegisterUnitEvent( B.OrderDropTr,u, EVENT_UNIT_ISSUED_POINT_ORDER )
         TriggerRegisterUnitEvent( B.OrderDropTr,u, EVENT_UNIT_ISSUED_ORDER )
        
         TriggerAddAction( B.OrderDropTr, function OrderDropA)
         DisableTrigger(B.OrderDropTr)
          
         B.EventTr = CreateTrigger()
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_ISSUED_TARGET_ORDER )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_ISSUED_POINT_ORDER )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_ISSUED_ORDER )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_SELECTED )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_DESELECTED )
         TriggerRegisterUnitEvent( B.EventTr,u, EVENT_UNIT_DEATH )
         
         TriggerAddAction( B.EventTr, function EventTr_Actions) 
         
         B.Data.onCreate(B)
        return B
    }
 }   
 
//=========================================================================================
//=
//=                             ______ "_______"
//=
//=========================================================================================
#if MSpringes
struct Spring {
    Body a,b                    // _________ ____
    real k,l,kb                 // _________, ___________ _____, _____. _________
    bool IsBindToPoint = false  // _________ __ ____ a _ _____
    real x,y,z                  // _____ ________, ________ ______, ____ _______ ____ IsBindToPoint
    
    bool Visible = false        // ____________ _______
    string EffStr               // ____ _ ______ ________ _______, __ ______ _________ _____ _ __________
    real EffStep = 50           // ___, _____ _______ _____ ___________ _______
    effect array Effects [1000] // _______
    int EffI = 0                // __________ _________ ________
    
    private integer FindInStack() {
        int i = 1
        whilenot(i>Stack.spi) {
            if Stack.Sp[i] == this {
                return i
            }
        i++
        }
        return 0
    }
    private void Start() {
        if .FindInStack() == 0 {
            Stack.spi++
            Stack.Sp[Stack.spi] = this
        }
    }
    // ________ _______ _____ _____ ______, kb - ___________ _________
    static Spring Ini(Body a, Body b, real k, real l, real kb) {
        local Spring sp = Spring.create()
        sp.a = a
        sp.b = b
        sp.k = k
        sp.l = l
        sp.kb = kb
        sp.Start()
        a.Data.onSpringBinded(a,b,sp)
        b.Data.onSpringBinded(b,a,sp)
        return sp
    }
    // ________ _______ _____ _____ _ ______, kb - ___________ _________
    static Spring IniBindedToPoint(Body a, real x, real y, real z,real k, real l, real kb) {
        local Spring sp = Spring.create()
        sp.a = a
        sp.IsBindToPoint = true
        sp.x = x
        sp.y = y
        sp.z = z
        sp.k = k
        sp.l = l
        sp.kb = kb
        sp.Start()
        a.Data.onSpringBinded(a,0,sp)
        return sp
    }
    void SetK(real k) {
        .k = k
    }
    void SetL(real l) {
        if l > 0 {
            .l = l
        }
    }
    void SetKB(real kb) {
        .kb = kb
    }
    // _________ _______ _ _____, _________ a == 0 __ _____ ______ _
    void BindToPoint(Body a,real x,real y,real z) {
        if a != 0 {
            if .a != 0 {
                .a.Data.onSpringUnBinded(.a)
            }
            .a = a
        }
        if .b != 0 {
            .b.Data.onSpringUnBinded(.b)
        }
        .b = 0
        .IsBindToPoint = true
        .x = x
        .y = y
        .z = z
    }
    // _________ _______ _ ____ _____, _________ _ == 0  __ _____ ______ _
    void BindToBody(Body a, Body b) {
        if a != 0 {
            if .a != 0 {
                .a.Data.onSpringUnBinded(.a)
            }
            .a = a
        }
        if .b != 0 {
            .b.Data.onSpringUnBinded(.b)
        }
        .b = b
        .IsBindToPoint = false
        .x = 0
        .y = 0
        .z = 0
    }
    // _________ __ _______ _ _____?
    bool IsBTP(){
        return .IsBindToPoint
    }
    // ________ __ ____________ _______?
    bool IsV(){
        return .Visible
    }
    // _________ ____________ _______
    void SetVisible(bool flag, string estr, real step) {
        if flag {
            .Visible=flag
            .EffStr = estr
            .EffStep = step
        }else{
            .Visible=flag
            .EffStr = ""
            .EffStep = 0.
            int i = 1
            whilenot(i>.EffI){
                DestroyEffect(.Effects[i])
            i++
            }
            .EffI=0
        }
    }
    // __________ _______
    void Render(bool ReDrawAll) {
        if ReDrawAll {
            if not .IsBTP() {
                real spr = SquareRoot( (.b.x-.a.x)*(.b.x-.a.x)+(.b.y-.a.y)*(.b.y-.a.y)+(.b.z-.a.z)*(.b.z-.a.z) ) 
                real nx = (.b.x-.a.x)/spr
                real ny = (.b.y-.a.y)/spr
                real nz = (.b.z-.a.z)/spr
            }else {
                spr = SquareRoot( (.x-.a.x)*(.x-.a.x)+(.y-.a.y)*(.y-.a.y)+(.z-.a.z)*(.z-.a.z) ) 
                nx = (.x-.a.x)/spr
                ny = (.y-.a.y)/spr
                nz = (.z-.a.z)/spr
            }
            int j = 1
            whilenot(j>.EffI){
                if .Effects[j] != null {
                    DestroyEffect(.Effects[j])
                    .Effects[j] = null 
                }
            j++
            }
            .EffI = 0
            j=0
            real i = .EffStep
            destructable platform
            whilenot(i>spr){
                    j++
                     platform = CreateDestructableZ( 'OTis', .a.x + nx*i, .a.y + ny*i,.a.z + nz*i + GetZ(.a.x + nx*i,.a.y + ny*i),0,1.,0)
                    .Effects[j] = AddSpecialEffect( .EffStr, .a.x + nx*i, .a.y + ny*i)
                    RemoveDestructable(platform)
                    platform = null
            i+=.EffStep
            }
            .EffI = j
        }
    }
    // __________ ________ _______
    void Destroy() {
        int i = .FindInStack()
        if i != 0 { 
              Stack.Sp[i] = Stack.Sp[Stack.spi]
              Stack.Sp[Stack.spi] = 0
              Stack.spi--
        }
        .SetVisible(false,"",0.)
        .a.Data.onSpringUnBinded(.a)
        .b.Data.onSpringUnBinded(.b)
        .destroy()
    }
}

// ___________ _______ _____ _____ ______
void DestroySpring(unit u1,unit u2) {
        int i = 1
        whilenot(i>Stack.spi) {
            if ((Stack.Sp[i].a.u == u1)&&(Stack.Sp[i].b.u == u2))||((Stack.Sp[i].a.u == u2)&&(Stack.Sp[i].b.u == u1)) {
                    Stack.Sp[i].Destroy()
            }
        i++
        }
}

// _____ _______
Spring FindSpring(unit u1,unit u2) {
        int i = 1
        whilenot(i>Stack.spi) {
            if ((Stack.Sp[i].a.u == u1)&&(Stack.Sp[i].b.u == u2))||((Stack.Sp[i].a.u == u2)&&(Stack.Sp[i].b.u == u1)) {
                    return Stack.Sp[i]
            }
        i++
        }
        return 0
}

// __________ ______ _______, _______ ______
Spring FindAnySpring(unit u) {
        int i = 1
        whilenot(i>Stack.spi) {
            if ((Stack.Sp[i].a.u == u)||(Stack.Sp[i].b.u == u)) {
                    return Stack.Sp[i]
            }
        i++
        }
        return 0
}

// _____ _ _____ _____ _________
int FindSpringInStack(unit u1,unit u2) {
        int i = 1
        whilenot(i>Stack.spi) {
            if ((Stack.Sp[i].a.u == u1)&&(Stack.Sp[i].b.u == u2))||((Stack.Sp[i].a.u == u2)&&(Stack.Sp[i].b.u == u1)) {
                    return i
            }
        i++
        }
        return 0
}

// _____ _____ _______ _ _____, _____________ _ ____
int FindAnySpringInStack(unit u) {
        int i = 1
        whilenot(i>Stack.spi) {
            if ((Stack.Sp[i].a.u == u)||(Stack.Sp[i].b.u == u)) {
                    return i
            }
        i++
        }
        return 0
}
#endif
//=========================================================================================
//=
//=                             _______ _______ ____________
//=
//=========================================================================================

scope CollFuncPDL {

    
// _____________ __________ ___ ___ ____________
    void Calibration(Body a, Body b) {
      real rs = SquareRoot( (b.x - a.x)*(b.x - a.x) + (b.y - a.y)*(b.y - a.y) + (b.z - a.z)*(b.z - a.z))
      if a.z < b.z {
        a.x = a.x - (b.x-a.x)*(a.Data.r+b.Data.r-rs)/rs
        a.y = a.y - (b.y-a.y)*(a.Data.r+b.Data.r-rs)/rs
        a.z = a.z - (b.z-a.z)*(a.Data.r+b.Data.r-rs)/rs
      } elseif a.z == b.z {
        a.x = a.x - (b.x-a.x)*(a.Data.r+b.Data.r-rs)/rs/2.
        a.y = a.y - (b.y-a.y)*(a.Data.r+b.Data.r-rs)/rs/2.
        a.z = a.z - (b.z-a.z)*(a.Data.r+b.Data.r-rs)/rs/2.
        b.x = b.x + (b.x-a.x)*(a.Data.r+b.Data.r-rs)/rs/2.
        b.y = b.y + (b.y-a.y)*(a.Data.r+b.Data.r-rs)/rs/2.
        b.z = b.z + (b.z-a.z)*(a.Data.r+b.Data.r-rs)/rs/2.
      }else{
        b.x = b.x + (b.x-a.x)*(a.Data.r+b.Data.r-rs)/rs
        b.y = b.y + (b.y-a.y)*(a.Data.r+b.Data.r-rs)/rs
        b.z = b.z + (b.z-a.z)*(a.Data.r+b.Data.r-rs)/rs
      }
    }
    
// ____________ ________ _____ ____________

     void AfterColl(Body a, Body b) {
         Vector V1t 
         Vector V2t 
         Vector V1n 
         Vector V2n 
         Vector r = Vector.create()
         Vector g
         real cosa 
         real cosb 
         real u
         
        r.GetFrom2Loc(a.x,a.y,a.z,b.x,b.y,b.z)
        cosa = CosV(a.v,r)
        cosb = CosV(b.v,r)
        r.Multiply(1/Module(r))
        
            g = Vector.CreateMultiply(r,-Module(a.v)*cosa)
            V1t = Vector.CreateSumm(a.v,g)
            g.destroy()
            
            g = Vector.CreateMultiply(r,-Module(b.v)*cosb)
            V2t = Vector.CreateSumm(b.v,g)
            g.destroy()
            
            u = (a.Data.elastic*b.Data.elastic)*(2*b.Data.m*Module(b.v)*cosb + Module(a.v)*cosa*(a.Data.m - b.Data.m))/(a.Data.m+b.Data.m)
            V1n = Vector.CreateMultiply(r,u)
            
            u = (a.Data.elastic*b.Data.elastic)*(2*a.Data.m*Module(a.v)*cosa - Module(b.v)*cosb*(a.Data.m - b.Data.m))/(a.Data.m+b.Data.m)
            V2n = Vector.CreateMultiply(r,u)
            
            a.v.destroy()
            a.v = Vector.CreateSumm(V1n,V1t)
                if Module(V1n) > ForcedCollSpeed {
                    a.Data.onForcedColl(a,b)
                }else{
                    a.Data.onCollusion(a,b)
                }
            V1n.destroy()
            V1t.destroy()
            //
            b.v.destroy()
            b.v = Vector.CreateSumm(V2n,V2t)
                if Module(V2n) > ForcedCollSpeed {
                    b.Data.onForcedColl(b,a)
                }else{
                    b.Data.onCollusion(b,a)
                }
            V2n.destroy()
            V2t.destroy()
            
            r.destroy()
            if Module(a.v) < StopCollSpeed {
                a.v.vx = 0
                a.v.vy = 0
                a.v.vz = 0
                if a.Data.AllowRest {
                    a.Motionless = true
                }
            }
            else {a.Motionless = false}
            if Module(a.v) < StopCollSpeed {
                a.v.vx = 0
                a.v.vy = 0
                a.v.vz = 0
                if a.Data.AllowRest {
                    a.Motionless = true
                }
            }
            else {b.Motionless = false}

    }

// _______________ ___________, _____ 3 _____, ____________ _________ _____ _ ___________ ______________ ________
    void ParamColl(Body a, real x1, real y1, real z1, real x2, real y2, real z2, real x3, real y3, real z3,real Rest) {
         real nx = ((y2-y1)*(z3-z1) - (y3-y1)*(z2-z1))/SquareRoot(((y2-y1)*(z3-z1) - (y3-y1)*(z2-z1))*((y2-y1)*(z3-z1) - (y3-y1)*(z2-z1)) + ((x3-x1)*(z2-z1) - (x2-x1)*(z3-z1))*((x3-x1)*(z2-z1) - (x2-x1)*(z3-z1)) +((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1))*((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1)))
         real ny = ((x3-x1)*(z2-z1) - (x2-x1)*(z3-z1))/SquareRoot(((y2-y1)*(z3-z1) - (y3-y1)*(z2-z1))*((y2-y1)*(z3-z1) - (y3-y1)*(z2-z1)) + ((x3-x1)*(z2-z1) - (x2-x1)*(z3-z1))*((x3-x1)*(z2-z1) - (x2-x1)*(z3-z1)) +((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1))*((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1)))
         real nz = ((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1))/SquareRoot(((y2-y1)*(z3-z1) - (y3-y1)*(z2-z1))*((y2-y1)*(z3-z1) - (y3-y1)*(z2-z1)) + ((x3-x1)*(z2-z1) - (x2-x1)*(z3-z1))*((x3-x1)*(z2-z1) - (x2-x1)*(z3-z1)) +((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1))*((x2-x1)*(y3-y1) - (x3-x1)*(y2-y1)))
         real vn = nx*a.v.vx + ny*a.v.vy + nz*a.v.vz
            a.v.vx = a.v.vx - 2*nx*vn*Rest
            a.v.vy = a.v.vy - 2*ny*vn*Rest
            a.v.vz = a.v.vz - 2*nz*vn*Rest
            if Abs(vn) > ForcedCollSpeed {
                a.Data.onForcedColl(a,0)
            }else{
                a.Data.onCollusion(a,0)
            }
            a.Motionless = false
    }

// ___________ ____ __ _____, ______ _ __ ____ ______ _______ __ ______
    void HitGround(Body a) {
     real z0 = GetZ(a.x,a.y)
     real z2 = GetZ(a.x+CollPlosk,a.y)
     real z1 = GetZ(a.x,a.y+CollPlosk)
     real nx = (z0-z2)/SquareRoot((z0-z2)*(z0-z2) + (z0-z1)*(z0-z1) + CollPlosk*CollPlosk)
     real ny = (z0-z1)/SquareRoot((z0-z2)*(z0-z2) + (z0-z1)*(z0-z1) + CollPlosk*CollPlosk)
     real nz = CollPlosk/SquareRoot((z0-z2)*(z0-z2) + (z0-z1)*(z0-z1) + CollPlosk*CollPlosk)
     real vn = nx*a.v.vx + ny*a.v.vy + nz*a.v.vz
     real cos = -CollPlosk/((z0-z2)*(z0-z2) + (z0-z1)*(z0-z1) + CollPlosk*CollPlosk)
        if  GetTerrainCliffLevel(a.x,a.y) - GetTerrainCliffLevel(a.x + CliffDist*a.v.vx/(Module(a.v)+0.001) ,a.y + CliffDist*a.v.vy/(Module(a.v)+0.001)) >= 0 {
                a.v.vx = a.v.vx - 2*nx*vn*EarthResist
                a.v.vy = a.v.vy - 2*ny*vn*EarthResist
                a.v.vz = a.v.vz - 2*nz*vn*EarthResist
                real Nx = a.Data.m*Gravitational_acceleration*nx*cos
                real Ny = a.Data.m*Gravitational_acceleration*ny*cos 
                real Nz = a.Data.m*Gravitational_acceleration*nz*cos - a.F.vz
                real N = SquareRoot(Nx*Nx+Ny*Ny+Nz*Nz)
                a.Motionless = false
                        #if MFriction // _____ ______
                            if (a.Data.mu > 0) and (a.Data.m > 0) {
                                    if (Module(a.v)*cos == 0) and (SquareRoot(a.F.vx*a.F.vx+a.F.vy*a.F.vy + a.F.vz*a.F.vz)*cos <= a.Data.mu*N) {
                                        a.F.vx = 0
                                        a.F.vy = 0
                                        a.F.vz = 0
                                        Nx = 0
                                        Ny = 0
                                        Nz = 0
                                        if (a.Data.AllowRest) {
                                            a.Motionless = true
                                        }
                                    } elseif (Module(a.v) > 0) {
                                        if (Module(a.v) <=  a.Data.mu*N/a.Data.m*1.5) {
                                                //a.F.vx = 0
                                                //a.F.vy = 0
                                                //a.F.vz = 0
                                            a.v.vx = 0
                                            a.v.vy = 0
                                            a.v.vz = 0
                                            Nx = 0
                                            Ny = 0
                                            Nz = 0
                                            if (a.Data.AllowRest) {
                                                a.Motionless = true
                                            }
                                        } else {
                                            a.v.vx = a.v.vx -  a.Data.mu*N*a.v.vx/Module(a.v)/a.Data.m
                                            a.v.vy = a.v.vy -  a.Data.mu*N*a.v.vy/Module(a.v)/a.Data.m
                                            a.v.vz = a.v.vz -  a.Data.mu*N*a.v.vz/Module(a.v)/a.Data.m                     
                                        }
                                    }
                                }
                           #endif
                a.F.vx = a.F.vx + Nx
                a.F.vy = a.F.vy + Ny
                a.F.vz = a.F.vz + Nz
            }
            else {
                cos = AngleBLoc(a.x + a.v.vx, a.y + a.v.vy, a.x, a.y)
                ParamColl(a, a.x+a.v.vx + Cos(cos + 0.175),a.y+a.v.vy + Sin(cos + 0.175),0,a.x+a.v.vx + Cos(cos - 0.175),a.y+a.v.vy + Sin(cos - 0.175),0,a.x+a.v.vx + Cos(cos),a.y+a.v.vy + Sin(cos),1,0.8)
                a.Data.onTerrainCliff(a)
            }
        if vn < -ForcedCollSpeed {a.Data.onForcedColl(a,0)}
    }
    
    
    public Body Collb
    public integer CBI = 0

    // _______ ___________ ____________, ________ ________ ___________ _________, _____ ______, __ ____________.
    void Collusion() {
     Body b = FindBody(GetEnumUnit()) 
     integer i = 1
        if b == Collb or b == 0 or b.Data.r == 0 {return}
        real da = (Collb.v.vx-b.v.vx)*(Collb.v.vx-b.v.vx)+(Collb.v.vy-b.v.vy)*(Collb.v.vy-b.v.vy)+(Collb.v.vz-b.v.vz)*(Collb.v.vz-b.v.vz)
        real db = (Collb.x-b.x)*(Collb.v.vx-b.v.vx)+(Collb.y-b.y)*(Collb.v.vy-b.v.vy)+(Collb.z-b.z)*(Collb.v.vz-b.v.vz)
        real dc = (Collb.x-b.x)*(Collb.x-b.x)+(Collb.y-b.y)*(Collb.y-b.y)+(Collb.z-b.z)*(Collb.z-b.z)-(b.Data.r + Collb.Data.r)*(b.Data.r + Collb.Data.r)
        real D  = db*db-da*dc
        if  D >= 0 {
            real tt1  = (-db-SquareRoot(D))/da
            real tt2  = (-db+SquareRoot(D))/da
            if (tt1 >= 0) and (tt2 >= 0) {
                if tt1 > tt2 {
                    tt1 = tt2
                }
                if tt1/PDLTimer <= 1 {
                     Calibration(Collb,b)
                     AfterColl(Collb,b)
                }
            }
        }
    }

    // __________ _______ ___________ ____________, ___________ _____ __________ _____ ______ _______, _ _______ __ __________ _______
    // ____________, _____ ____ _________ _ ____, _ _______ "_________" _______ ___________
    void CollusionSimple() {
     Body b = FindBody(GetEnumUnit())
     integer i = 1
        if b == Collb or b == 0 or b.Data.r == 0 {return}
        if  SquareRoot( (Collb.x-b.x)*(Collb.x-b.x) + (Collb.y-b.y)*(Collb.y-b.y) + (Collb.z-b.z)*(Collb.z-b.z)) < b.Data.r + Collb.Data.r {
            if b.Motionless {b.Motionless = false}
                Calibration(Collb,b)
                AfterColl(Collb,b)
        }
    }
    
    // ___________ ____________ _ ______
    void UnitColl() {
         Body b = FindBody(GetEnumUnit())
        if b == 0 {
            Collb.Data.onUnitColl(Collb,GetEnumUnit())
        }
    }
    
        public rect DestrCollRect
        public Body DestrCollBody
    
    // ___________ ____________ _ ___________ ________    
    void DestrCollusion() {
        DestrCollBody.Data.onDestrColl(DestrCollBody,GetEnumDestructable())
    }
    
    // _______ _______ ______
    void CountGroup() {
        CBI++
    }

    struct CrackedBody {
        Body a
        Body b
        Body c
    }
    
    // ___________ ____ __ 2 _____, _____ ____, _________ _______ 1___ _____ _ _______________ _______, _______ ________
    // _________ _________ _ ________ __ ____-_______
    CrackedBody Crack2b(Body b, real massk, Vector v1, Vector v2, boolean scale) {
     real ang = Asin(b.v.vy/(Module(b.v)+0.001)) + 3.14159/2
     real x = b.x + Cos(ang)*b.Data.r*massk
     real y = b.y + Sin(ang)*b.Data.r*massk
     Body cc    
     CrackedBody cb = CrackedBody.create()
        if (b.Data.r != 0) and (massk < 1) and (massk > 0) {
            cc = CreateBody(icerock.create(),x,y, b.z, CreateUnit(GetOwningPlayer(b.u),GetUnitTypeId(b.u),x,y, GetRandomReal(0,360)) , b.Data.m*massk)
                EnableTrigger(cc.OrderDropTr)
            cc.Data.r = b.Data.r*massk
            cc.Data.k = b.Data.k
            cc.Data.mu = b.Data.mu
            cc.Data.gx = b.Data.gx
            cc.Data.gy = b.Data.gy
            cc.Data.gz = b.Data.gz
            cc.Data.elastic = b.Data.elastic
            cc.CanRun = b.CanRun
            cb.a = cc
            cc.v.destroy()
            cc.v = v1
            if scale {
                SetUnitScale(cc.u,massk*b.scale,massk*b.scale,massk*b.scale)
                cc.scale = massk*b.scale
            }
            cc.Start()
            x = b.x - Cos(ang)*b.Data.r*(1-massk)
            y = b.y - Sin(ang)*b.Data.r*(1-massk)
            cc = CreateBody(icerock.create(),x,y, b.z, CreateUnit(GetOwningPlayer(b.u),GetUnitTypeId(b.u),x,y, GetRandomReal(0,360)) , b.Data.m*(1-massk))
                EnableTrigger(cc.OrderDropTr)
            cc.Data.r = b.Data.r*(1-massk)
            cc.Data.k = b.Data.k
            cc.Data.mu = b.Data.mu
            cc.Data.gx = b.Data.gx
            cc.Data.gy = b.Data.gy
            cc.Data.gz = b.Data.gz
            cc.Data.elastic = b.Data.elastic
            cc.CanRun = b.CanRun
            cb.b = cc
            cc.v.destroy()
            cc.v = v2
            if scale {
                SetUnitScale(cc.u,(1-massk)*b.scale,(1-massk)*b.scale,(1-massk)*b.scale)
                cc.scale =(1-massk)*b.scale
            }
            cc.Start()
           
            if SquareRoot( ((cb.a.x + cb.a.v.vx) - (cb.b.x+cb.b.v.vx))*((cb.a.x + cb.a.v.vx) - (cb.b.x+cb.b.v.vx)) + ((cb.a.y + cb.a.v.vy) - (cb.b.y+cb.b.v.vy))*((cb.a.y + cb.a.v.vy) - (cb.b.y+cb.b.v.vy)) + ((cb.a.z + cb.a.v.vz) - (cb.b.z+cb.b.v.vz)*((cb.a.z + cb.a.v.vz) - (cb.b.z+cb.b.v.vz)) )) < cb.a.Data.r + cb.b.Data.r {
                Calibration(cb.a,cb.b)
                AfterColl(cb.a,cb.b)
            }
            b.Data.onCrack(b,cb)
            b.Remove(true)
            return cb
        }
        elseif b.Data.r == 0 {
            debug msg("|c00BB0000PDL warning:  tried to crack a body without radius |r")
            cb.destroy()
            return 0
        }
        else {
            debug msg("|c00BB0000PDL warning:  tried to crack with invalid massk argument |r")
            cb.destroy()
            return 0
        }
    }

}
//=========================================================================================
//=
//=                                       ______
//=
//=========================================================================================

scope EnginePDL {
    
    // _______ ____
    private struct TStack {
        Body array S [MaxStackSize]
        Force array F [MaxStackSize]
        Body array BMotionless [MaxStackSize]
        Spring array Sp [MaxStackSize]
        integer i = 0
        integer j = 0
        integer k = 0
        integer spi = 0
    }
    
// ________ _______ __________ ______
#if MSpringes
    void SpringRender_Actions() {
    integer j=1
    Spring sp

        if (Stack.spi > 0) {
            whilenot( j > Stack.spi ) {
                sp = Stack.Sp[j]
                if sp.IsV() {

                    sp.Render(( sp.a.x != sp.a.kx )||( sp.a.y != sp.a.ky )||( sp.a.z != sp.a.kz )||( sp.b.x != sp.b.kx )||( sp.b.y != sp.b.ky )||( sp.b.z != sp.b.kz ))
                }
            j++
            }
        }
    }
#endif

void Engine_Action() {
 integer i = 0
 integer j = 0
 integer k = 1
 Body a
 Body b
 group gr
 
// ___________ ________ ___
#if MCustomForces 
   if Stack.j > 0  {
      loop {
       if  (Stack.F[k].cv == 0) and (Stack.F[k].a.Data.m > 0) and (Stack.F[k].b.Data.m > 0) {Stack.F[k].Attraction()}
       elseif Stack.F[k].cv != 0 {Stack.F[k].Circle()}
       exitwhen k>=Stack.j
       k++
       }
   }
#endif

// ___________ ____
#if MKulonForces
    if Stack.i > 0 {  
        k = 1
        while(k <= Stack.i) {
            if Stack.S[k].Data.q != 0 {
                j = k+1
                while(j <= Stack.i) {
                    if (Stack.S[j].Data.q != 0) and (j!=k) {
                        a = Stack.S[k]
                        b = Stack.S[j]
                        real kf01 = SquareRoot( (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)+(a.z-b.z)*(a.z-b.z) )
                        a.F.vx = a.F.vx+KulonFactor*a.Data.q*b.Data.q*(a.x-b.x)/(kf01*kf01*kf01)
                        a.F.vy = a.F.vy+KulonFactor*a.Data.q*b.Data.q*(a.y-b.y)/(kf01*kf01*kf01)
                        a.F.vz = a.F.vz+KulonFactor*a.Data.q*b.Data.q*(a.z-b.z)/(kf01*kf01*kf01)
                        b.F.vx = b.F.vx+KulonFactor*a.Data.q*b.Data.q*(b.x-a.x)/(kf01*kf01*kf01)
                        b.F.vy = b.F.vx+KulonFactor*a.Data.q*b.Data.q*(b.y-a.y)/(kf01*kf01*kf01)
                        b.F.vz = b.F.vx+KulonFactor*a.Data.q*b.Data.q*(b.z-a.z)/(kf01*kf01*kf01)
                    }
                j++
                }
            }
        k++
        }
    }
#endif

// ____________ ______
#if MSpringes
j=1
Spring sp
real spr,sdx,sdy,sdz,spscalar
    if (Stack.spi > 0) {
        whilenot( j > Stack.spi ) {
            sp = Stack.Sp[j]
            if not sp.IsBTP() {
               spr = SquareRoot( (sp.b.x-sp.a.x)*(sp.b.x-sp.a.x)+(sp.b.y-sp.a.y)*(sp.b.y-sp.a.y)+((sp.b.z+sp.b.Data.r)-(sp.a.z+sp.a.Data.r))*((sp.b.z+sp.b.Data.r)-(sp.a.z+sp.a.Data.r)) ) 
               if ( RAbsBJ(spr-sp.l) > MinSpringDeformation) {
                    sdx = (sp.b.x-sp.a.x)*(1-sp.l/spr)
                    sdy = (sp.b.y-sp.a.y)*(1-sp.l/spr)
                    sdz = ((sp.b.z+sp.b.Data.r)-(sp.a.z+sp.a.Data.r))*(1-sp.l/spr)
                    spscalar = (sp.a.v.vx*(sp.b.x-sp.a.x)/spr+sp.a.v.vy*(sp.b.y-sp.a.y)/spr+sp.a.v.vz*((sp.b.z+sp.b.Data.r)-(sp.a.z+sp.a.Data.r))/spr)
                    sp.a.F.vx = sp.a.F.vx + sp.k*sdx - sp.kb*spscalar*(sp.b.x-sp.a.x)/spr
                    sp.a.F.vy = sp.a.F.vy + sp.k*sdy - sp.kb*spscalar*(sp.b.y-sp.a.y)/spr
                    sp.a.F.vz = sp.a.F.vz + sp.k*sdz - sp.kb*spscalar*((sp.b.z+sp.b.Data.r)-(sp.a.z+sp.a.Data.r))/spr
                    spscalar = sp.b.v.vx*(sp.a.x-sp.b.x)/spr+sp.b.v.vy*(sp.a.y-sp.b.y)/spr+sp.b.v.vz*((sp.b.z+sp.b.Data.r)-(sp.a.z+sp.a.Data.r))/spr
                    sp.b.F.vx = sp.b.F.vx - sp.k*sdx - sp.kb*spscalar*(sp.a.x-sp.b.x)/spr
                    sp.b.F.vy = sp.b.F.vy - sp.k*sdy - sp.kb*spscalar*(sp.a.y-sp.b.y)/spr
                    sp.b.F.vz = sp.b.F.vz - sp.k*sdz - sp.kb*spscalar*((sp.b.z+sp.b.Data.r)-(sp.a.z+sp.a.Data.r))/spr
                    sp.a.Motionless = false 
                    sp.b.Motionless = false 
                }
                
            }else{
               spr = SquareRoot( (sp.x-sp.a.x)*(sp.x-sp.a.x)+(sp.y-sp.a.y)*(sp.y-sp.a.y)+(sp.z-(sp.a.z+sp.a.Data.r))*(sp.z-(sp.a.z+sp.a.Data.r)) ) 
               if ( RAbsBJ(spr-sp.l) > MinSpringDeformation) {
                   sdx = (sp.x-sp.a.x)*(1-sp.l/spr)
                   sdy = (sp.y-sp.a.y)*(1-sp.l/spr)
                   sdz = (sp.z-(sp.a.z+sp.a.Data.r))*(1-sp.l/spr)
                    spscalar = (sp.a.v.vx*(sp.x-sp.a.x)/spr+sp.a.v.vy*(sp.y-sp.a.y)/spr+sp.a.v.vz*(sp.z-(sp.a.z+sp.a.Data.r))/spr)
                    sp.a.F.vx = sp.a.F.vx + sp.k*sdx - sp.kb*spscalar*(sp.x-sp.a.x)/spr
                    sp.a.F.vy = sp.a.F.vy + sp.k*sdy - sp.kb*spscalar*(sp.y-sp.a.y)/spr
                    sp.a.F.vz = sp.a.F.vz + sp.k*sdz - sp.kb*spscalar*(sp.z-(sp.a.z+sp.a.Data.r))/spr
                    sp.a.Motionless = false
               } 
            }
        j++
        }
    }
#endif

// Loop __ ________ _____ ___
    if Stack.i > 0 {  
        // ________ ____
        j = 1
        loop {
        
            if (not Stack.S[j].Motionless) or (not b.Data.AllowRest) {
                b = Stack.S[j]
                // _____ _______
                b.Data.onLoop(b)
                
                #if MCollusion // ___________ ____________
                    if b.Data.r > 0 {
                        gr = CreateGroup()
                        GroupEnumUnitsInRange(gr,b.x,b.y, b.Data.r + Module(b.v)+MaxBodyRad, null)
                        CollFuncPDL_CBI = 0
                        call ForGroup(gr, function CountGroup)
                        CollFuncPDL_Collb = b
                        if CollFuncPDL_CBI > CollBodyMax {
                            ForGroup( gr, function CollusionSimple)
                        }else{
                            ForGroup( gr, function Collusion)
                        }
                        GroupEnumUnitsInRange(gr,b.x,b.y, b.Data.r, null)
                        ForGroup( gr, function UnitColl)
                        DestroyGroup(gr)
                        gr = null
                        
                        // _______ Destr
                        SetRect(CollFuncPDL_DestrCollRect,b.x-b.Data.r,b.y-b.Data.r,b.x+b.Data.r,b.y+b.Data.r)
                        CollFuncPDL_DestrCollBody = b
                        EnumDestructablesInRect(CollFuncPDL_DestrCollRect,null,function DestrCollusion)
                        
                    }
                #endif
                
                // ____ ________ ____, __ _____ ____ _____ ____ __ _____, z ___________ [-1.5,0]            
                            if (b.z <= 0) {
                                if b.v.vz < 0 {
                                    b.Data.onGround(b)
                                    b.z = 0.001
                                    HitGround(b)
                                }
                            }
                    // _______ _________ ____
                    if b.Data.m > 0  {
                        b.a.vx = b.F.vx/b.Data.m
                        b.a.vy = b.F.vy/b.Data.m
                        b.a.vz = b.F.vz/b.Data.m
                        #if MFriction// ______ ______
                           if b.Data.k > 0 {
                                b.a.vx = b.a.vx - AddVFrFactor*b.Data.k*b.v.vx/b.Data.m
                                b.a.vy = b.a.vy - AddVFrFactor*b.Data.k*b.v.vy/b.Data.m
                                b.a.vz = b.a.vz - AddVFrFactor*b.Data.k*b.v.vz/b.Data.m
                                if (Module(b.v) < 0.5) and (b.Data.AllowRest) {b.Motionless = true}
                            }
                        #endif
                        b.F.Multiply(0)
                    }
                    // _______ ________
                    if not b.Fixation {                    
                        b.v.vx = b.v.vx + b.a.vx + 1.1*b.Data.gx
                        b.v.vy = b.v.vy + b.a.vy + 1.1*b.Data.gy
                        b.v.vz = b.v.vz + b.a.vz + 1.1*b.Data.gz
                    }
                        // ____________ _ ________ _____
                        if b.z > Height_max {
                            b.z = Height_max - 1
                            b.v.vz = -FactorOfResist*b.v.vz
                            b.Data.onWorldBound(b)
                        }
                        // _____ __ _______ _____
                        if b.x > GetRectMaxX(bj_mapInitialPlayableArea) {
                            b.v.vx = -b.v.vx*(1-FactorOfResist)
                            b.x = GetRectMaxX(bj_mapInitialPlayableArea) - 1
                            b.Data.onWorldBound(b)
                        }
                        elseif b.x < GetRectMinX(bj_mapInitialPlayableArea) {
                            b.v.vx = -b.v.vx*(1-FactorOfResist)
                            b.x = GetRectMinX(bj_mapInitialPlayableArea) + 1
                            b.Data.onWorldBound(b)
                        }
                        if b.y > GetRectMaxY(bj_mapInitialPlayableArea) {
                            b.v.vy = -b.v.vy*(1-FactorOfResist)
                            b.y = GetRectMaxY(bj_mapInitialPlayableArea) - 1
                            b.Data.onWorldBound(b)
                        }
                        elseif b.y < GetRectMinY(bj_mapInitialPlayableArea) {
                            b.v.vy = -b.v.vy*(1-FactorOfResist)
                            b.y = GetRectMinY(bj_mapInitialPlayableArea) + 1 
                            b.Data.onWorldBound(b)
                        }
                    // ___________ ________
                    if Module(b.v) > PDLMaxSpeed {b.v.Multiply(PDLMaxSpeed/(Module(b.v)))}
                    // _________ _______ _____ _________ _ z ____
                    if (Abs(GetZ(b.x + b.v.vx*PDLTimer,b.y + b.v.vy*PDLTimer) - GetZ(b.x,b.y)) > 0) {
                        b.z = b.z - GetZ(b.x + b.v.vx*PDLTimer,b.y + b.v.vy*PDLTimer) + GetZ(b.x,b.y)
                    }
                    // _________ ______ __________
                    b.kx = b.x
                    b.ky = b.y
                    b.kz = b.z


                    // _______ _____ __________ _ ____ __________ _______ _____
                        b.x = b.x + b.v.vx*PDLTimer
                        b.y = b.y + b.v.vy*PDLTimer
                        b.z = b.z + b.v.vz*PDLTimer
                        if b.u != null {
                            if b.kx != b.x {SetUnitX(b.u,b.x)}
                            if b.ky != b.y {SetUnitY(b.u,b.y)}
                            if b.kz != b.z {SetUnitFlyHeight(b.u, b.z, 0)}
                        }
                        //__ ___________ _________ ____
                        if ((Module(b.v) == 0) ) {b.Motionless = true}
            }
            else {
                Stack.S[j].Data.onRest(Stack.S[j])
                Stack.k++ // ____ ______ __________ _ 1 _ _______ _________ __ _________ _______ _______
                Stack.BMotionless[Stack.k] = Stack.S[j]
                Stack.S[j] = Stack.S[Stack.i]
                Stack.S[Stack.i]=0
                Stack.i--
            }
        exitwhen j >= Stack.i
        j++
        }
    }
}

// ____________ __ _______ _________ ___ "___________"
void Motionless_Action() {
 integer i = 1
    loop {
        exitwhen i > Stack.k
            if (Stack.BMotionless[i].Motionless == false)  {
                Stack.i++
                Stack.S[Stack.i] = Stack.BMotionless[i]
                Stack.BMotionless[i] = Stack.BMotionless[Stack.k]
                Stack.BMotionless[Stack.k] =0
                Stack.k--
            }
        i++
    }
}

// _____ _______
        private timer Engine = CreateTimer()
        private timer MotionlessT = CreateTimer()
        private timer SpringT = CreateTimer()
        TStack Stack = 0
        
    void StartEngine() {
            Stack = TStack.create()
            
            // ______ ______ _ _______ "_________" ___
            TimerStart(Engine, PDLTimer, true , function Engine_Action )
            TimerStart(MotionlessT, PDLTimer+0.01, true , function Motionless_Action )
            
            // ______ __________ _________ _______
            TimerStart(SetRadiusPDLT, 0.05 , true, function SetRadiusPDL_Actions)
            
            // ______ __________ ______
            #if MSpringes
                TimerStart(SpringT, SpringRenderingTime , true, function SpringRender_Actions)
            #endif
            
            // ________ _______ ___ ________ widget
            CollFuncPDL_DestrCollRect = Rect(0,0,0,0)
    }

  }

}
`
ОЖИДАНИЕ РЕКЛАМЫ...
0
19
3 года назад
0
Похожие вопросы:

ответ
а статьи читать не научили?
ответ
DarkRaven Best, в картах есть 2 файла с кодом
j и wct
wct содержит тот код который отображается в редакторе
j файл содержит окончательный код который и работает в игре(с переменными, генерируемыми функциями и результатом гуи)
проги для взлома карт тупо перемещает код из j файла в wct (в том числе и генерируемые функции наподобие main)
при попытке сохранения карты код из wct перемещается в j и генерируются системные функции (например main)
но т.к. генерируемые функции уже перенеслись в j из wct получается повторение функций( например main из wct + сгенерированный main)
если же удалить/переименовать лишние функции в редакторе то функции будут сгенерированны не правильно (например в main будет отсутствовать инициализация библиотек)
для того чтобы всё нормально работало надо открыть карту в mpq редакторе и ручками править wct файл вычищая из него всё лишнее
для этого надо хорошо знать джасс
ответ
Kind Ram:
UPD: Перезапуск редактора неожиданно вылечил данную проблему.
ответ
native TriggerRegisterEnterRegion takes trigger whichTrigger, region whichRegion, boolexpr filter returns event
Вы забыли ввести последний аргумент функции.
ответ
Не сов сем по теме, но близко - вот такое можно реализовать на новых функциях 1.31
Увы, полноценного инвентаря на аналогичных функциях пока не выкладывали в общий доступ, каждый пилит себе свою версию.

0
17
3 года назад
0
Ошибочное объявление библиотеки, он не понимает фигурных скобок, cjass включен?!
0
1
3 года назад
0
Привет! Спасибо за отзыв
Да, cJass вроде бы включен но все равно выдает эту же ошибку :{
0
27
3 года назад
0
Ну library так-то с маленькой буквы пишется)
0
1
3 года назад
0
Привет
Да в коде с маленькой я просто скопировал без Л потом добавил в ручную в сообщении по не знанию
0
27
3 года назад
0
AltDream, ты и не весь код впихнул собственно, пришлось кое-что дописывать, чтобы хотя бы сохранить карту
раскрыть
library PDLtypes
        //define MSpringes = false
        interface CrackedBody
        endinterface
        interface Body
        endinterface
        interface Spring
        endinterface
        
        interface BodyData
                real m = 0               
                real gx = 0 
                real gy = 0
                real gz = -Gravitational_acceleration
                
                real mu = 0 
                real k =  0 
                real r =  0 
                real q =  0 
                
                real elastic = GetRandomReal(0.7,1)
                boolean AllowRest = true 
                
                Body BindedBody = 0
                        
                method onCreate takes Body b returns nothing defaults nothing
                method onGround takes Body b returns nothing defaults nothing
                method onCollusion takes Body b, Body b2 returns nothing defaults nothing
                method onForcedColl takes Body b, Body b2 returns nothing defaults nothing
                method onDestrColl takes Body b, destructable destr returns nothing defaults nothing
                method onUnitColl takes Body b, unit u returns nothing defaults nothing
                method onWorldBound takes Body b returns nothing defaults nothing 
                method onCrack takes Body b, CrackedBody cb returns nothing defaults nothing
                method onTerrainCliff takes Body b returns nothing defaults nothing
                method onRest takes Body b returns nothing defaults nothing
                method onSelect takes Body b returns nothing defaults nothing
                method onDeselect takes Body b returns nothing defaults nothing
                method onDeath takes Body b returns nothing defaults nothing
                method onExit takes Body b returns nothing defaults nothing
                method onPointOrder takes Body b, real TargetX, real TargetY, integer OrdId returns nothing defaults nothing
                method onTargetOrder takes Body b, widget target, integer OrdId returns nothing defaults nothing
                method onOrder takes Body b, integer OrdId returns nothing defaults nothing
                method onStart takes Body b returns nothing defaults nothing
                method onLoop takes Body b returns nothing defaults nothing
                //#if MSpringes
                    method onSpringBinded takes Body a, Body b, Spring sp returns nothing defaults nothing
                    method onSpringUnBinded takes Body a returns nothing defaults nothing
                //#endif
        endinterface
endlibrary
У меня только в таком случае начало хотя бы карту запускать. Пробовал заменить MSpringes на булевую глобалку и всё равно безрезультатно, жалуется на "Expected of name" при endif, хз что там не так
Загруженные файлы
0
17
3 года назад
0
rsfghd, у меня твой код выдает такую ошибку
Загруженные файлы
0
27
3 года назад
Отредактирован rsfghd
0
Vlod, потому что сджасс нужно выключить

ну либо обвести эту либу блоками //!nocjass и //!endnocjass
Загруженные файлы
0
1
3 года назад
Отредактирован AltDream
0
Вы правы, код очень длинный 1000++ строк для системы, поэтому я не стал изначально сюда его кидать целиком.
Я попробовал заменить часть кода Вашей версией но теперь выдает ошибку в другом месте T.T
Nested Struct
First struct declaration
Я выложил весь код в первом посте
Еще карта прикреплена к посту
Буду очень благодарен если поможете заставить код рабочим для импорта

P.S. Коментарии кода не отображаются у меня потому что Варик не читает русский у меня Q.Q
0
27
3 года назад
Отредактирован rsfghd
0
AltDream,
Я попробовал заменить часть кода Вашей версией но теперь выдает ошибку в другом месте
Я ж писал:
ты и не весь код впихнул собственно, пришлось кое-что дописывать, чтобы хотя бы сохранить карту
Ошибка у тебя говорит о том, что такое название уже существует, потому что мне пришлось дописывать пустышки, чтобы оно сохранило спокойно

попробуй это в общем
раскрыть
//!nocjass
library PDLtypes
        //define MSpringes = false
        interface BodyData
                real m = 0               
                real gx = 0 
                real gy = 0
                real gz = -Gravitational_acceleration
                
                real mu = 0 
                real k =  0 
                real r =  0 
                real q =  0 
                
                real elastic = GetRandomReal(0.7,1)
                boolean AllowRest = true 
                
                Body BindedBody = 0
                        
                method onCreate takes Body b returns nothing defaults nothing
                method onGround takes Body b returns nothing defaults nothing
                method onCollusion takes Body b, Body b2 returns nothing defaults nothing
                method onForcedColl takes Body b, Body b2 returns nothing defaults nothing
                method onDestrColl takes Body b, destructable destr returns nothing defaults nothing
                method onUnitColl takes Body b, unit u returns nothing defaults nothing
                method onWorldBound takes Body b returns nothing defaults nothing 
                method onCrack takes Body b, CrackedBody cb returns nothing defaults nothing
                method onTerrainCliff takes Body b returns nothing defaults nothing
                method onRest takes Body b returns nothing defaults nothing
                method onSelect takes Body b returns nothing defaults nothing
                method onDeselect takes Body b returns nothing defaults nothing
                method onDeath takes Body b returns nothing defaults nothing
                method onExit takes Body b returns nothing defaults nothing
                method onPointOrder takes Body b, real TargetX, real TargetY, integer OrdId returns nothing defaults nothing
                method onTargetOrder takes Body b, widget target, integer OrdId returns nothing defaults nothing
                method onOrder takes Body b, integer OrdId returns nothing defaults nothing
                method onStart takes Body b returns nothing defaults nothing
                method onLoop takes Body b returns nothing defaults nothing
                //#if MSpringes
                    method onSpringBinded takes Body a, Body b, Spring sp returns nothing defaults nothing
                    method onSpringUnBinded takes Body a returns nothing defaults nothing
                //#endif
        endinterface
endlibrary
//!endnocjass
0
1
3 года назад
Отредактирован AltDream
0
rsfghd, Спасибо за исправления
Но все равно дает ошибки далее в коде T.T
Та часть что Вы исправили по видимому работает
0
17
3 года назад
0
потому что сджасс нужно выключить
Это понятно, но я нахожу странным отключение cjass в коде, в котором используются его директивы типа #if и есть элементы синтаксиса типа {}
0
27
3 года назад
0
Vlod,
в котором используются его директивы типа #if
это пришлось убрать ибо я хз почему оно ошибку выдаёт, можешь сам исправить, у меня не получилось

AltDream,
Та часть что Вы исправили по видимому работает
в твоём случае это всё равно толку не имеет, я правда хз как это поправить, странное поведение сджасса

странно, что такая проблема наблюдается даже в карте приложенной к посту
Чтобы оставить комментарий, пожалуйста, войдите на сайт.