Здраствуйте!
Я пытался перенести старенькое заклинание, которое я нашел в Барахолке, в свою карту.
И при сохранении выдает ошибку в коде и карта больше не открывается в Варике...
И при сохранении выдает ошибку в коде и карта больше не открывается в Варике...
Помогите исправить для не-Кодировщика!
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)
}
}
}
`
ОЖИДАНИЕ РЕКЛАМЫ...
Чтобы оставить комментарий, пожалуйста, войдите на сайт.
Да, cJass вроде бы включен но все равно выдает эту же ошибку :{
Да в коде с маленькой я просто скопировал без Л потом добавил в ручную в сообщении по не знанию
Отредактирован rsfghd
Отредактирован AltDream
Я попробовал заменить часть кода Вашей версией но теперь выдает ошибку в другом месте T.T
Nested Struct
First struct declaration
Еще карта прикреплена к посту
Буду очень благодарен если поможете заставить код рабочим для импорта
Отредактирован rsfghd
Отредактирован AltDream
Но все равно дает ошибки далее в коде T.T