home *** CD-ROM | disk | FTP | other *** search
/ WarCraft 2000 - Nuclear Epidemic / W2000.nrg / SOURCE.War2000 / Legion.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-01  |  11.8 KB  |  599 lines
  1. //                   ╬≥≡ Σ√
  2. #include "ddini.h"
  3. #include "ResFile.h"
  4. #include "FastDraw.h"
  5. #include "mgraph.h"
  6. #include "mouse.h"
  7. #include "menu.h"
  8. #include "MapDiscr.h"
  9. #include <math.h>
  10. const idrx[8]={0,1,1,1,0,-1,-1,-1};
  11. const idry[8]={-1,-1,0,1,1,1,0,-1};
  12. void Legion::CreateLegionInSquare(byte x,byte y,
  13.                                   byte x1,byte y1,byte Mask){
  14.     NMask=Mask;
  15.     byte rx,ry;
  16.     byte rx1,ry1;
  17.     if(x>x1){rx=x1;rx1=x;}else{rx=x;rx1=x1;};
  18.     if(y>y1){ry=y1;ry1=y;}else{ry=y;ry1=y1;};
  19.     if(rx<1)rx=1;
  20.     if(rx>msx)rx=msx;
  21.     if(rx1<1)rx1=1;
  22.     if(rx1>msx)rx1=msx;
  23.     if(ry<1)rx=1;
  24.     if(ry>msy)ry=msy;
  25.     if(ry1<1)ry1=1;
  26.     if(ry1>msy)ry1=msy;
  27.     NNeed=0;
  28.     Member=NULL;
  29.     word NM=0;
  30. //    word MID;
  31.     word NNeed1=NNeed;
  32.     for(byte ky=ry;ky<=ry1;ky++)
  33.         for(byte kx=rx;kx<=rx1;kx++){
  34.             OneObject* OB;
  35.             __asm{
  36.                 xor    eax,eax
  37.                 mov    al,kx
  38.                 mov    ah,ky
  39.                 mov    eax,[Mops+eax]
  40.                 cmp    ax,0ffffh
  41.                 je    NoGo__1
  42.                 shl    eax,2
  43.                 mov    eax,[Group+eax]
  44.                 mov    OB,eax
  45.             };
  46.             if(OB->NMask&NMask)NM++;
  47.  
  48. NoGo__1:;
  49.         };
  50.     //NM-Ωεδ-Γε Γ√Σσδσφφ√⌡ ∞εφ±≥≡εΓ
  51.     word rlx=rx1-rx+1;
  52.     word rly=ry1-ry+1;
  53.     word ActSize=rlx*rly;
  54.     word DistSize=ActSize-(ActSize>>3);
  55.     if(NM<DistSize){//φσεß⌡εΣΦ∞α ∩σ≡σ±≥≡εΘΩα Γ ΩΓαΣ≡α≥φ≤■ ±≥≡≤Ω≥≤≡≤
  56.         //Γ√≈Φ±δ σ∞ ≡ατ∞σ≡ ±≥≡≤Ω≥≤≡√
  57.         int Sqs=int(sqrt(NM));
  58.         int Glx=Sqs;
  59.         int Gly=Sqs;
  60.         if(Glx*Gly>NM)Glx--;
  61.         if(Glx*Gly<NM)Glx++;else
  62.         {
  63.             if(Glx*Gly>NM)Gly--;
  64.             if(Glx*Gly<NM)Gly++;
  65.         };
  66.         XL1=byte(int(rx+rx1-Glx)>>1);
  67.         YL1=byte(int(ry+ry1-Gly)>>1);
  68.         if(XL1<=0)XL1=1;
  69.         if(YL1<=0)YL1=1;
  70.         if(XL1+Glx>msx)XL1=msx-Glx+1;
  71.         if(YL1+Gly>msy)YL1=msy-Gly+1;
  72.         SizeX1=Glx;
  73.         SizeY1=Gly;
  74.         NNeed=Glx*Gly;
  75.     }else{
  76.         XL1=rx;
  77.         YL1=ry;
  78.         SizeX1=rx1-rx+1;
  79.         SizeY1=ry1-ry+1;
  80.         NNeed=rx*ry;
  81.     }
  82.     NMemb=0;
  83.     //Γφε±Φ∞ ≥Γα≡σΘ Γ ±∩Φ±εΩ
  84.     if(NNeed1<NNeed){
  85.         if(int(Member))free(Member);
  86.         Member=new word[NNeed];
  87.     };
  88.     for(ky=ry;ky<=ry1;ky++)
  89.         for(byte kx=rx;kx<=rx1;kx++){
  90.             OneObject* OB;
  91.             word MID;
  92.             __asm{
  93.                 xor    eax,eax
  94.                 mov    al,kx
  95.                 mov    ah,ky
  96.                 mov    eax,[Mops+eax]
  97.                 mov    MID,ax
  98.                 cmp    ax,0ffffh
  99.                 je    NoGo__
  100.                 shl    eax,2
  101.                 mov    eax,[Group+eax]
  102.                 mov    OB,eax
  103.             };
  104.             if(OB->NMask&NMask)Member[NMemb]=MID;
  105.             NMemb++;
  106. NoGo__:;
  107.         };
  108.     maxDeplX=SizeX1<127?(SizeX1<<1):128;
  109.     maxDeplY=SizeY1<127?(SizeY1<<1):128;
  110.     critDeplX=SizeX1<63?(SizeX1<<2):128;
  111.     critDeplY=SizeY1<63?(SizeY1<<2):128;
  112.     XL2=XL1;
  113.     YL2=YL1;
  114.     SizeX2=SizeX1;
  115.     SizeY2=SizeY1;
  116.     minx=0;
  117.     miny=0;
  118.     maxx=0;
  119.     maxy=0;
  120.     NoFire=false;
  121.     NoInitiate=false;
  122.     NoMotion=false;
  123.     Mobil=false;
  124.     needMobil=false;
  125. };
  126. void Legion::CreateLegionFromSelection(byte Mask){
  127.     minx=255;
  128.     miny=255;
  129.     maxx=0;
  130.     maxy=0; 
  131.     word realNm=0;
  132.     word MID;
  133.     OneObject* OB;
  134.     byte xo,yo;
  135.     word Nsel=NSL[MyNation];
  136.     word* SMon=Selm[MyNation];
  137.     for(word k=0;k<Nsel;k++){
  138.         OB=Group[SMon[k]];
  139.         if(int(OB)){
  140.             xo=OB->x;
  141.             yo=OB->y;
  142.             if(xo<minx)minx=xo;
  143.             if(yo<miny)miny=yo;
  144.             if(xo>maxx)maxx=xo;
  145.             if(yo>maxy)maxy=yo;
  146.             realNm++;
  147.             OB->TempFlag=true;
  148.             OB->Wars=this;
  149.             OB->Mobilised=false;
  150.         };
  151.     };
  152. //    if(!NMemb)return;
  153.     NMemb=realNm;
  154.     realNm=0;
  155.     CalculateBestComposition();
  156.     Member=new word[NNeed];
  157.     for(byte ky=miny;ky<=maxy;ky++)
  158.         for(byte kx=minx;kx<=maxx;kx++){
  159.             __asm{
  160.                 xor        eax,eax
  161.                 mov        al,kx
  162.                 mov        ah,ky
  163.                 mov        ax,[Mops+eax*2]
  164.                 cmp        ax,0FFFFh
  165.                 je        NextCycl
  166.                 mov        MID,ax
  167.                 mov        eax,[Group+eax*4]
  168.                 mov        OB,eax
  169.             };
  170.             if(OB->TempFlag){
  171.                 OB->TempFlag=false;
  172.                 Member[realNm]=MID;
  173.                 realNm++;
  174.             };
  175. NextCycl:;
  176.         };
  177.     NoFire=false;
  178.     NoInitiate=false;
  179.     NoMotion=false;
  180.     Mobil=false;
  181.     needMobil=false;
  182. };
  183. //minx,maxx->NNeed,SizeX1,SizeY1
  184. void Legion::CalculateBestComposition(){
  185.     word rx=minx;
  186.     word ry=miny;
  187.     word rx1=maxx;
  188.     word ry1=maxy;
  189.     word rlx=maxx-minx+1;
  190.     word rly=maxy-miny+1;
  191.     word ActSize=rlx*rly;
  192.     word DistSize=ActSize-(ActSize>>3);
  193.     if(NMemb<DistSize){//φσεß⌡εΣΦ∞α ∩σ≡σ±≥≡εΘΩα Γ ΩΓαΣ≡α≥φ≤■ ±≥≡≤Ω≥≤≡≤
  194.         //Γ√≈Φ±δ σ∞ ≡ατ∞σ≡ ±≥≡≤Ω≥≤≡√
  195.         int Sqs=int(sqrt(NMemb));
  196.         int Glx=Sqs+1;
  197.         int Gly=Sqs+1;
  198.         if(Glx*Gly>NMemb)Glx--;
  199.         if(Glx*Gly<NMemb)Glx++;else
  200.         {
  201.             if(Glx*Gly>NMemb)Gly--;
  202.             if(Glx*Gly<NMemb)Gly++;
  203.         };
  204.         SizeX1=Glx;
  205.         SizeY1=Gly;
  206.         NNeed=Glx*Gly;
  207.     }else{
  208.         SizeX1=rx1-rx+1;
  209.         SizeY1=ry1-ry+1;
  210.         NNeed=SizeX1*SizeY1;
  211.     }
  212. };
  213. void Legion::CalculateArea(){
  214.     if(NMemb){
  215.         minx=255;
  216.         miny=255;
  217.         maxx=0;
  218.         maxy=0;
  219.         byte xo,yo;
  220.         word realNm=0;
  221.         for(word k=0;k<NMemb;k++){
  222.             OneObject* OB=Group[Member[k]];
  223.             if(OB){
  224.                 Member[realNm]=Member[k];
  225.                 xo=OB->x;
  226.                 yo=OB->y;
  227.                 if(xo<minx)minx=xo;
  228.                 if(xo>maxx)maxx=xo;
  229.                 if(yo<miny)miny=yo;
  230.                 if(yo>maxy)maxy=yo;
  231.                 realNm++;
  232.             };
  233.         };
  234.         NMemb=realNm;
  235.         if(NMemb){
  236.             if(maxx-minx+1>critDeplX||
  237.                 maxy-miny+1>critDeplY)needMobil=true;
  238.             else needMobil=false;
  239.         };
  240.     };
  241. };
  242. void Legion::CalculateSoldiers(){
  243.     minx=255;
  244.     miny=255;
  245.     maxx=0;
  246.     maxy=0; 
  247.     word realNm=0;
  248.     word MID;
  249.     OneObject* OB;
  250.     byte xo,yo;
  251.     for(word k=0;k<NMemb;k++){
  252.         MID=Member[k];
  253.         if(MID!=0xFFFF){
  254.             OB=Group[MID];
  255.             if(int(OB)&&OB->Wars==this){
  256.                 xo=OB->x;
  257.                 yo=OB->y;
  258.                 if(xo<minx)minx=xo;
  259.                 if(yo<miny)miny=yo;
  260.                 if(xo>maxx)maxx=xo;
  261.                 if(yo>maxy)maxy=yo;
  262.                 realNm++;
  263.                 OB->TempFlag=true;
  264.             };
  265.         };
  266.     };
  267.     if(!NMemb)return;
  268.     NMemb=realNm;
  269.     realNm=0;
  270.     CalculateBestComposition();
  271.     for(byte ky=miny;ky<=maxy;ky++)
  272.         for(byte kx=minx;kx<=maxx;kx++){
  273.             __asm{
  274.                 xor        eax,eax
  275.                 mov        al,kx
  276.                 mov        ah,ky
  277.                 mov        ax,[Mops+eax*2]
  278.                 cmp        ax,0FFFFh
  279.                 je        NextCycl
  280.                 mov        MID,ax
  281.                 mov        eax,[Group+eax*4]
  282.                 mov        OB,eax
  283.             };
  284.             if(OB->TempFlag){
  285.                 OB->TempFlag=false;
  286.                 Member[realNm]=MID;
  287.                 realNm++;
  288.             };
  289. NextCycl:;
  290.         };
  291. };
  292. inline word CalcHSpace(byte x,byte y,byte x1){
  293.     if(y<1||y>msy)return 0;
  294.     word NF=0;
  295.     __asm{
  296.         xor        eax,eax
  297.         xor        ebx,ebx
  298.         xor        ecx,ecx
  299.         mov        al,x
  300.         mov        ah,y
  301.         mov        cl,x1
  302.         sub        cl,x
  303.         inc        cl
  304. LpStart:
  305.         cmp        [TrMap+eax],0
  306.         jnz        LockedCell1
  307.         inc        bx
  308. LockedCell1:
  309.         inc        al
  310.         loop    LpStart
  311.         mov        NF,bx
  312.     };
  313.     return    NF;
  314. };
  315. inline word CalcVSpace(byte x,byte y,byte y1){
  316.     if(x<1||x>msx)return 0;
  317.     word NF=0;
  318.     __asm{
  319.         xor        eax,eax
  320.         xor        ebx,ebx
  321.         xor        ecx,ecx
  322.         mov        al,x
  323.         mov        ah,y
  324.         mov        cl,y1
  325.         sub        cl,ah
  326.         inc        cl
  327. LpStart:
  328.         cmp        [TrMap+eax],0
  329.         jnz        LockedCell1
  330.         inc        bx
  331. LockedCell1:
  332.         inc        ah
  333.         loop    LpStart
  334.         mov        NF,bx
  335.     };
  336.     return    NF;
  337. };
  338. //±ετΣασ≥ τεφ≤,Γ Ωε≥ε≡≤■ ±εδΣα≥√ Σεδµφ√ ∩σ≡σ∞σ±≥Φ≥ⁿ± ,
  339. //÷σφ≥≡ τεφ√-≥ε≈Ωα ± Ωεε≡ΣΦφα≥α∞Φ (x,y)
  340. //∩σ≡σΣ ²≥Φ∞ Σεδµφα Γ√τ√Γα≥ⁿ±α CalculateSoldiers()
  341. void Legion::CreateFinalZone(byte x,byte y){
  342.     word NFree=0;
  343.     int x0=x-(SizeX1>>1);
  344.     int    y0=y-(SizeY1>>1);
  345.     if(x0<1)x0=1;
  346.     if(y0<1)y0=1;
  347.     int x1=x0+SizeX1-1;
  348.     int y1=y0+SizeY1-1;
  349.     if(x1>msx){
  350.         x1=msx-SizeX1+1;
  351.         x0=x1-SizeX1+1;
  352.     };
  353.     if(y1>msy){
  354.         y1=msy-SizeY1+1;
  355.         y0=y1-SizeY1+1;
  356.     };
  357.     StonesInside=false;
  358.     //±≈Φ≥ασ∞ Ωεδ-Γε Σε±≥≤∩φ√⌡ ∞σ±≥ Γ ²≥ε∞ ΩΓΣ≡α≥σ
  359.     __asm{
  360.         xor        eax,eax
  361.         mov        bl,byte ptr x1
  362.         mov        bh,byte ptr y1
  363.         mov        al,byte ptr x0
  364.         mov        ah,byte ptr y0
  365. CycleStart1:
  366.         cmp        byte ptr [TrMap+eax],0
  367.         jne        LockedCell
  368.         inc        NFree
  369. LockedCell:
  370.         inc        al
  371.         cmp        al,bl
  372.         jbe        CycleStart1
  373.         mov        al,byte ptr x0
  374.         inc        ah
  375.         cmp        ah,bh
  376.         jbe        CycleStart1
  377.     };
  378.     word MaxRes=0;
  379.     word Resz;
  380.     byte DIR1;
  381.     word rf=0;
  382.     word rrr;
  383.     while(NMemb>NFree){
  384.         StonesInside=true;
  385.         //∩√≥ασ∞±  ≡ατΣΓΦφ≤≥ⁿ τεφ≤
  386.         //ΓφΦτ
  387.         Resz=CalcHSpace(x0,y1+1,x1);
  388.         rrr=NFree+Resz>NMemb?NFree+10000-Resz:NFree+Resz;
  389.         if(rrr>rf){
  390.             rf=rrr;
  391.             MaxRes=Resz;
  392.             DIR1=0;
  393.         };
  394.         //ΓΓσ≡⌡
  395.         Resz=CalcHSpace(x0,y0-1,x1);
  396.         rrr=NFree+Resz>NMemb?NFree+10000-Resz:NFree+Resz;
  397.         if(rrr>rf){
  398.             rf=rrr;
  399.             MaxRes=Resz;
  400.             DIR1=1;
  401.         };
  402.         //Γ∩≡αΓε
  403.         Resz=CalcVSpace(x1+1,y0,y1);
  404.         rrr=NFree+Resz>NMemb?NFree+10000-Resz:NFree+Resz;
  405.         if(rrr>=rf){
  406.             rf=rrr;
  407.             MaxRes=Resz;
  408.             DIR1=2;
  409.         };
  410.         //ΓδσΓε
  411.         Resz=CalcVSpace(x0-1,y0,y1);
  412.         rrr=NFree+Resz>NMemb?NFree+10000-Resz:NFree+Resz;
  413.         if(rrr>rf){
  414.             rf=rrr;
  415.             MaxRes=Resz;
  416.             DIR1=0;
  417.         };
  418.         if(MaxRes==0)break;
  419.         switch(DIR1){
  420.         case 0:    y1++;
  421.                 break;
  422.         case 1: y0--;
  423.                 break;
  424.         case 2: x1++;
  425.                 break;
  426.         case 3: y0--;
  427.                 break;
  428.         };
  429.         NFree+=MaxRes;
  430.     };
  431.     destX=x0;
  432.     destY=y0;
  433.     destX1=x1;
  434.     destY1=y1;
  435. };
  436. //∩ε±√δασ≥ ±εδΣα≥ Γ Γ√ß≡αφφ≤■ τεφ≤
  437. void Legion::SendSoldiers(){
  438.     word MID;
  439.     OneObject* OB;
  440.     byte tx=destX;
  441.     byte ty=destY;
  442.     for(word k=0;k<NMemb;k++){
  443.         MID=Member[k];
  444.         if(MID!=0xFFFF){
  445.             OB=Group[MID];
  446.             while(TrMap[ty][tx]){
  447.                 tx++;
  448.                 if(tx>destX1){
  449.                     tx=destX;
  450.                     ty++;
  451.                 };
  452.             };
  453.             OB->ClearOrders();
  454.             OB->SendInGroup(tx,ty,destX,destY,destX1,destY1);
  455.             OB->PathBroken=false;
  456.             tx++;
  457.             if(tx>destX1){
  458.                 tx=destX;
  459.                 if(ty<msy)ty++;
  460.             };
  461.         };
  462.     };
  463. };
  464. bool Legion::MobilisationIsDone(){
  465.     return false;
  466. };
  467. bool Legion::CompositionIsDone(){
  468.     return false;
  469. };
  470. void Legion::Compose(){
  471. };
  472. void Legion::Mobilisate(){
  473. };
  474. void Legion::MoveTo(byte x,byte y){
  475. };
  476. void Legion::AttackObj(word ObjID){
  477. };
  478. void Legion::Process(){
  479.     if(NMemb==0)return;
  480.     CalculateArea();
  481.     Ordering=GetOrderDegree();
  482.     if(needMoveTo){
  483.         if(Ordering>=3)Order3Time++;else Order3Time=0;
  484.         if(Order3Time>20)needMoveTo=false;
  485.     };
  486.     if(needCompactness&&!TempMobil){
  487.         if(Ordering==0){
  488.             byte XG=FinX;
  489.             byte YG=FinY;
  490.             if(FinX>maxx)XG=maxx;
  491.             if(FinX<minx)XG=maxy;
  492.             if(FinY>maxy)YG=maxy;
  493.             if(FinY<miny)YG=miny;
  494.             CreateFinalZone(XG,YG);
  495.             if(!StonesInside){
  496.                 SendSoldiers();
  497.                 TempMobil=true;
  498.             }else CreateFinalZone(FinX,FinY);
  499.         };
  500.     };
  501.     if(TempMobil&&Ordering>=2){
  502.         CreateFinalZone(FinX,FinY);
  503.         SendSoldiers();
  504.         TempMobil=false;
  505.     };
  506. };
  507. void Legion::PreProcess(){
  508.  
  509. };
  510. void OneObject::ClearOrders(){
  511.     if(int(InLineCom))FreeAsmLink();
  512.     while(int(LocalOrder)){
  513.         Order1* Loc1=LocalOrder->NextOrder;
  514.         FreeOrdBlock(LocalOrder);
  515.         LocalOrder=Loc1;
  516.     };
  517.     Attack=0;
  518. }
  519. void SendInGroupLink(OneObject* OBJ);
  520. void OneObject::SendInGroup(byte tx,byte ty,byte x0,byte y0,
  521.                             byte x1,byte y1){
  522.     lastX=tx;
  523.     lastY=ty;
  524.     destX=x0;
  525.     destY=y0;
  526.     destX1=x1;
  527.     destY1=y1;
  528.     if(MoveInRect)return;
  529.     Order1* Or1=GetOrdBlock();
  530.     if(!int(Or1))return;
  531.     Or1->NextOrder=LocalOrder;
  532.     Or1->OrderType=22;
  533.     Or1->OrderTime=0;
  534.     Or1->DoLink=&SendInGroupLink;
  535.     Order1* LOR=LocalOrder;
  536.     if(int(InLineCom)){
  537.         FreeAsmLink();
  538.     };
  539.     LocalOrder=Or1;
  540.     //OrderReport=NULL;
  541.     //MessageKind=0;
  542.     //Sender=0xFFFF;
  543.     MoveInRect=true;
  544.     DrawUp=true;
  545. }; 
  546. void SendInGroupLink(OneObject* OBJ){
  547.     if(int(OBJ->Wars)){
  548.         if(!OBJ->Wars->needMoveTo){
  549.             Order1* Loc1=OBJ->LocalOrder->NextOrder;
  550.  
  551.         };
  552.     };
  553.     byte x=OBJ->x;
  554.     byte y=OBJ->y;
  555.     if(x>=OBJ->destX&&x<=OBJ->destX1&&y>=OBJ->destY&&y<=OBJ->destY1&&OBJ->PathBroken){
  556.         byte nx=x+idrx[OBJ->Direction];
  557.         byte ny=y+idry[OBJ->Direction];
  558.         if(nx>=OBJ->destX&&nx<=OBJ->destX1&&ny>=OBJ->destY&&
  559.             ny<=OBJ->destY1&&!TrMap[ny][nx]){
  560.                 OBJ->LoadAnimation(1,1,0);
  561.                 AddAsk(OBJ->Index|0x8000,x,y,idrx[OBJ->Direction],idry[OBJ->Direction]);
  562.         };
  563.         OBJ->lastX=x;
  564.         OBJ->lastY=y;
  565.         return;
  566.     };
  567.     if(int(OBJ->InLineCom))OBJ->FreeAsmLink();
  568.     if(OBJ->x!=OBJ->lastX||OBJ->y!=OBJ->lastY)
  569.         OBJ->CreatePath(OBJ->lastX,OBJ->lastY);
  570.     OBJ->MemoryTime=0;
  571. };
  572. void Legion::SendTo(byte x,byte y){
  573.     TempMobil=false;
  574.     StonesInside=false;
  575.     needCompactness=true;
  576.     needMoveTo=true;
  577.     FinX=x;
  578.     FinY=y;
  579.     Order3Time=0;
  580.     CalculateSoldiers();
  581.     CreateFinalZone(x,y);
  582.     SendSoldiers();
  583. };
  584. //0-φΦΩαΩεπε ∩ε≡ ΣΩα φσ≥, ΓεΘ±Ωε ≡α±±σ φε
  585. //1-∩ε≡ ΣεΩ φσΣε±≥α≥ε≈σφ Σδ  φε≡∞αδⁿφεπε ⌠≤φΩ÷ΦεφΦ≡εΓαφΦ 
  586. //2-∩ε≡ ΣεΩ, Σε±≥α≥ε≈φ√Θ Σδ  ∩σ≡σ∞σ∙σφΦ 
  587. //3-∞ΦφΦ∞αδⁿφ√Θ ßσ±∩ε≡ ΣεΩ,≥Γα≡Φ ≥εδⁿΩε φα εΣφ≤ Ωδσ≥Ω≤ φσ ΓδστδΦ
  588. //4-ΦΣσαδⁿφ√Θ ∩ε≡ ΣεΩ
  589. char Legion::GetOrderDegree(){
  590.     short MaxDY1=abs(short(maxy-miny)-short(destY1-destY));
  591.     short MaxDX1=abs(short(maxx-minx)-short(destX1-destX));
  592.     short LX=destX1-destX+1;
  593.     short LY=destY1-destY+1;
  594.     if(MaxDX1==0&&MaxDY1==0)return 4;
  595.     if(MaxDX1<=2&&MaxDY1<=2)return 3;
  596.     if(MaxDX1<=LX&&MaxDY1<=LY)return 2;
  597.     if(MaxDX1<=(LX+LX)&&MaxDY1<=(LY+LY))return 1;
  598.     return 0;
  599. };