home *** CD-ROM | disk | FTP | other *** search
/ WarCraft 2000 - Nuclear Epidemic / W2000.nrg / SOURCE.War2000 / mapa.cpp < prev    next >
C/C++ Source or Header  |  1998-09-25  |  70KB  |  2,758 lines
  1. #include "ddini.h"
  2. #include <stdlib.h>
  3. #include "ResFile.h"
  4. #include "Fastdraw.h"
  5. #include "MapDiscr.h"
  6. #include "mouse.h"
  7. #include "mode.h"
  8. #include "fog.h"
  9. #include "walls.h"
  10. #include "Nature.h"
  11. #include <crtdbg.h>
  12. #include <math.h>
  13. #include "TopZones.h"
  14. #include "Megapolis.h"
  15. #include "FlyObj.h"
  16. #include "fonts.h"
  17. #include "WeaponID.h"
  18. #include "MapEdit.h"
  19. #include "3DSurf.h"
  20. #include "GSound.h"
  21. #include <assert.h>
  22. extern int time1,time2,time3,time4,time5;
  23. int time6,time7,time8;
  24. extern int HintX;
  25. extern int HintY;
  26. extern bool CheapMode;
  27. extern int NMyUnits;
  28. extern int NThemUnits;
  29. extern RLCFont FPassive;
  30. extern RLCFont FActive;
  31. extern RLCFont FDisable;
  32. int GetRLen(char* s,RLCFont* font);
  33. word GetEnemy(int x,int y,byte NI);
  34. word GetFriend(int x,int y,byte NI);
  35. int COUNTER;
  36. extern int BlobMode;
  37. extern RLCTable IMM; 
  38. extern int LASTRAND,LASTIND;
  39. void ShowRMap();
  40. extern int FogMode;
  41. extern int RealLx;
  42. extern int RealLy;
  43. extern int Pitch;
  44. extern Forces NForces[8];
  45. word GetOwner(int x,int y);
  46. extern bool GetCoord;
  47. extern UniqMethood* UNIM;
  48. //╩α≡≥α φσ≤±≥≡αφΦ∞√⌡ ∩≡σ∩ ≥±≥ΓΦΘ
  49. extern int PathAsks;
  50. extern int NMONS;
  51. extern bool AttackMode;
  52. extern int nEused;
  53. extern bool EUsage[1024];
  54. extern Nation* curn;
  55. extern int counter;
  56. extern bool InfoMode;
  57. extern int WaitCycle;
  58. extern int tmtmt;
  59. extern bool EditMapMode;
  60. extern bool HeightEditMode;
  61. extern bool HelpMode;
  62. extern bool ChoosePosition;
  63. extern int LastKey;
  64. const byte CLRT[8]={0xD0,0xD4,0xD8,0xDC,0xE0,0xE4,0xE8,0xAD};
  65. void ShowSuperFluentFog(int x,int y,int z1,int z2,int z3,int z4);
  66. void ShowDestn();
  67. void ShowMiniDestn();
  68. extern byte RNTB[64][256];
  69. byte TrMap[maxmap][maxmap];
  70. word SlMons[8192];
  71. bool GetTask[8192];
  72. void CreateMiniMap();
  73. void ShowSuperFluentFog32_160(int x,int y,int z1x,int z2x,int z3x,int z4x);
  74. word Nsel;
  75. //╩α≡ΦφΩΦ Σδ  ⌠εφα
  76. byte tiles[32][8192];
  77. byte mtiles[16][4096];
  78. //ε∩Φ±αφΦσ Ωα≡≥ΦφεΩ φα Ωα≡≥σ
  79. byte tmap[maxmap][maxmap];
  80. //Ωα≡≥α-±±√δΩΦ φα ∞εφ±≥≡εΓ
  81. MapCell map[maxmap][maxmap];
  82. //Ωα≡≥α ßδεΩΦ≡εΓεΩ
  83. byte LLock[maxmap][maxmap];
  84. //╩α≡≥α ≡α±∩εδεµσφΦ  ∞εφ±≥≡εΓ
  85. word Mops[maxmap][maxmap];
  86. word FlyMops[256][256];
  87. //╩α≡≥α Σδ  ≤ßΦ≥√⌡
  88. word Died[maxmap][maxmap];
  89. bool BuildMode;
  90. byte SpecCmd;
  91. OneSlide* OSB;
  92. byte blx;
  93. byte bly;
  94. word BuildingID;
  95. Nation* BNat;
  96. extern int NAsk;
  97. extern int curptr;
  98. int    smapx;
  99. int    smapy;
  100. int    smaplx;
  101. int    smaply;
  102. int    mapx;
  103. int    mapy;
  104. int    msx;
  105. int msy;
  106. int minix;
  107. int    miniy;
  108. static int StartX=0;
  109. static int StartY=0;
  110. bool MiniMade;
  111. char Prompt[80];
  112. int PromptTime;
  113. byte minimap[maxmap][maxmap];
  114. byte Locking[1024];//╚φ⌠. ε ßδεΩΦ≡εΓαφΦΦ ∩εΓσ≡⌡φε±≥Φ
  115. #define ScreenSizeX32 ScreenSizeX-32
  116. //╠α±±ΦΓ Γ±σ ∞εφ±≥≡εΓ φα Ωα≡≥σ
  117. OneObject* Group[8192];
  118. //Mα±±ΦΓ Σδ  δεΩαδⁿφ√⌡ Ωε∞αφΣ
  119. //╚φΣσΩ±√ Φ±∩εδⁿτεΓαφΦ 
  120. bool    AsmUsage[MaxAsmCount];
  121. char    AsmBuf[MaxAsmCount*OneAsmSize];
  122. int        LastAsmRequest;
  123. //╠α±±ΦΓ Σδ  Ωε∞αφΣ ∩σ≡Γεπε ≤≡εΓφ 
  124. bool    OrdUsage[MaxOrdCount];
  125. Order1  OrdBuf[MaxOrdCount];
  126. int        LastOrdRequest;
  127. //network sequence errors enumeration
  128. extern int SeqErrorsCount;
  129. extern int LastRandDif;
  130. extern int curdx;
  131. extern int curdy;
  132. //╘εφ
  133. byte fon000[1024*768];
  134. void RedSquare(int x,int y){
  135.     if(x<mapx||x>=mapx+smaplx||y<mapy||y>=mapy+smaply)return;
  136.     int sco=int(ScreenPtr)+smapx+((x-mapx)<<5)+
  137.         (((y-mapy)<<5)+smapy)*SCRSizeX;
  138.     int ddx=SCRSizeX+SCRSizeX-32;
  139.     __asm{
  140.         push    edi
  141.         mov        edi,sco
  142.         mov        eax,16
  143. uyu:    mov        ecx,16
  144. uuu:    mov        byte ptr [edi],clrRed
  145.         add        edi,2
  146.         loop    uuu
  147.         add        edi,ddx
  148.         dec        al
  149.         jnz        uyu
  150.  
  151.         pop        edi
  152.     };
  153. };
  154. void RedMiniSquare(int x,int y){
  155.     if(x<mapx||x>=mapx+smaplx||y<mapy||y>=mapy+smaply)return;
  156.     int sco=int(ScreenPtr)+smapx+((x-mapx)<<4)+
  157.         (((y-mapy)<<4)+smapy)*SCRSizeX;
  158.     int ddx=SCRSizeX+SCRSizeX-16;
  159.     __asm{
  160.         push    edi
  161.         mov        edi,sco
  162.         mov        eax,8
  163. uyu:    mov        ecx,8
  164. uuu:    mov        byte ptr [edi],clrRed
  165.         add        edi,2
  166.         loop    uuu
  167.         add        edi,ddx
  168.         dec        al
  169.         jnz        uyu
  170.  
  171.         pop        edi
  172.     };
  173. };
  174. void RedBar(int x,int y,int lx,int ly){
  175.     for(int i=0;i<lx;i++)
  176.         for(int j=0;j<ly;j++)
  177.             RedSquare(x+i,y+j);
  178. };
  179. void RedMiniBar(int x,int y,int lx,int ly){
  180.     for(int i=0;i<lx;i++)
  181.         for(int j=0;j<ly;j++)
  182.             RedMiniSquare(x+i,y+j);
  183. };
  184. void WhiteSquare(int x,int y){
  185.     if(x<mapx||x>=mapx+smaplx||y<mapy||y>=mapy+smaply)return;
  186.     int sco=int(ScreenPtr)+smapx+((x-mapx)<<5)+
  187.         (((y-mapy)<<5)+smapy)*SCRSizeX;
  188.     int ddx=SCRSizeX+SCRSizeX-32;
  189.     __asm{
  190.         push    edi
  191.         mov        edi,sco
  192.         mov        eax,16
  193. uyu:    mov        ecx,16
  194. uuu:    mov        byte ptr [edi],255
  195.         add        edi,2
  196.         loop    uuu
  197.         add        edi,ddx
  198.         dec        al
  199.         jnz        uyu
  200.  
  201.         pop        edi
  202.     };
  203. };
  204. void WhiteMiniSquare(int x,int y){
  205.     if(x<mapx||x>=mapx+smaplx||y<mapy||y>=mapy+smaply)return;
  206.     int sco=int(ScreenPtr)+smapx+((x-mapx)<<4)+
  207.         (((y-mapy)<<4)+smapy)*SCRSizeX;
  208.     int ddx=SCRSizeX+SCRSizeX-16;
  209.     __asm{
  210.         push    edi
  211.         mov        edi,sco
  212.         mov        eax,8
  213. uyu:    mov        ecx,8
  214. uuu:    mov        byte ptr [edi],255
  215.         add        edi,2
  216.         loop    uuu
  217.         add        edi,ddx
  218.         dec        al
  219.         jnz        uyu
  220.  
  221.         pop        edi
  222.     };
  223. };
  224. void WhiteBar(int x,int y,int lx,int ly){
  225.     for(int i=0;i<lx;i++)
  226.         for(int j=0;j<ly;j++)
  227.             WhiteSquare(x+i,y+j);
  228. };
  229. void WhiteMiniBar(int x,int y,int lx,int ly){
  230.     for(int i=0;i<lx;i++)
  231.         for(int j=0;j<ly;j++)
  232.             WhiteMiniSquare(x+i,y+j);
  233. };
  234. void OutErr(LPCSTR s)
  235. {
  236.     MessageBox(hwnd,s,"Loading failed...",MB_ICONWARNING|MB_OK);
  237. };
  238. bool ManualFogCheck(int xx,int yy,int dx){
  239.     if(EditMapMode)return true;
  240.     int x,y;
  241.     for(int i=0;i<dx;i++)
  242.         for(int j=0;j<dx;j++){
  243.             x=xx+i;
  244.             y=yy+j;
  245.             if(x<=1||x>=msx||y<=1||y>=msy)return false;
  246.             if(fmap[y][x]<1000)return false;
  247.         };
  248.     return true;
  249. };
  250. void AssignHint1(char* s,int time);
  251. bool CheckGold(int xx,int yy,GeneralObject* GO){
  252.     if(!GO->AGold)return true;
  253.     for(int i=0;i<15;i++)
  254.         for(int j=0;j<15;j++){
  255.             int x=xx+i-5;
  256.             int y=yy+j-5;
  257.             if(x>1&&y>1&&x<=msx&&y<=msy){
  258.                 if(rtmap[y][x]==1&&ramap[y][x]){
  259.                     AssignHint1("╤δΦ°Ωε∞ ßδΦτΩε Ω τεδε≥≤.",4);
  260.                     return false;
  261.                 };
  262.             };
  263.         };
  264.     return true;
  265. };
  266. //╧εδ≤≈Φ≥ⁿ ßδεΩ Σδ  InLineCom
  267. char* GetAsmBlock(){
  268.     if(LastAsmRequest>=MaxAsmCount)LastAsmRequest=0;
  269.     for(int i=LastAsmRequest;i<MaxAsmCount&&AsmUsage[i];i++);
  270.     if(i<MaxAsmCount){
  271.         LastAsmRequest=i+1;
  272.         AsmUsage[i]=true;
  273.         return &AsmBuf[i*OneAsmSize];
  274.     } else{
  275.         for(int i=0;i<LastAsmRequest&&AsmUsage[i];i++);
  276.         if(i<LastAsmRequest){
  277.             LastAsmRequest=i+1;
  278.             AsmUsage[i]=true;
  279.             return &AsmBuf[i*OneAsmSize];
  280.         } else return NULL;
  281.     };
  282. };
  283. void FreeAsmBlock(char* p ){
  284.     int i=(int(p)-int(AsmBuf))>>OneAShift;
  285.     AsmUsage[i]=false;
  286.     LastAsmRequest=i;
  287. };
  288. void InitAsmBuf(){
  289.     memset(AsmUsage,0,sizeof AsmUsage);
  290.     memset(AsmBuf,0,sizeof AsmBuf);
  291.     LastAsmRequest=0;
  292. };
  293. //╧εδ≤≈Φ≥ⁿ ßδεΩ Σδ  LocalOrder
  294. int CHSM1;
  295. void GetOrdSum(){
  296.     return;
  297.     CHSM1=0;
  298.     for(int i=0;i<MaxOrdCount;i++){
  299.         if(OrdUsage[i])CHSM1+=i;
  300.     };
  301. };
  302. void ChkOrdSum(){
  303.     return;
  304.     int xxx=CHSM1;
  305.     GetOrdSum();
  306.     assert(xxx=CHSM1);
  307. };
  308. Order1* GetOrdBlock(){
  309.     ChkOrdSum();
  310.     if(LastOrdRequest>=MaxOrdCount)LastOrdRequest=0;
  311.     for(int i=LastOrdRequest;i<MaxOrdCount&&OrdUsage[i];i++);
  312.     if(i<MaxOrdCount){
  313.         LastOrdRequest=i+1;
  314.         OrdUsage[i]=true;
  315.         GetOrdSum();
  316.         return &OrdBuf[i];
  317.     } else{
  318.         for(int i=0;i<LastOrdRequest&&OrdUsage[i];i++);
  319.         if(i<LastOrdRequest){
  320.             LastOrdRequest=i+1;
  321.             OrdUsage[i]=true;
  322.             GetOrdSum();
  323.             return &OrdBuf[i];
  324.         } else{
  325.             GetOrdSum();            
  326.             return NULL;
  327.         };
  328.     };
  329. };
  330. void OneObject::FreeOrdBlock(Order1* p ){
  331.     ChkOrdSum();
  332.     byte ot=p->OrderType;
  333.     if(ot==3){
  334.         Attack=false;
  335.         EnemyID=0xFFFF;
  336.         EnemyDist=5000;
  337.     };
  338.     if(ot==22)MoveInRect=false;
  339.     int i=div(int(p)-int(OrdBuf),sizeof Order1).quot;
  340.     OrdUsage[i]=false;
  341.     LastOrdRequest=i;
  342.     GetOrdSum();
  343. };
  344. void InitOrdBuf(){
  345.     memset(OrdUsage,0,sizeof OrdUsage);
  346.     memset(OrdBuf,0,sizeof OrdBuf);
  347.     //LastOrdRequest=0;
  348. };
  349.  
  350. void LoadLock()
  351. {
  352.     ResFile f=RReset("lock.dat");
  353.     if(IOresult())OutErr("Can't load locking.");
  354.     RBlockRead(f,Locking,RFileSize(f));
  355.     RClose(f);
  356. };
  357. void LoadFon()
  358. {
  359.     if(RealLx==1024){
  360.         ResFile ff1=RReset("fon1024p.raw");
  361.         if(IOresult()) OutErr("Can't load fon1024p.raw");
  362.         RBlockRead(ff1,fon000,RFileSize(ff1));
  363.         RClose(ff1);
  364.         return;
  365.     };
  366.     ResFile ff1=RReset("fon.000");
  367.     if(IOresult()) OutErr("Can't load fon.000");
  368.     RBlockRead(ff1,fon000,RFileSize(ff1));
  369.     RClose(ff1);
  370. };
  371. void ShowFon()
  372. {
  373.     return;
  374.     //if(SCRSizeY==768)return;
  375.     int addX=RSCRSizeX-COPYSizeX;
  376.     int SZX=(COPYSizeX)>>2;
  377.     __asm{
  378.         push    esi
  379.         push    edi
  380.         mov        esi,offset fon000
  381.         mov        edi,RealScreenPtr
  382.         mov        ebx,RSCRSizeY
  383.         cld
  384. uuu1:
  385.         mov        ecx,SZX
  386.         rep        movsd
  387.         add        edi,addX
  388.         dec        ebx
  389.         jnz        uuu1
  390.         pop        edi
  391.         pop        esi
  392.     }
  393. };
  394. void ShowFon1()
  395. {
  396.     //if(SCRSizeY==768)return;
  397.     int addX=SCRSizeX-COPYSizeX;
  398.     int SZX=(COPYSizeX)>>2;
  399.     __asm{
  400.         push    esi
  401.         push    edi
  402.         mov        esi,offset fon000
  403.         mov        edi,ScreenPtr
  404.         mov        ebx,RSCRSizeY
  405.         cld
  406. uuu1:
  407.         mov        ecx,SZX
  408.         rep        movsd
  409.         add        edi,addX
  410.         dec        ebx
  411.         jnz        uuu1
  412.         pop        edi
  413.         pop        esi
  414.     }    
  415. };
  416. void ShowBorder()
  417. {
  418.     return;
  419.     /*int Start=smapx-32+smapy*ScreenSizeX;
  420.     int    Ly=smaply*32;
  421.     __asm{
  422.         push    esi
  423.         push    edi
  424.         mov        ebx,Ly
  425.         mov        esi,offset fon000
  426.         add        esi,Start
  427.         mov        edi,ScreenPtr
  428.         add        edi,Start
  429.         cld
  430. Uuy1:    mov        ecx,8
  431.         rep        movsd
  432.         add        esi,ScreenSizeX-32
  433.         add        edi,ScreenSizeX-32
  434.         dec        ebx
  435.         jnz        Uuy1
  436.         pop        edi
  437.         pop        esi
  438.     }
  439.     Start=smapx+smaplx*32+smapy*ScreenSizeX;
  440.     __asm{
  441.         push    esi
  442.         push    edi
  443.         mov        ebx,Ly
  444.         mov        esi,offset fon000
  445.         add        esi,Start
  446.         mov        edi,ScreenPtr
  447.         add        edi,Start
  448.         cld
  449. Uuy2:    mov        ecx,8
  450.         rep        movsd
  451.         add        esi,ScreenSizeX-32
  452.         add        edi,ScreenSizeX-32
  453.         dec        ebx
  454.         jnz        Uuy2
  455.         pop        edi
  456.         pop        esi
  457.     }*/
  458. };
  459. void LoadTiles()
  460. {
  461.     ResFile ff1=RReset("new_dark.bpx");//tiles.t00");
  462.     if (IOresult()) OutErr("Can't load tiles.");
  463.     RBlockRead(ff1,tiles,RFileSize(ff1));
  464.     int ntiles=RFileSize(ff1)>>10;
  465.     RClose(ff1);
  466.     for(int i=0;i<ntiles;i++){
  467.         for(int ux=0;ux<16;ux++)
  468.             for(int uy=0;uy<16;uy++){
  469.                 ((byte*)(mtiles))[(i<<8)+(ux)+(uy<<4)]=
  470.                     ((byte*)(tiles))[(i<<10)+(ux<<1)+(uy<<6)];
  471.             };
  472.     };
  473.     
  474. };
  475. void SaveWalls(ResFile ff1);
  476. void LoadWalls(ResFile ff1);
  477. char MapName[128];
  478. extern short HiMap[256][256];//Height of surface
  479. byte mapPos[16];
  480. int RES[8][8];
  481. void SaveExtendedMap(char* s){
  482.     ResFile f1=RRewrite(s);
  483.     int i='APAM';
  484.     RBlockWrite(f1,&i,4);
  485.     RBlockWrite(f1,MapName,128);
  486.     RBlockWrite(f1,mapPos,16);
  487.     //Saving Tiles Map
  488.     RBlockWrite(f1,&msx,4);
  489.     RBlockWrite(f1,&msy,4);
  490.     RBlockWrite(f1,&RES[0][0],sizeof RES);
  491.     for(i=0;i<msx;i++)RBlockWrite(f1,&tmap[i][0],msy);
  492.     //Saving Height map
  493.     for(i=0;i<=msy;i++)RBlockWrite(f1,&HiMap[i][0],(msx+1)<<1);
  494.     //Oil spots
  495.     int NU=0;
  496.     for(int xx=0;xx<128;xx++)
  497.         for(int yy=0;yy<128;yy++)if(OILMAP[yy][xx])NU++;
  498.     RBlockWrite(f1,&NU,4);
  499.     for(xx=0;xx<128;xx++)
  500.         for(int yy=0;yy<128;yy++)if(OILMAP[yy][xx]){
  501.             RBlockWrite(f1,&xx,1);
  502.             RBlockWrite(f1,&yy,1);
  503.             RBlockWrite(f1,&OILMAP[yy][xx],2);
  504.         };
  505.     //saving units
  506.     NU=0;
  507.     for(i=0;i<8192;i++){
  508.         if(Group[i])NU++;
  509.     };
  510.     RBlockWrite(f1,&NU,4);
  511.     for(i=0;i<8192;i++){
  512.         OneObject* OB=Group[i];
  513.         if(OB){
  514.             RBlockWrite(f1,&OB->NIndex,2);
  515.             RBlockWrite(f1,&OB->NNUM,1);
  516.             RBlockWrite(f1,&OB->x,1);
  517.             RBlockWrite(f1,&OB->y,1);
  518.         };
  519.     };
  520.     SaveWalls(f1);
  521.     RClose(f1);
  522. };
  523. void PreLoadExtendedMap(char* s){
  524.     ResFile f1=RReset(s);
  525.     InitRenderMap();
  526.     int i='APAM';
  527.     RBlockRead(f1,&i,4);
  528.     if(i!='APAM'){
  529.         RClose(f1);
  530.         return;
  531.     };
  532.     //Loading tiles map
  533.     RBlockRead(f1,MapName,128);
  534.     RBlockRead(f1,mapPos,16);
  535.     RBlockRead(f1,&msx,4);
  536.     RBlockRead(f1,&msy,4);
  537.     RBlockRead(f1,&RES[0][0],sizeof RES);
  538.     memcpy(&RESRC[0][0],&RES[0][0],sizeof RES);
  539.     for(i=0;i<msx;i++)RBlockRead(f1,&tmap[i][0],msy);
  540.     //Loading height map
  541.     for(i=0;i<=msy;i++)RBlockRead(f1,&HiMap[i][0],(msx+1)<<1);
  542.     int NOIL;
  543.     byte x,y;
  544.     word AMOUNT;
  545.     RBlockRead(f1,&NOIL,4);
  546.     for(i=0;i<NOIL;i++){
  547.         RBlockRead(f1,&x,1);
  548.         RBlockRead(f1,&y,1);
  549.         RBlockRead(f1,&AMOUNT,2);
  550.         OILMAP[y][x]=AMOUNT;
  551.     };
  552.     PromptTime=0;
  553.     MAXOBJECT=0;
  554.     memset(&fmap[0][0],0,sizeof fmap);
  555.     memset(Group,0,sizeof Group);
  556.     memset(&TrMap[0][0],0,sizeof TrMap);
  557.     memset(&LLock[0][0],0,sizeof LLock);
  558.     memset(&WLock[0][0],0,sizeof WLock);
  559.     memset(&WMap[0][0],0,sizeof WMap);
  560.     memset(&map[0][0],0,sizeof map);
  561.     memset(NLocks,0,sizeof NLocks);
  562.     BuildMode=false;
  563.     for(i=0;i<maxmap;i++)
  564.     for(int j=0;j<maxmap;j++){
  565.         //map[i][j].BuildingID=65535;
  566.         Mops[j][i]=65535;
  567.         Died[j][i]=65535;
  568.         FlyMops[j][i]=65535;
  569.         //map[i][j].FlyID=65535;
  570.     };
  571.     for(i=0;i<msx;i++)for(int j=0;j<msy;j++){
  572.         byte k=Locking[tmap[j][i]];
  573.         if(k&1){
  574.             LLock[i+1][j+1]=1;
  575.             IncLock(j+1,i+1);
  576.             TrMap[i+1][j+1]=1;
  577.         };
  578.         //if(k&2)map[j][i].WaterLock=true;
  579.     };
  580.     for(i=0;i<=msx+1;i++){
  581.         TrMap[i][0]=2;
  582.         TrMap[i][msy+1]=2;
  583.         LLock[i][0]=2;
  584.         IncLock(0,i);
  585.         LLock[i][msy+1]=2;
  586.         IncLock(msy+1,i);
  587.         WMap[i][0]=2;
  588.         WMap[i][msy+1]=2;
  589.         WLock[i][0]=2;
  590.         WLock[i][msy+1]=2;
  591.         WMap[i][0]=2;
  592.         WMap[i][msy+2]=2;
  593.         WLock[i][0]=2;
  594.         WLock[i][msy+2]=2;
  595.  
  596.     };
  597.     for(i=0;i<msy+1;i++){
  598.         TrMap[0][i]=2;
  599.         TrMap[msx+1][i]=2;
  600.         LLock[0][i]=2;
  601.         IncLock(i,0);
  602.         LLock[msx+1][i]=2;
  603.         IncLock(i,msx+1);
  604.         WMap[0][i]=2;
  605.         WMap[msx+1][i]=2;
  606.         WLock[0][i]=2;
  607.         WLock[msx+1][i]=2;
  608.         WMap[0][i]=2;
  609.         WMap[msx+2][i]=2;
  610.         WLock[0][i]=2;
  611.         WLock[msx+2][i]=2;
  612.     };
  613.     RClose(f1);
  614.     Nsel=0;    
  615.     CreateResMap();
  616.     CreateWaterMap();
  617.     CreateTZones();
  618.     CreateCMap();
  619.     CreateMiniMap();
  620. };
  621. void CreateUnit(Nation* NT,byte x,byte y,word ID){
  622.     GeneralObject* GO=NT->Mon[ID];    
  623.     if(!GO->cpbBuilding){
  624.         NT->CreateTerrainAt(x,y,ID);
  625.     }else{
  626.         CheapMode=true;
  627.         int oi=NT->CreateBuilding(ID,x,y);
  628.         CheapMode=false;
  629.         if(oi!=-1){
  630.             OneObject* OB=Group[oi];
  631.             OB->LoadCurAnm(0);
  632.             OB->TicksPerChange=255;
  633.             OB->Life=OB->MaxLife;
  634.             OB->CurrentSprite=OB->CurAnm->count-1;
  635.             if(OB->Ref.General->cpbFarm)NT->NFarms++;
  636.             OB->Ready=true;
  637.             OB->Stage=OB->Stage=OB->NStages;
  638.         };
  639.     };
  640. };
  641. void PostLoadExtendedMap(char* s){
  642.     memset(&fmap[0][0],10,sizeof fmap);
  643.     ResFile f1=RReset(s);
  644.     int pos=12+16+128+8*8*4+(msx*msy)+(msx+1)*(msy+1)*2;
  645.     RSeek(f1,pos);
  646.     //Load units
  647.     int NU;
  648.     RBlockRead(f1,&NU,4);
  649.     pos+=(NU+1)<<2;
  650.     RSeek(f1,pos);
  651.     RBlockRead(f1,&NU,4);
  652.     byte NNUM,xu,yu;
  653.     word NIndex;
  654.     for(int i=0;i<NU;i++){
  655.         RBlockRead(f1,&NIndex,2);
  656.         RBlockRead(f1,&NNUM,1);
  657.         RBlockRead(f1,&xu,1);
  658.         RBlockRead(f1,&yu,1);
  659.         Nation* NT=&NATIONS[NNUM];
  660.         CreateUnit(NT,xu,yu,NIndex);
  661.     };
  662.     //walls
  663.     LoadWalls(f1);
  664.     RClose(f1);
  665.     memset(&fmap[0][0],0,sizeof fmap);
  666. };
  667. void RestoreLock(int x,int y,int lx,int ly){
  668.     for(int j=x-1;j<x+lx-1;j++)for(int i=y-1;i<y+ly-1;i++){
  669.         byte k=Locking[tmap[j][i]];
  670.         if(k&1){
  671.             if(!LLock[i+1][j+1])IncLock(j+1,i+1);
  672.             LLock[i+1][j+1]=1;
  673.             TrMap[i+1][j+1]=1;
  674.         }else{
  675.             if(LLock[i+1][j+1])DecLock(j+1,i+1);
  676.             LLock[i+1][j+1]=0;
  677.             TrMap[i+1][j+1]=0;
  678.         };
  679.         k=Locking[tmap[j][i]];
  680.         if(k&2){
  681.             WLock[i+1][j+1]=1;
  682.             WMap[i+1][j+1]=1;
  683.         }else{
  684.             WLock[i+1][j+1]=0;
  685.             WMap[i+1][j+1]=0;
  686.         };
  687.         Mops[i+1][j+1]=0xFFFF;
  688.     };
  689.     
  690. };
  691. void LoadMap(LPCSTR s)
  692. {
  693.     PromptTime=0;
  694.     MAXOBJECT=0;
  695.     memset(Group,0,sizeof Group);
  696.     memset(TrMap,0,sizeof TrMap);
  697.     memset(LLock,0,sizeof LLock);
  698.     memset(WLock,0,sizeof WLock);
  699.     memset(WMap,0,sizeof WMap);
  700.     memset(map,0,sizeof map);
  701.     memset(NLocks,0,sizeof NLocks);
  702.     BuildMode=false;
  703.     for(int i=0;i<maxmap;i++)
  704.     for(int j=0;j<maxmap;j++){
  705.         //map[i][j].BuildingID=65535;
  706.         Mops[j][i]=65535;
  707.         Died[j][i]=65535;
  708.         FlyMops[j][i]=65535;
  709.         //map[i][j].FlyID=65535;
  710.     };
  711.     ResFile ff1=RReset(s);
  712.     if (IOresult())OutErr("Can't load map file.");
  713.     RBlockRead(ff1,&i,4);
  714.     if (i!=0x1B46504D) OutErr("Incorrect map file format.");
  715.     RBlockRead(ff1,&msx,4);
  716.     RBlockRead(ff1,&msy,4);
  717.     RBlockRead(ff1,&i,4);
  718.     RBlockRead(ff1,&i,4);
  719.     for(i=0;i<msy;i++)RBlockRead(ff1,&tmap[i][0],msx);
  720.     for(i=0;i<msx;i++)for(int j=0;j<msy;j++){
  721.         byte k=Locking[tmap[j][i]];
  722.         if(k&1){
  723.             LLock[i+1][j+1]=1;
  724.             IncLock(j+1,i+1);
  725.             TrMap[i+1][j+1]=1;
  726.         };
  727.         //if(k&2)map[j][i].WaterLock=true;
  728.     };
  729.     for(i=0;i<=msx+1;i++){
  730.         TrMap[i][0]=2;
  731.         TrMap[i][msy+1]=2;
  732.         LLock[i][0]=2;
  733.         IncLock(0,i);
  734.         LLock[i][msy+1]=2;
  735.         IncLock(msy+1,i);
  736.  
  737.     };
  738.     for(i=0;i<msy+1;i++){
  739.         TrMap[0][i]=2;
  740.         TrMap[msx+1][i]=2;
  741.         LLock[0][i]=2;
  742.         IncLock(i,0);
  743.         LLock[msx+1][i]=2;
  744.         IncLock(i,msx+1);
  745.     };
  746.     RClose(ff1);
  747.     RSCRSizeX=RealLx;
  748.     RSCRSizeY=RealLy;
  749.     COPYSizeX=RealLx;
  750.     smaplx=17;
  751.     if(RSCRSizeY==768)smaplx=22;
  752.     smaply=smaplx;
  753.     smapx=COPYSizeX-(smaplx<<5)-32;
  754.     smapy=(RSCRSizeY-(smaply<<5))>>1;
  755.     //smapx=7*32;
  756.     //smapy=28;
  757.     //smaplx=19;
  758.     //smaply=19;
  759.     mapx=1;
  760.     mapy=1;
  761.     minix=32;
  762.     miniy=32;
  763.     MiniMade=false;
  764.     Nsel=0;    
  765.     CreateResMap();
  766.     CreateWaterMap();
  767.     CreateTZones();
  768.     CreateCMap();
  769.     InitRenderMap();
  770. };
  771. void NewMap(int szX,int szY)
  772. {
  773.     PromptTime=0;
  774.     MAXOBJECT=0;
  775.     memset(Group,0,sizeof Group);
  776.     memset(TrMap,0,sizeof TrMap);
  777.     memset(LLock,0,sizeof LLock);
  778.     memset(WLock,0,sizeof WLock);
  779.     memset(map,0,sizeof map);
  780.     memset(NLocks,0,sizeof NLocks);
  781.     BuildMode=false;
  782.     for(int i=0;i<maxmap;i++)
  783.     for(int j=0;j<maxmap;j++){
  784.         //map[i][j].BuildingID=65535;
  785.         Mops[j][i]=65535;
  786.         Died[j][i]=65535;
  787.         FlyMops[j][i]=65535;
  788.         //map[i][j].FlyID=65535;
  789.     };
  790.     memset(&tmap[0][0],0,sizeof tmap);
  791.     memset(&HiMap[0][0],0,sizeof HiMap);
  792.     for(i=0;i<msx;i++)for(int j=0;j<msy;j++){
  793.         byte k=Locking[tmap[j][i]];
  794.         if(k&1){
  795.             LLock[i+1][j+1]=1;
  796.             IncLock(j+1,i+1);
  797.             TrMap[i+1][j+1]=1;
  798.         };
  799.         //if(k&2)map[j][i].WaterLock=true;
  800.     };
  801.     for(i=0;i<=msx+1;i++){
  802.         TrMap[i][0]=2;
  803.         TrMap[i][msy+1]=2;
  804.         LLock[i][0]=2;
  805.         IncLock(0,i);
  806.         LLock[i][msy+1]=2;
  807.         IncLock(msy+1,i);
  808.  
  809.     };
  810.     for(i=0;i<msy+1;i++){
  811.         TrMap[0][i]=2;
  812.         TrMap[msx+1][i]=2;
  813.         LLock[0][i]=2;
  814.         IncLock(i,0);
  815.         LLock[msx+1][i]=2;
  816.         IncLock(i,msx+1);
  817.     };
  818.     MiniMade=false;
  819.     Nsel=0;    
  820.     CreateResMap();
  821.     CreateWaterMap();
  822.     CreateTZones();
  823.     CreateCMap();
  824.     InitRenderMap();
  825.     SetTiles(0,0,256);
  826. };
  827. void CreateMiniMap()
  828. {
  829.     int i,j;
  830.     char *yy=(char*)(&tiles);
  831.     for(i=0;i<msx;i++)
  832.         for(j=0;j<msy;j++)
  833.             minimap[i>>1][j>>1]=yy[33+/*33*16+1+*/(int(tmap[j][i])<<10)];
  834.     MiniMade=true;
  835. };
  836. const drx[8]={0,1,1,1,0,-1,-1,-1};
  837. const dry[8]={-1,-1,0,1,1,1,0,-1};
  838. extern bool HealthMode;
  839. void GetRect(OneObject* ZZ,int* x,int* y,int* Lx){
  840.     int scx,scy;
  841.     if(ZZ->OnWater){
  842.         scx=(int(ZZ->x)<<5)+(ZZ->Addx)-16;
  843.         scy=(int(ZZ->y)<<5)+(ZZ->Addy)-16;
  844.         int dy=64;
  845.         int dx=64;
  846.         if(ZZ->isMoving){
  847.             int nsp=ZZ->CurAnm->count;
  848.             if(nsp>3){
  849.                 scx+=div((int(ZZ->CurrentSprite)<<6)*drx[ZZ->Direction],nsp).quot;
  850.                 scy+=div((int(ZZ->CurrentSprite)<<6)*dry[ZZ->Direction],nsp).quot;
  851.             };
  852.         };
  853.         if(ZZ->capBuilding){
  854.             scx+=32;
  855.             scy+=32;
  856.         };
  857.         *x=scx;
  858.         *y=scy;
  859.         *Lx=dy;
  860.         return;
  861.     };
  862.     if(ZZ->Media==2){
  863.         scx=(ZZ->RealX>>4-32)-32;
  864.         scy=(ZZ->RealY>>4-32)-16-16+10-ZZ->Height;
  865.         *x=scx;
  866.         *y=scy;
  867.         *Lx=64;
  868.         return;
  869.     };
  870.     scx=(int(ZZ->x)<<5)+ZZ->Addx;
  871.     scy=(int(ZZ->y)<<5)+ZZ->Addy;
  872.     int dx=ZZ->Lx<<5;
  873.     if(ZZ->isMoving){
  874.         int nsp=ZZ->CurAnm->count;
  875.         if(nsp>3){
  876.             scx+=div((int(ZZ->CurrentSprite)<<5)*drx[ZZ->Direction],nsp).quot;
  877.             scy+=div((int(ZZ->CurrentSprite)<<5)*dry[ZZ->Direction],nsp).quot;
  878.         };
  879.     };
  880.     *x=scx;
  881.     *y=scy;
  882.     *Lx=dx;
  883. };
  884. void DrawMarker(OneObject* OB){
  885.     if(OB){
  886.         int x,y,Lx;
  887.         GetRect(OB,&x,&y,&Lx);
  888.         x+=smapx-(int(mapx)<<5);
  889.         y+=smapy-(int(mapy)<<5);
  890.         byte cl=clrYello;
  891.         byte c1=0;
  892.         byte c2=2;
  893.         byte dc=4;
  894.         int ddy=-12;
  895.         Hline(x+c1,y,x+c2,cl);
  896.         Hline(x+Lx-1-c2,y,x+Lx-1-c1,cl);
  897.         Hline(x+c1,y+Lx-1,x+c2,cl);
  898.         Hline(x+Lx-1-c2,y+Lx-1,x+Lx-1-c1,cl);
  899.         Vline(x,y+c1,y+c2,cl);
  900.         Vline(x+Lx-1,y+c1,y+c2,cl);
  901.         Vline(x,y+Lx-1-c2,y+Lx-1-c1,cl);
  902.         Vline(x+Lx-1,y+Lx-1-c2,y+Lx-1-c1,cl);
  903.         if(HealthMode){
  904.             int mhs=Lx-c2-c2-dc-dc;
  905.             int hs=mhs;
  906.             if(OB->MaxLife>0){
  907.                 hs=div(mhs*OB->Life,OB->MaxLife).quot;
  908.             };
  909.             Vline(-2+x+c2+dc,y+ddy,y+ddy+2,255);
  910.             Vline(-2+x+Lx-1-c2,y+ddy,y+ddy+2,255);
  911.             Vline(-2+x+c2+dc+1,y+ddy,y+ddy,255);
  912.             Vline(-2+x+c2+dc+1,y+ddy+2,y+ddy+2,255);
  913.             Vline(-2+x+Lx-1-c2-1,y+ddy,y+ddy,255);
  914.             Vline(-2+x+Lx-1-c2-1,y+ddy+2,y+ddy+2,255);
  915.             Hline(-2+x+c2+dc+1,y+ddy+1,x+c2+hs+dc+1,clrGreen);
  916.         };
  917.         /*
  918.         Hline(x+1,y+1,x+1,cl);
  919.         Hline(x+1,y+Lx-2,x+1,cl);
  920.         Hline(x+Lx-2,y+1,x+Lx-2,cl);
  921.         Hline(x+Lx-2,y+Lx-2,x+Lx-2,cl);*/
  922.     };
  923. };
  924. void DrawMiniMarker(OneObject* OB){
  925.     if(OB){
  926.         int x,y,Lx;
  927.         GetRect(OB,&x,&y,&Lx);
  928.         x=x>>1;
  929.         y=y>>1;
  930.         Lx=Lx>>1;
  931.         x+=smapx-(int(mapx)<<4);
  932.         y+=smapy-(int(mapy)<<4);
  933.         byte cl=clrYello;
  934.         byte c1=0;
  935.         byte c2=2;
  936.         byte dc=4;
  937.         int ddy=-12;
  938.         Hline(x+c1,y,x+c2,cl);
  939.         Hline(x+Lx-1-c2,y,x+Lx-1-c1,cl);
  940.         Hline(x+c1,y+Lx-1,x+c2,cl);
  941.         Hline(x+Lx-1-c2,y+Lx-1,x+Lx-1-c1,cl);
  942.         Vline(x,y+c1,y+c2,cl);
  943.         Vline(x+Lx-1,y+c1,y+c2,cl);
  944.         Vline(x,y+Lx-1-c2,y+Lx-1-c1,cl);
  945.         Vline(x+Lx-1,y+Lx-1-c2,y+Lx-1-c1,cl);
  946.         if(HealthMode){
  947.             int mhs=Lx-c2-c2-dc-dc;
  948.             int hs=mhs;
  949.             if(OB->MaxLife>0){
  950.                 hs=div(mhs*OB->Life,OB->MaxLife).quot;
  951.             };
  952.             Vline(-2+x+c2+dc,y+ddy,y+ddy+2,255);
  953.             Vline(-2+x+Lx-1-c2,y+ddy,y+ddy+2,255);
  954.             Vline(-2+x+c2+dc+1,y+ddy,y+ddy,255);
  955.             Vline(-2+x+c2+dc+1,y+ddy+2,y+ddy+2,255);
  956.             Vline(-2+x+Lx-1-c2-1,y+ddy,y+ddy,255);
  957.             Vline(-2+x+Lx-1-c2-1,y+ddy+2,y+ddy+2,255);
  958.             Hline(-2+x+c2+dc+1,y+ddy+1,x+c2+hs+dc+1,clrGreen);
  959.         };
  960.         /*
  961.         Hline(x+1,y+1,x+1,cl);
  962.         Hline(x+1,y+Lx-2,x+1,cl);
  963.         Hline(x+Lx-2,y+1,x+Lx-2,cl);
  964.         Hline(x+Lx-2,y+Lx-2,x+Lx-2,cl);*/
  965.     };
  966. };
  967. void ShowHealth(OneObject* ZZ){
  968.     if(!ZZ->Selected||ZZ->NNUM!=MyNation)return;
  969.     DrawMarker(ZZ);
  970.     return; 
  971. };
  972. void ShowMiniHealth(OneObject* ZZ){
  973.     if(!ZZ->Selected||ZZ->NNUM!=MyNation)return;
  974.     DrawMiniMarker(ZZ);
  975.     return; 
  976. };
  977. extern void MakeFog(int x,int y);
  978. void ShowFog(OneObject* ZZ){
  979.     if(!(ZZ->InFire||ZZ->capBuilding))return;
  980.     if(ZZ->InFire){
  981.         if(rando()<2000)MakeFog((int(ZZ->x)<<7),(int(ZZ->y)<<7));
  982.         return;
  983.     };
  984.     if(ZZ->Stage!=ZZ->NStages)return;
  985.     int Life=ZZ->Life;
  986.     int maxl=ZZ->Ref.Visual->info.Basic.MaxLife;
  987.     int m1=maxl>>1;
  988.     int m3=m1>>1;
  989.     int m2=m1+m3;
  990.     int xx,yy;
  991.     int DX=int(ZZ->Lx-1)<<3;
  992.     if(!DX)DX=1;
  993.     if(Life<m1){
  994.         if(rando()<8000){
  995.             xx=(int(ZZ->x)<<7)+(int(RNTB[DX][rando()&255])<<4);
  996.             yy=(int(ZZ->y)<<7)+(int(RNTB[DX][rando()&255])<<4);
  997.             MakeFog(xx,yy);
  998.         };
  999.         if(Life<m2){
  1000.             if(rando()<8000){
  1001.                 xx=(int(ZZ->x)<<7)+(int(RNTB[DX][rando()&255])<<4);
  1002.                 yy=(int(ZZ->y)<<7)+(int(RNTB[DX][rando()&255])<<4);
  1003.                 MakeFog(xx,yy);
  1004.             };
  1005.         };
  1006.     };
  1007. };
  1008. void ShowProperty(OneObject* OB){
  1009.     int mx=smapx+(int(OB->x-mapx)<<5)+OB->Addx;
  1010.     int my=smapy+(int(OB->y-mapy)<<5)+OB->Addy;
  1011.     if(OB->isMoving){
  1012.         int nsp=OB->CurAnm->count;
  1013.         if(nsp>3){
  1014.             mx+=div(34*OB->CurrentSprite*drx[OB->Direction],nsp).quot;
  1015.             my+=div(32*OB->CurrentSprite*dry[OB->Direction],nsp).quot;
  1016.         };
  1017.     };
  1018.     if(OB->xForce>16&&OB->xForce<=32){
  1019.         ShowRLCItem(mx,my-32,&IMM,3,0);
  1020.     };
  1021.     if(OB->xForce>32&&OB->xForce<=48){
  1022.         ShowRLCItem(mx,my-32,&IMM,3,0);
  1023.         ShowRLCItem(mx+10,my-32+10,&IMM,1,0);
  1024.     };
  1025.     if(OB->xForce>48){
  1026.         ShowRLCItem(mx,my-32,&IMM,3,0);
  1027.         ShowRLCItem(mx+10,my-32+10,&IMM,1,0);
  1028.         ShowRLCItem(mx,my-32+12,&IMM,1,0);
  1029.     };
  1030.     if(OB->xForce<16){
  1031.         ShowRLCItem(mx,my-32,&IMM,0,0);
  1032.     };
  1033.     if(OB->Invisible){
  1034.         ShowRLCItem(mx,my-32,&IMM,3,0);
  1035.     };
  1036.  
  1037. };
  1038. static int tmt=0;
  1039. void CBar(int x,int y,int Lx,int Ly,byte c);
  1040. void ShowMap()
  1041. {
  1042.     int i;
  1043.     int j;
  1044.     int scr;
  1045.     int til;
  1046.     int uuu=(tmt&31);
  1047.     tmt++;
  1048.     for(j=0;j<smaply;j++)
  1049.         for(i=0;i<smaplx;i++)if(fmap[j+mapy][i+mapx]>512){
  1050.             scr=int(ScreenPtr)+(i<<5)+smapx+((j<<5)+smapy)*SCRSizeX;
  1051.             til=int(&tiles)+(int(tmap[i+mapx-1][j+mapy-1])<<10);
  1052.             int SDX=SCRSizeX-32;
  1053.             //if(uuu<10)if(TrMap[j+mapy][i+mapx])til=int(&tiles)+1024*98;
  1054.             //if(uuu>10&&uuu<21)
  1055.             //if(LLock[j+mapy][i+mapx])til=int(&tiles)+1024*98;
  1056.             /*__asm{
  1057.                 push    esi
  1058.                 push    edi
  1059.                 mov        eax,31
  1060.                 cld
  1061.                 mov        edi,scr
  1062.                 mov        esi,til
  1063. Lab12:            mov        ecx,31
  1064.                 rep        movsb
  1065.                 inc        esi;
  1066.                 inc        edi
  1067.                 add        edi,ScreenSizeX32
  1068.                 dec        eax
  1069.                 jnz        Lab12
  1070.                 pop        edi
  1071.                 pop        esi
  1072.             }*/
  1073.             __asm{
  1074.                 push    esi
  1075.                 push    edi
  1076.                 mov        eax,32
  1077.                 cld
  1078.                 mov        edi,scr
  1079.                 mov        esi,til
  1080. Lab12:            mov        ecx,8
  1081.                 rep        movsd
  1082.                 /*fild    qword ptr [esi]
  1083.                 fist    qword ptr [edi]
  1084.                 fild    qword ptr [esi+8]
  1085.                 fist    qword ptr [edi+8]
  1086.                 fild    qword ptr [esi+16]
  1087.                 fist    qword ptr [edi+16]
  1088.                 fild    qword ptr [esi+24]
  1089.                 fist    qword ptr [edi+24]
  1090.                 add        esi,32
  1091.                 add        edi,32*/
  1092.                 add        edi,SDX
  1093.                 dec        eax
  1094.                 jnz        Lab12
  1095.                 pop        edi
  1096.                 pop        esi
  1097.             };
  1098.                 /*if(LLock[j+mapy][i+mapx])
  1099.                     Xbar(smapx+i*32+2,smapy+j*32+2,28,28,15);
  1100.                 if(TrMap[j+mapy][i+mapx]){
  1101.                     Xbar(smapx+i*32,smapy+j*32,32,32,15);
  1102.                     Xbar(smapx+i*32+1,smapy+j*32+1,30,30,15);
  1103.                 };*/
  1104.     }
  1105.     SetRLCWindow(0,smapy,COPYSizeX+128,32*smaply,SCRSizeX);
  1106.     ShowResScreen();
  1107.     //SetRLCWindow(smapx,smapy,32*smaplx,32*smaply,32*ScreenSizeX);
  1108.     for(j=0;j<smaply;j++){
  1109.         for(i=-1;i<=smaplx;i++){
  1110.             int p=Died[j+mapy][i+mapx];
  1111.             if(p!=0xFFFF){
  1112.                 OneObject* GG=Group[p];
  1113.                 Octant* Oc2=GG->CurAnm;
  1114.                 OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1115.                 byte clr=GG->NNUM;
  1116.                 int spr=Oc1->spr;
  1117.                 if(spr<4096)
  1118.                 if(Group[p]->Invert) 
  1119.                 ShowRLCItem((i+1)*32+smapx-Oc1->dx,j*32+smapy+Oc1->dy,
  1120.                     &MImage[Oc1->FileID],spr+4096,clr);
  1121.                 else
  1122.                     ShowRLCItem(i*32+smapx+Oc1->dx,j*32+smapy+Oc1->dy,
  1123.                         &MImage[Oc1->FileID],spr,clr);
  1124.                 //ShowHealth(GG);
  1125.                 //ShowFog(GG);
  1126.             };
  1127.         };
  1128.         for(i=-1;i<=smaplx;i++){
  1129.             int p=Mops[j+mapy][i+mapx];
  1130.             if(p!=0xFFFF){
  1131.                 OneObject* GG=Group[p];
  1132.                 int    ddy=GG->Addy;
  1133.                 if(ddy<0){
  1134.                     byte clr=GG->NNUM;
  1135.                     Octant* Oc2=GG->CurAnm;
  1136.                     int    ddx=GG->Addx;
  1137.                     OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1138.                     int spr=Oc1->spr;
  1139.                     if(spr<4096)
  1140.                     if(Group[p]->Invert) 
  1141.                         ShowRLCItem(ddx+(i+1)*32+smapx-Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1142.                             &MImage[Oc1->FileID],spr+4096,clr);
  1143.                     else
  1144.                         ShowRLCItem(ddx+i*32+smapx+Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1145.                             &MImage[Oc1->FileID],spr,clr);
  1146.                     ShowHealth(GG);
  1147.                     ShowProperty(GG);
  1148.                 };
  1149.             };
  1150.         };
  1151.         for(i=-3;i<smaplx;i++){
  1152.             int p=i+mapx>0?Mops[j+mapy][i+mapx]:0xffff;
  1153.             if(p!=0xFFFF){
  1154.                 OneObject* GG=Group[p];
  1155.                 int    ddy=GG->Addy;
  1156.                 if(ddy==0){
  1157.                     byte clr=GG->NNUM;
  1158.                     if(!(GG->capBuilding&&(GG->x!=i+mapx||GG->y!=j+mapy))){
  1159.                         Octant* Oc2=GG->CurAnm;
  1160.                         int    ddx=GG->Addx;
  1161.                         OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1162.                         int spr=Oc1->spr;
  1163.                         if(spr<4096)
  1164.                         if(Group[p]->Invert) 
  1165.                             ShowRLCItem(ddx+(i+1)*32+smapx-Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1166.                                 &MImage[Oc1->FileID],spr+4096,clr);
  1167.                         else
  1168.                             ShowRLCItem(ddx+i*32+smapx+Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1169.                                 &MImage[Oc1->FileID],spr,clr);
  1170.                         ShowHealth(GG);
  1171.                         ShowProperty(GG);
  1172.                     };
  1173.                 
  1174.                 };
  1175.             };
  1176.         };
  1177.         for(i=0;i<smaplx;i++){
  1178.             int p=Mops[j+mapy][i+mapx];
  1179.             if(p!=0xFFFF){
  1180.                 OneObject* GG=Group[p];
  1181.                 int    ddy=GG->Addy;
  1182.                 if(ddy>0){
  1183.                     byte clr=GG->NNUM;
  1184.                     Octant* Oc2=GG->CurAnm;
  1185.                     int    ddx=GG->Addx;
  1186.                     OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1187.                     int spr=Oc1->spr;
  1188.                     if(spr<4096)
  1189.                     if(Group[p]->Invert) 
  1190.                         ShowRLCItem(ddx+(i+1)*32+smapx-Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1191.                             &MImage[Oc1->FileID],spr+4096,clr);
  1192.                     else
  1193.                         ShowRLCItem(ddx+i*32+smapx+Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1194.                             &MImage[Oc1->FileID],spr,clr);
  1195.                     ShowHealth(GG);
  1196.                     ShowProperty(GG);
  1197.                 };
  1198.             };
  1199.         }
  1200.     };
  1201.     ProcessExpl();
  1202.     ShowFlyingMonsters();
  1203.     ProcessFog();
  1204.     SetRLCWindow(0,0,COPYSizeX,RSCRSizeY,SCRSizeX);
  1205.     //void* SCR1=ScreenPtr;
  1206.     //if(!DDDebug)ScreenPtr=RealScreenPtr;
  1207.     //ShowBorder();
  1208.     if(!MiniMade)CreateMiniMap();
  1209.     int ssx;
  1210.     int ssy;
  1211.     if(msx>128)ssx=msx>>3;else ssx=msx>>2;
  1212.     if(msy>128)ssy=msy>>1;else ssy=msy;
  1213.     for(i=0;i<ssy;i++){
  1214.         //if(
  1215.         scr=int(ScreenPtr)+minix+(i+miniy)*SCRSizeX;
  1216.         //til=int(&TrMap)+i*maxmap;
  1217.         til=int(&minimap)+i*maxmap;
  1218.         //til=int(AsmUsage)+i*128;
  1219.         //til=int(EUsage)+i*128;
  1220.         //til=int(&T[0][0])+i*256;
  1221.         __asm{
  1222.             push    esi
  1223.             push    edi
  1224.             mov        ecx,ssx
  1225.             cld
  1226.             mov        esi,til
  1227.             mov        edi,scr
  1228.             rep        movsd
  1229. uiyt:
  1230.         /*    fild    qword ptr [esi]
  1231.             add        esi,8
  1232.             fist    qword ptr [edi]
  1233.             add        edi,8
  1234.             loop    uiyt*/
  1235.             pop        edi
  1236.             pop        esi
  1237.         }
  1238.     }
  1239.     CBar(minix-1,miniy-1,msx+2,msy+2,255);
  1240.     /*for(i=0;i<msy;i++){
  1241.         scr=int(RealScreenPtr)+minix+(i+miniy+140)*ScreenSizeX;
  1242.         //til=int(&TrMap)+i*maxmap;
  1243.         til=int(&minimap)+i*maxmap;
  1244.         til=int(OrdUsage)+i*128;
  1245.         //til=int(EUsage)+i*128;
  1246.         __asm{
  1247.             push    esi
  1248.             push    edi
  1249.             mov        ecx,ssx
  1250.             cld
  1251.             mov        esi,til
  1252.             mov        edi,scr
  1253.             rep        movsd
  1254.             pop        edi
  1255.             pop        esi
  1256.         }
  1257.     }*/
  1258.     if(BuildMode){
  1259.         if(mouseX>=smapx&&mouseY>=smapy&&mouseX<smapx*(smaplx-blx+1)*32&&mouseY<smapy+(smaply-bly+1)*32){
  1260.             int xxx=mouseX&(65535-31);
  1261.             int yyy=mouseY&(65535-31);
  1262.             xxx=mapx+((xxx-smapx)>>5);    
  1263.             yyy=mapy+((yyy-smapy)>>5);
  1264.             if(!(CheckGold(xxx,yyy,BNat->Mon[BuildingID])&&ManualFogCheck(xxx,yyy,BNat->Mon[BuildingID]->SizeX)&&BNat->CheckBuilding(BuildingID,xxx,yyy)))
  1265.                 RedBar(xxx,yyy,blx,bly);else
  1266.                 WhiteBar(xxx,yyy,blx,bly);
  1267.             xxx=mouseX&(65535-31);
  1268.             yyy=mouseY&(65535-31);
  1269.             ShowRLCItem(xxx+OSB->dx,yyy+OSB->dy,
  1270.             &MImage[OSB->FileID],OSB->spr,MyNation);
  1271.             
  1272.         };
  1273.     };
  1274.     if(BuildWall)TMPCluster.ShowCluster();
  1275.     ShowProp();
  1276.     ShowAbility();
  1277.     word mp;
  1278.     OneObject* OO;
  1279.     byte mxx,myy,val;
  1280.     for(int g=0;g<MAXOBJECT;g++){
  1281.         OO=Group[g];
  1282.         if(OO){
  1283.             mxx=OO->x>>1;
  1284.             myy=OO->y>>1;
  1285.             val=CLRT[OO->NNUM];
  1286.             scr=int(ScreenPtr)+minix+mxx+(myy+miniy)*SCRSizeX;
  1287.             __asm{
  1288.                 mov    eax,scr
  1289.                 mov    bl,val
  1290.                 mov    [eax],bl
  1291.             };
  1292.         };
  1293.     };
  1294.     /*
  1295.     for(i=0;i<msx;i++)for(j=0;j<msy;j++){
  1296.         mp=Mops[j][i];
  1297.         if(mp!=0xFFFF){
  1298.             scr=int(ScreenPtr)+minix+i+(j+miniy)*SCRSizeX;
  1299.             byte val=Group[mp]->NMask;
  1300.             __asm{
  1301.                 mov    eax,scr
  1302.                 mov    bl,val
  1303.                 mov    [eax],bl
  1304.             };
  1305.         };
  1306.     };
  1307.     */
  1308.     AcceptMiniMap();
  1309.     ShowFoggedBattle();
  1310.     Xbar(minix+(mapx>>1),miniy+(mapy>>1),smaplx>>1,smaply>>1,14);
  1311.     //ScreenPtr=SCR1;
  1312.     int x=mouseX;
  1313.     int y=mouseY;
  1314.     ssy=smapy+3;
  1315.     //if(PromptTime>0){
  1316.     //    ShowString(smapx,smapy+smaply*32-32,Prompt,&f16x16w);
  1317.     //    PromptTime--;
  1318.     //};
  1319.     ProcessHint();
  1320.     ssy+=20;
  1321.     char ggg[600];
  1322.     int uxxx=mapx+((mouseX-smapx)>>5);
  1323.     int uyyy=mapy+((mouseY-smapy)>>5);
  1324.     OutCInf(uxxx,uyyy);
  1325.     int sy1=RSCRSizeY-128;
  1326.     ShowString(5,sy1,"\x1 └Γ≥ε α≥αΩα",&f16x16w);
  1327.     sy1+=16;
  1328.     ShowString(5,sy1,"\x1 ╧ε∞επα≥ⁿ ≥εΓα≡Φ∙≤",&f16x16w);
  1329.     sy1+=16;
  1330.     ShowString(5,sy1,"\x1 ╬≥Γσ≈α≥ⁿ φα α≥αΩ≤",&f16x16w);
  1331.     sy1+=16;
  1332.     ShowString(5,sy1,"\x3\x4 ╧ε≡αµσφΦσ ±≥σφ:10%",&f16x16r);
  1333.     sy1+=16;
  1334.     //ShowString(20,RSCRSizeY-64,"\x1\x2\x3\x4\x5\x6\x7",&f16x16w);
  1335.     sprintf(ggg,"(%d,%d)",uxxx,uyyy);
  1336.     ShowString(smapx,smapy+smaply*32-64-32,ggg,&f16x16w);
  1337.     Nation* NT=&NATIONS[MyNation];
  1338.     //_CrtMemState CMS;
  1339.     //_CrtMemCheckpoint(&CMS);
  1340.     //sprintf(ggg,"ALLOCATED:%d" ,CMS.lTotalCount);
  1341.     //ShowString(smapx,ssy,ggg,&f16x16w);
  1342.     //ssy+=16;
  1343.     //sprintf(ggg,"PITCH:%d" ,Pitch);
  1344.     //ShowString(smapx,ssy,ggg,&f16x16w);
  1345.     //ssy+=16;
  1346.     sprintf(ggg,"Farms:%d,Gidot:%d" ,NT->NFarms,NT->NGidot);
  1347.     ShowString(smapx,ssy,ggg,&f16x16w);
  1348.     ssy+=16;
  1349.     sprintf(ggg,"%d,%d" ,LASTIND,LASTRAND);
  1350.     ShowString(smapx,ssy,ggg,&f16x16w);
  1351.     ssy+=16;
  1352.     sprintf(ggg,"Time:%d" ,tmtmt);
  1353.     ShowString(smapx,ssy,ggg,&f16x16w);
  1354.     ssy+=16;
  1355.     sprintf(ggg,"Sequene errors:%d (%d)" ,SeqErrorsCount,LastRandDif);
  1356.     ShowString(smapx,ssy,ggg,&f16x16w);
  1357.     ssy+=16;
  1358.     ShowRMap();
  1359.     if(InfoMode)return;
  1360.     sprintf(ggg,"Strong factor:%d" ,NForces[MyNation].StrongFactor);
  1361.     ShowString(smapx,ssy,ggg,&f16x16w);
  1362.     ssy+=16;
  1363.     //if(AttackMode)ShowString(smapx,ssy,"╨σµΦ∞ α≥αΩΦ",&f16x16w);
  1364.     //else ShowString(smapx,ssy,"╨σµΦ∞ ∩σ≡σ∞σ∙σφΦ ",&f16x16w);
  1365.     //ssy+=16;
  1366.     if(EgoFlag)ShowString(smapx,ssy,"╨σµΦ∞ ±ΓαδΦΓαφΦ  ε≥ Γ≡απα",&f16x16w);
  1367.     else ShowString(smapx,ssy,"╨σµΦ∞ ßε≡ⁿß√ ± Γ≡απε∞",&f16x16w);
  1368.     ssy+=16;
  1369.     sprintf(ggg,"FPS:%d, Waiting: %d" ,Flips,WaitCycle);
  1370.     counter=0;
  1371.     ShowString(smapx,ssy,ggg,&f16x16w);
  1372.     ssy+=16;
  1373.     sprintf(ggg,"┬±σπε ≥Γα≡■Ω:%d",NMONS);
  1374.     ShowString(smapx,ssy,ggg,&f16x16w);
  1375.     ssy+=20;
  1376.     int sapx=smapx+4;
  1377.     if(!NSL[MyNation])return;
  1378.     OneObject* OBB=Group[Selm[MyNation][0]];
  1379.     if(int(OBB)){
  1380.         sprintf(ggg,"═ε∞σ≡ Φτß≡αφφεΘ ≥Γα≡■ΩΦ :%d,(x=%d,y=%d)",
  1381.             OBB->Index,
  1382.             OBB->x,
  1383.             OBB->y);
  1384.         ShowString(smapx,ssy,ggg,&f16x16w);
  1385.         ssy+=16;
  1386.         sprintf(ggg,"═≤∞σ≡ ∩δσ∞σφΦ:%d",OBB->NMask);
  1387.         ShowString(sapx,ssy,ggg,&f16x16w);
  1388.         ssy+=16;
  1389.         sprintf(ggg,"Vx,Vy=%d,%d",OBB->RealVx,OBB->RealVy);
  1390.         ShowString(sapx,ssy,ggg,&f16x16w);
  1391.         ssy+=16;
  1392.         /*sprintf(ggg,"┬ετπε≡ΣΦδα±ⁿ δⁿ ≥Γα≡ⁿ?:%d",OBB->Important&1);
  1393.         ShowString(sapx,ssy,ggg,&f16x16w);
  1394.         ssy+=16;*/
  1395.         //sprintf(ggg,"╞δεß·:%d",OBB->Egoist&1);
  1396.         //ShowString(sapx,ssy,ggg,&f16x16w);
  1397.         //ssy+=16;
  1398.         if(OBB->CrowdRef){
  1399.             ssy+=10;
  1400.             Crowd* CR=OBB->CrowdRef;
  1401.             ShowString(sapx,ssy,CR->Message,&f16x16w);
  1402.             ssy+=16;
  1403.             sprintf(ggg,"└≥αΩεΓα≥ⁿ:");
  1404.             char gxx[10];
  1405.             for(int u=0;u<32;u++){
  1406.                 int pp=CR->ForAtt[u];
  1407.                 if(pp!=0xFFFF){
  1408.                     sprintf(gxx,"%d(%d) ",pp,u);
  1409.                     strcat(ggg,gxx);
  1410.                 };
  1411.             };
  1412.             ShowString(sapx,ssy,ggg,&f16x16w);
  1413.             ssy+=16;
  1414.             sprintf(ggg,"╫Φ±δσφφε±≥ⁿ:%d",CR->NMembers);
  1415.             ShowString(sapx,ssy,ggg,&f16x16w);
  1416.             ssy+=16;
  1417.             //sprintf(ggg,"SizeX:%d",L->SizeX1);
  1418.             //ShowString(sapx,ssy,ggg,&f16x16w);
  1419.             //ssy+=16;
  1420.         };
  1421.         if(OBB->MoveInRect){
  1422.             sprintf(ggg,"╩ΓαΣ≡α≥ φατφα≈σφΦ :(%d,%d)-(%d,%d)",
  1423.                 OBB->destX,
  1424.                 OBB->destY,
  1425.                 OBB->destX1,
  1426.                 OBB->destY1);
  1427.             ShowString(sapx,ssy,ggg,&f16x16w);
  1428.             ssy+=16;
  1429.             sprintf(ggg,"╥ε≈Ωα φατφα≈σφΦ :(%d,%d)",
  1430.                 OBB->lastX,
  1431.                 OBB->lastY);
  1432.             ShowString(sapx,ssy,ggg,&f16x16w);
  1433.             ssy+=20;
  1434.         };
  1435.         if(int(OBB->LocalOrder)){
  1436.             ShowString(sapx-4,ssy,"╪≥ε ∞φσ φεφ≈σ Σσδα≥ⁿ.",&f16x16w);
  1437.             ssy+=16;
  1438.             Order1* LOL=OBB->LocalOrder;
  1439.             do{
  1440.                 switch(LOL->OrderType){
  1441.                 case 2:    sprintf(ggg,"╧εΓσδσφΦσ:(╧εΣⁿ Ωα Γ:x=%d,y=%d)",
  1442.                             LOL->info.MoveToXY.x,
  1443.                             LOL->info.MoveToXY.y);
  1444.                         break;
  1445.                 case 77:sprintf(ggg,"╧εΓσδσφΦσ:(╙ΘΣΦ ± Σε≡επΦ, εΩα φφ√Θ!:dir=%d)%d",
  1446.                             LOL->info.MoveFrom.dir);
  1447.                         break;
  1448.                 case 3:sprintf(ggg,"╧εΓσδσφΦσ:(╠ε≈Φ≥ⁿ ≥Γα≡ⁿ:%d)",
  1449.                             OBB->EnemyID);
  1450.                         break;
  1451.                 default:sprintf(ggg,"╧εΓσδσφΦσ:(─≤≡φΦ÷i  Ωi±ⁿ:%d)",
  1452.                             LOL->OrderType);
  1453.                 };
  1454.                 ShowString(sapx,ssy,ggg,&rlf_s);
  1455.                 ssy+=16;
  1456.                 LOL=LOL->NextOrder;
  1457.                 if(ssy>500)return;
  1458.             }while(int(LOL));
  1459.         };
  1460.         ssy=smapy;
  1461.         sapx=smapx+smaplx*16+100;
  1462.         /*if(int(OBB->Wars)){
  1463.             ShowString(sapx,ssy,"Legion information",&f16x16w);
  1464.             ssy+=20;
  1465.             Legion* L=OBB->Wars;
  1466.             sprintf(ggg,"Members:%d",L->NMemb);
  1467.             ShowString(sapx,ssy,ggg,&f16x16w);
  1468.             ssy+=16;
  1469.             sprintf(ggg,"Full complectation:%d",L->NNeed);
  1470.             ShowString(sapx,ssy,ggg,&f16x16w);
  1471.             ssy+=16;
  1472.             sprintf(ggg,"Minx:%d",L->minx);
  1473.             ShowString(sapx,ssy,ggg,&f16x16w);
  1474.             ssy+=16;
  1475.             sprintf(ggg,"Miny:%d",L->miny);
  1476.             ShowString(sapx,ssy,ggg,&f16x16w);
  1477.             ssy+=16;
  1478.             sprintf(ggg,"Maxx:%d",L->maxx);
  1479.             ShowString(sapx,ssy,ggg,&f16x16w);
  1480.             ssy+=16;
  1481.             sprintf(ggg,"Maxy:%d",L->maxy);
  1482.             ShowString(sapx,ssy,ggg,&f16x16w);
  1483.             ssy+=16;
  1484.             sprintf(ggg,"SizeX:%d",L->SizeX1);
  1485.             ShowString(sapx,ssy,ggg,&f16x16w);
  1486.             ssy+=16;
  1487.             sprintf(ggg,"SizeY:%d",L->SizeY1);
  1488.             ShowString(sapx,ssy,ggg,&f16x16w);
  1489.             ssy+=16;
  1490.             sprintf(ggg,"╧ε≡ ΣεΩ:%d",L->Ordering);
  1491.             ShowString(sapx,ssy,ggg,&f16x16w);
  1492.             ssy+=16;
  1493.             int wdx=0;
  1494.             int nn=0;
  1495.             while(ssy<600-20&&nn<L->NMemb){
  1496.                 int zz=L->Member[nn];
  1497.                 sprintf(ggg,"%d",zz);
  1498.                 ShowString(sapx+wdx*32,ssy,ggg,&f16x16w);
  1499.                 wdx++;
  1500.                 if(wdx>5){
  1501.                     wdx=0;
  1502.                     ssy+=16;
  1503.                 };
  1504.                 nn++;
  1505.             };
  1506.         };*/
  1507.     };
  1508. };
  1509. void ShowWinner(){
  1510.     char sss[128]="";
  1511.     if(!NMyUnits){
  1512.         strcpy(sss,"┬█ ╧╨╬╚├╨└╦╚ !");
  1513.     }else{
  1514.         if(!NThemUnits)
  1515.             strcpy(sss,"╧╬╟─╨└┬╦▀┼╠ ╧╬┴┼─╚╥┼╦▀!");
  1516.     };
  1517.     int lx=GetRLen(sss,&FPassive)>>1;
  1518.     if(lx)ShowString(smapx+(smaplx<<(Shifter-1))-lx,smapy+(smaply<<(Shifter-1)),sss,&FPassive);
  1519. };
  1520. //final procedures for graphics output
  1521. void miniGFieldShow();
  1522. void GFieldShow(){
  1523.     if(MiniMode){
  1524.         miniGFieldShow();
  1525.         return;
  1526.     };
  1527.     int i;
  1528.     int j;
  1529.     int scr;
  1530.     int til;
  1531.     int uuu=(tmt&31);
  1532.     char ggg[600];
  1533.     tmt++;
  1534.     time1=GetTickCount();
  1535.     if(FogMode){
  1536.         for(j=0;j<smaply;j++)
  1537.             for(i=0;i<smaplx;i++)if(fmap[j+mapy][i+mapx]>512){
  1538.                 int til=int(RenderSquare(i+mapx,j+mapy));
  1539.                 if(til){
  1540.                     scr=int(ScreenPtr)+(i<<5)+smapx+((j<<5)+smapy)*SCRSizeX;
  1541.                     int SDX=SCRSizeX-32;
  1542.                     __asm{
  1543.                         push    esi
  1544.                         push    edi
  1545.                         mov        eax,32
  1546.                         cld
  1547.                         mov        edi,scr
  1548.                         mov        esi,til
  1549. Lab12:                    mov        ecx,8
  1550.                         rep        movsd
  1551.                         add        edi,SDX
  1552.                         dec        eax
  1553.                         jnz        Lab12
  1554.                         pop        edi
  1555.                         pop        esi
  1556.                     };    
  1557.                 };
  1558.             };
  1559.     }else{
  1560.         for(j=0;j<smaply;j++)
  1561.             for(i=0;i<smaplx;i++){
  1562.                 int til=int(RenderSquare(i+mapx,j+mapy));
  1563.                 if(til){
  1564.                     scr=int(ScreenPtr)+(i<<5)+smapx+((j<<5)+smapy)*SCRSizeX;
  1565.                     int SDX=SCRSizeX-32;
  1566.                     __asm{
  1567.                         push    esi
  1568.                         push    edi
  1569.                         mov        eax,32
  1570.                         cld
  1571.                         mov        edi,scr
  1572.                         mov        esi,til
  1573. Labx12:                    mov        ecx,8
  1574.                         rep        movsd
  1575.                         add        edi,SDX
  1576.                         dec        eax
  1577.                         jnz        Labx12
  1578.                         pop        edi
  1579.                         pop        esi
  1580.                     };    
  1581.                 };
  1582.             };
  1583.     };
  1584.     time6=GetTickCount()-time1;
  1585.             /*
  1586.             scr=int(ScreenPtr)+(i<<5)+smapx+((j<<5)+smapy)*SCRSizeX;
  1587.             til=int(&tiles)+(int(tmap[i+mapx-1][j+mapy-1])<<10);
  1588.             int SDX=SCRSizeX-32;
  1589.             __asm{
  1590.                 push    esi
  1591.                 push    edi
  1592.                 mov        eax,32
  1593.                 cld
  1594.                 mov        edi,scr
  1595.                 mov        esi,til
  1596. Lab12:            mov        ecx,8
  1597.                 rep        movsd
  1598.                 add        edi,SDX
  1599.                 dec        eax
  1600.                 jnz        Lab12
  1601.                 pop        edi
  1602.                 pop        esi
  1603.             };*/
  1604.     
  1605.     SetRLCWindow(smapx,smapy,smaplx<<5,smaply<<5,SCRSizeX);
  1606.     if(EditMapMode){
  1607.         for(i=0;i<8;i++){
  1608.             int x=mapPos[i<<1];
  1609.             int y=mapPos[(i<<1)+1];
  1610.             if(x>=mapx&&y>=mapy&&x<mapx+smaplx&&y<mapy+smaply){
  1611.                 sprintf(ggg,"%d",i+1);
  1612.                 ShowString(smapx+((x-mapx)<<5)+8,smapy+((y-mapy)<<5)+2,ggg,&f32x32w);
  1613.             };
  1614.         };
  1615.     };
  1616.     ShowResScreen();
  1617.     for(j=0;j<smaply;j++){
  1618.         for(i=-1;i<=smaplx;i++){
  1619.             int p=Died[j+mapy][i+mapx];
  1620.             if(p!=0xFFFF){
  1621.                 OneObject* GG=Group[p];
  1622.                 Octant* Oc2=GG->CurAnm;
  1623.                 OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1624.                 byte clr=GG->NNUM;
  1625.                 int spr=Oc1->spr;
  1626.                 if(spr<4096)
  1627.                 if(Group[p]->Invert) 
  1628.                 ShowRLCItem((i+1)*32+smapx-Oc1->dx,j*32+smapy+Oc1->dy,
  1629.                     &MImage[Oc1->FileID],spr+4096,clr);
  1630.                 else
  1631.                     ShowRLCItem(i*32+smapx+Oc1->dx,j*32+smapy+Oc1->dy,
  1632.                         &MImage[Oc1->FileID],spr,clr);
  1633.             };
  1634.         };
  1635.         for(i=-1;i<=smaplx;i++){
  1636.             int p=Mops[j+mapy][i+mapx];
  1637.             if(p!=0xFFFF){
  1638.                 OneObject* GG=Group[p];
  1639.                 if(GG){
  1640.                     int    ddy=GG->Addy;
  1641.                     if(ddy<0){
  1642.                         byte clr=GG->NNUM;
  1643.                         Octant* Oc2=GG->CurAnm;
  1644.                         int    ddx=GG->Addx;
  1645.                         OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1646.                         int spr=Oc1->spr;
  1647.                         //-----------
  1648.                         int hy=GetHig((int(GG->x)<<5)+GG->Addx,(int(GG->y)<<5)+GG->Addy);
  1649.                         //-----------
  1650.                         if(spr<4096)
  1651.                         if(Group[p]->Invert) 
  1652.                             ShowRLCItem(ddx+(i+1)*32+smapx-Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1653.                                 &MImage[Oc1->FileID],spr+4096,clr);
  1654.                         else
  1655.                             ShowRLCItem(ddx+i*32+smapx+Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1656.                                 &MImage[Oc1->FileID],spr,clr);
  1657.                         ShowHealth(GG);
  1658.                         ShowProperty(GG);
  1659.                     };
  1660.                 };
  1661.             };
  1662.         };
  1663.         for(i=-3;i<smaplx;i++){
  1664.             int p=i+mapx>0?Mops[j+mapy][i+mapx]:0xffff;
  1665.             if(p!=0xFFFF){
  1666.                 OneObject* GG=Group[p];
  1667.                 if(GG){
  1668.                     int    ddy=GG->Addy;
  1669.                     if(ddy==0){
  1670.                         byte clr=GG->NNUM;
  1671.                         if(!(GG->capBuilding&&(GG->x!=i+mapx||GG->y!=j+mapy))){
  1672.                             Octant* Oc2=GG->CurAnm;
  1673.                             //-----------
  1674.                             int hy=GetHig((int(GG->x)<<5)+GG->Addx,(int(GG->y)<<5)+GG->Addy);
  1675.                             //-----------
  1676.                             int    ddx=GG->Addx;
  1677.                             OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1678.                             int spr=Oc1->spr;
  1679.                             if(spr<4096)
  1680.                             if(Group[p]->Invert) 
  1681.                                 ShowRLCItem(ddx+(i+1)*32+smapx-Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1682.                                     &MImage[Oc1->FileID],spr+4096,clr);
  1683.                             else
  1684.                                 ShowRLCItem(ddx+i*32+smapx+Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1685.                                     &MImage[Oc1->FileID],spr,clr);
  1686.                             ShowHealth(GG);
  1687.                             ShowProperty(GG);
  1688.                         };
  1689.                     
  1690.                     };
  1691.                 };
  1692.             };
  1693.         };
  1694.         for(i=0;i<smaplx;i++){
  1695.             int p=Mops[j+mapy][i+mapx];
  1696.             if(p!=0xFFFF){
  1697.                 OneObject* GG=Group[p];
  1698.                 if(GG){
  1699.                     int    ddy=GG->Addy;
  1700.                 if(ddy>0){
  1701.                         byte clr=GG->NNUM;
  1702.                         Octant* Oc2=GG->CurAnm;
  1703.                         //-----------
  1704.                         int hy=GetHig((int(GG->x)<<5)+GG->Addx,(int(GG->y)<<5)+GG->Addy);
  1705.                         //-----------
  1706.                         int    ddx=GG->Addx;
  1707.                         OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  1708.                         int spr=Oc1->spr;
  1709.                         if(spr<4096)
  1710.                         if(Group[p]->Invert) 
  1711.                             ShowRLCItem(ddx+(i+1)*32+smapx-Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1712.                                 &MImage[Oc1->FileID],spr+4096,clr);
  1713.                         else
  1714.                             ShowRLCItem(ddx+i*32+smapx+Oc1->dx,ddy+j*32+smapy+Oc1->dy,
  1715.                                 &MImage[Oc1->FileID],spr,clr);
  1716.                         ShowHealth(GG);
  1717.                         ShowProperty(GG);
  1718.                     };
  1719.                 };
  1720.             };
  1721.         }
  1722.     };
  1723.     //for(int jj=0;jj<10;jj++)
  1724.     //ShowSuperFluentFog(smapx+32,smapy+32,31,31,31,0);
  1725.     ProcessExpl();
  1726.     ShowFlyingMonsters();
  1727.     if(FogMode)ProcessFog();
  1728.     int v1=3;
  1729.     int v2=158;
  1730.     //ShowSuperFluentFog32_160(200,200,v1,v1,v1,v2);
  1731.     //ShowSuperFluentFog32_160(200+32,200,v1,v1,v2,v1);
  1732.     //ShowSuperFluentFog32_160(200,200+32,v1,v2,v1,v1);
  1733.     //ShowSuperFluentFog32_160(200+32,200+32,v2,v1,v1,v1);
  1734.     if(EditMapMode){
  1735.         if(ChoosePosition)
  1736.             sprintf(ggg,"╚π≡εΩ %d : ┬√ßε≡ ±≥α≡≥εΓεΘ ∩ετΦ÷ΦΦ.",MyNation);
  1737.         else sprintf(ggg,"╚π≡εΩ %d.",MyNation+1);
  1738.         ShowString(smapx+32,smapy+64,ggg,&f16x16w);
  1739.     };
  1740.     SetRLCWindow(0,0,COPYSizeX,RSCRSizeY,SCRSizeX);
  1741.     if(BuildMode){
  1742.         if(mouseX>=smapx&&mouseY>=smapy&&mouseX<smapx*(smaplx-blx+1)*32&&mouseY<smapy+(smaply-bly+1)*32){
  1743.             int xxx=mouseX&(65535-31);
  1744.             int yyy=mouseY&(65535-31);
  1745.             xxx=mapx+((xxx-smapx)>>5);    
  1746.             yyy=mapy+((yyy-smapy)>>5);
  1747.             if(!(CheckGold(xxx,yyy,BNat->Mon[BuildingID])&&ManualFogCheck(xxx,yyy,BNat->Mon[BuildingID]->SizeX)&&BNat->CheckBuilding(BuildingID,xxx,yyy)))
  1748.                 RedBar(xxx,yyy,blx,bly);else
  1749.                 WhiteBar(xxx,yyy,blx,bly);
  1750.             xxx=mouseX&(65535-31);
  1751.             yyy=mouseY&(65535-31);
  1752.             ShowRLCItem(xxx+OSB->dx,yyy+OSB->dy,
  1753.                 &MImage[OSB->FileID],OSB->spr,MyNation&3);
  1754.             
  1755.         };
  1756.     };
  1757.     if(BuildWall)TMPCluster.ShowCluster();
  1758.     if(FogMode)ShowFoggedBattle();
  1759.     ProcessHint();
  1760.     ShowDestn();
  1761.     time7=GetTickCount()-time1-time6;
  1762.     if(SeqErrorsCount){
  1763.         ShowString(HintX,HintY-100,"┬═╚╠└═╚┼!!! ═└╨╙╪┼═╚┼ ╤╚═╒╨╬═╚╟└╓╚╚ !!!!",&FActive);
  1764.         SeqErrorsCount=0;
  1765.     };
  1766.     if(EditMapMode){
  1767.         for(i=0;i<8;i++){
  1768.             RESRC[i][1]=100000;
  1769.             RESRC[i][2]=100000;
  1770.             RESRC[i][3]=100000;
  1771.         };
  1772.     }else ShowWinner();
  1773.     //information
  1774.     if(HelpMode){
  1775.         int scx=smapx+64;
  1776.         int scy=smapy+128;
  1777.         if(EditMapMode){
  1778.             ShowString(scx+100,scy,"╨σαΩ≥ε≡ Ωα≡≥√. (F1 - ≤ß≡α≥ⁿ φαΣ∩Φ±Φ)",&f16x16w);
  1779.             scy+=20;
  1780.             ShowString(scx,scy,"'P' - Γ√ßε≡ εß·σΩ≥α",&f16x16w);
  1781.             scy+=20;
  1782.             ShowString(scx,scy,"F1  - Help",&f16x16w);
  1783.             scy+=20;
  1784.             ShowString(scx,scy,"F2  - ╥≡αΓα",&f16x16w);
  1785.             scy+=20;
  1786.             ShowString(scx,scy,"F3  - ╧≤±≥√φ ",&f16x16w);
  1787.             scy+=20;
  1788.             ShowString(scx,scy,"F4  - ╦σ±",&f16x16w);
  1789.             scy+=20;
  1790.             ShowString(scx,scy,"F5  - ┬εΣα",&f16x16w);
  1791.             scy+=20;
  1792.             ShowString(scx,scy,"F6  - ╩α∞φΦ",&f16x16w);
  1793.             scy+=20;
  1794.             ShowString(scx,scy,"F7  - ╤ετΣα≥ⁿ Γ√∩≤Ωδε±≥ⁿ",&f16x16w);
  1795.             scy+=20;
  1796.             ShowString(scx,scy,"F8  - ╤ετΣα≥ⁿ Γ∩αΣΦφ≤",&f16x16w);
  1797.             scy+=20;
  1798.             //ShowString(scx,scy,"F8  - ╤πδαµΦΓαφΦσ",&f16x16w);
  1799.             //scy+=20;
  1800.             ShowString(scx,scy,"F9  - ≡σµΦ∞ ≤∩≡αΓδσφΦ ",&f16x16w);
  1801.             scy+=20;
  1802.             ShowString(scx,scy,"'1'..'9' - ┬√ßε≡ ≡ατ∞σ≡α ∩σ≡α",&f16x16w);
  1803.             scy+=20;
  1804.             ShowString(scx,scy,"'W' - ╧ε±≥≡εΘΩα ±≥σφ√",&f16x16w);
  1805.             scy+=20;
  1806.             ShowString(scx,scy,"'T' - ┬√ßε≡ ±≥α≡≥εΓεΘ ∩ετΦ÷ΦΦ",&f16x16w);
  1807.             scy+=20;
  1808.             ShowString(scx,scy,"'R' - ═α≈αδⁿφ√σ ≡σ±≤≡±√",&f16x16w);
  1809.             scy+=20;
  1810.             ShowString(scx,scy,"NUM 1..8 - ┬√ßε≡ φα÷ΦΦ",&f16x16w);
  1811.             scy+=20;
  1812.             ShowString(scx,scy,"L  - ╨σµΦ∞ Ωα≡≥√",&f16x16w);
  1813.             scy+=20;
  1814.         };
  1815.     };
  1816.     ShowRMap();
  1817.     if(EditMapMode)return;
  1818.     if(InfoMode)return;
  1819.     int ssy=smapy+3;
  1820.     ssy+=20;
  1821.     sprintf(ggg,"LastKey=%d" ,LastKey);
  1822.     ShowString(smapx,ssy,ggg,&f16x16w);
  1823.     ssy+=16;
  1824.     int uxxx=mapx+((mouseX-smapx)>>5);
  1825.     int uyyy=mapy+((mouseY-smapy)>>5);
  1826.     OutCInf(uxxx,uyyy);
  1827.     sprintf(ggg,"(%d,%d)",uxxx,uyyy);
  1828.     ShowString(smapx,smapy+smaply*32-64-32,ggg,&f16x16w);
  1829.     Nation* NT=&NATIONS[MyNation];
  1830.     sprintf(ggg,"AI=%d" ,NT->AI_Level+1);
  1831.     ShowString(smapx,ssy,ggg,&f16x16w);
  1832.     ssy+=16;
  1833.     sprintf(ggg,"Farms:%d,Gidot:%d" ,NT->NFarms,NT->NGidot);
  1834.     ShowString(smapx,ssy,ggg,&f16x16w);
  1835.     ssy+=16;
  1836.     sprintf(ggg,"%d,%d" ,LASTIND,LASTRAND);
  1837.     ShowString(smapx,ssy,ggg,&f16x16w);
  1838.     ssy+=16;
  1839.     sprintf(ggg,"CNTR: %d" ,COUNTER);
  1840.     ShowString(smapx,ssy,ggg,&f16x16w);
  1841.     COUNTER=0;
  1842.     ssy+=16;
  1843.     sprintf(ggg,"Time 2: %d" ,time2);
  1844.     ShowString(smapx,ssy,ggg,&f16x16w);
  1845.     ssy+=16;
  1846.     sprintf(ggg,"Time 3: %d" ,time3);
  1847.     ShowString(smapx,ssy,ggg,&f16x16w);
  1848.     ssy+=16;
  1849.     sprintf(ggg,"Time 4: %d" ,time4);
  1850.     ShowString(smapx,ssy,ggg,&f16x16w);
  1851.     ssy+=16;
  1852.     sprintf(ggg,"Time 5: %d" ,time5);
  1853.     ShowString(smapx,ssy,ggg,&f16x16w);
  1854.     ssy+=16;
  1855.     sprintf(ggg,"Time 6: %d" ,time6);
  1856.     ShowString(smapx,ssy,ggg,&f16x16w);
  1857.     ssy+=16;
  1858.     sprintf(ggg,"Time 7: %d" ,time7);
  1859.     ShowString(smapx,ssy,ggg,&f16x16w);
  1860.     ssy+=16;
  1861.     sprintf(ggg,"Time 8: %d" ,time8);
  1862.     ShowString(smapx,ssy,ggg,&f16x16w);
  1863.     ssy+=16;
  1864.     sprintf(ggg,"Time:%d" ,tmtmt);
  1865.     ShowString(smapx,ssy,ggg,&f16x16w);
  1866.     ssy+=16;
  1867.     sprintf(ggg,"Sequene errors:%d (%d)" ,SeqErrorsCount,LastRandDif);
  1868.     ShowString(smapx,ssy,ggg,&f16x16w);
  1869.     ssy+=16;
  1870.     //if(!InfoMode)return;
  1871.     sprintf(ggg,"Strong factor:%d" ,NForces[MyNation].StrongFactor);
  1872.     ShowString(smapx,ssy,ggg,&f16x16w);
  1873.     ssy+=16;
  1874.     sprintf(ggg,"RSCRSizeX:%d" ,RSCRSizeX);
  1875.     ShowString(smapx,ssy,ggg,&f16x16w);
  1876.     ssy+=16;
  1877.     sprintf(ggg,"minix=%d,miniy=%d" ,minix,miniy);
  1878.     ShowString(smapx,ssy,ggg,&f16x16w);
  1879.     ssy+=16;
  1880.     sprintf(ggg,"mx=%d,my=%d,lp=%d" ,mouseX,mouseY,Lpressed);
  1881.     ShowString(smapx,ssy,ggg,&f16x16w);
  1882.     ssy+=16;
  1883.     sprintf(ggg,"LPitch:%d" ,ddsd.lPitch);
  1884.     ShowString(smapx,ssy,ggg,&f16x16w);
  1885.     ssy+=16;
  1886.     if(EgoFlag)ShowString(smapx,ssy,"╨σµΦ∞ ±ΓαδΦΓαφΦ  ε≥ Γ≡απα",&f16x16w);
  1887.     else ShowString(smapx,ssy,"╨σµΦ∞ ßε≡ⁿß√ ± Γ≡απε∞",&f16x16w);
  1888.     ssy+=16;
  1889.     sprintf(ggg,"FPS:%d, Waiting: %d" ,Flips,WaitCycle);
  1890.     counter=0;
  1891.     ShowString(smapx,ssy,ggg,&f16x16w);
  1892.     ssy+=16;
  1893.     sprintf(ggg,"┬±σπε ≥Γα≡■Ω:%d",NMONS);
  1894.     ShowString(smapx,ssy,ggg,&f16x16w);
  1895.     ssy+=20;
  1896.     int sapx=smapx+4;
  1897.     if(!NSL[MyNation])return;
  1898.     OneObject* OBB=Group[Selm[MyNation][0]];
  1899.     if(int(OBB)){
  1900.         sprintf(ggg,"═ε∞σ≡ Φτß≡αφφεΘ ≥Γα≡■ΩΦ :%d,(x=%d,y=%d)",
  1901.             OBB->Index,
  1902.             OBB->x,
  1903.             OBB->y);
  1904.         ShowString(smapx,ssy,ggg,&f16x16w);
  1905.         ssy+=16;
  1906.         sprintf(ggg,"═≤∞σ≡ ∩δσ∞σφΦ:%d",OBB->NMask);
  1907.         ShowString(sapx,ssy,ggg,&f16x16w);
  1908.         ssy+=16;
  1909.         sprintf(ggg,"Vx,Vy=%d,%d",OBB->RealVx,OBB->RealVy);
  1910.         ShowString(sapx,ssy,ggg,&f16x16w);
  1911.         ssy+=16;
  1912.         if(OBB->CrowdRef){
  1913.             ssy+=10;
  1914.             Crowd* CR=OBB->CrowdRef;
  1915.             ShowString(sapx,ssy,CR->Message,&f16x16w);
  1916.             ssy+=16;
  1917.             sprintf(ggg,"└≥αΩεΓα≥ⁿ:");
  1918.             char gxx[10];
  1919.             for(int u=0;u<32;u++){
  1920.                 int pp=CR->ForAtt[u];
  1921.                 if(pp!=0xFFFF){
  1922.                     sprintf(gxx,"%d(%d) ",pp,u);
  1923.                     strcat(ggg,gxx);
  1924.                 };
  1925.             };
  1926.             ShowString(sapx,ssy,ggg,&f16x16w);
  1927.             ssy+=16;
  1928.             sprintf(ggg,"╫Φ±δσφφε±≥ⁿ:%d",CR->NMembers);
  1929.             ShowString(sapx,ssy,ggg,&f16x16w);
  1930.             ssy+=16;
  1931.         };
  1932.         if(OBB->MoveInRect){
  1933.             sprintf(ggg,"╩ΓαΣ≡α≥ φατφα≈σφΦ :(%d,%d)-(%d,%d)",
  1934.                 OBB->destX,
  1935.                 OBB->destY,
  1936.                 OBB->destX1,
  1937.                 OBB->destY1);
  1938.             ShowString(sapx,ssy,ggg,&f16x16w);
  1939.             ssy+=16;
  1940.             sprintf(ggg,"╥ε≈Ωα φατφα≈σφΦ :(%d,%d)",
  1941.                 OBB->lastX,
  1942.                 OBB->lastY);
  1943.             ShowString(sapx,ssy,ggg,&f16x16w);
  1944.             ssy+=20;
  1945.         };
  1946.         if(int(OBB->LocalOrder)){
  1947.             ShowString(sapx-4,ssy,"╪≥ε ∞φσ φεφ≈σ Σσδα≥ⁿ.",&f16x16w);
  1948.             ssy+=16;
  1949.             Order1* LOL=OBB->LocalOrder;
  1950.             do{
  1951.                 switch(LOL->OrderType){
  1952.                 case 2:    sprintf(ggg,"╧εΓσδσφΦσ:(╧εΣⁿ Ωα Γ:x=%d,y=%d)",
  1953.                             LOL->info.MoveToXY.x,
  1954.                             LOL->info.MoveToXY.y);
  1955.                         break;
  1956.                 case 77:sprintf(ggg,"╧εΓσδσφΦσ:(╙ΘΣΦ ± Σε≡επΦ, εΩα φφ√Θ!:dir=%d)%d",
  1957.                             LOL->info.MoveFrom.dir);
  1958.                         break;
  1959.                 case 3:sprintf(ggg,"╧εΓσδσφΦσ:(╠ε≈Φ≥ⁿ ≥Γα≡ⁿ:%d)",
  1960.                             OBB->EnemyID);
  1961.                         break;
  1962.                 default:sprintf(ggg,"╧εΓσδσφΦσ:(─≤≡φΦ÷i  Ωi±ⁿ:%d)",
  1963.                             LOL->OrderType);
  1964.                 };
  1965.                 ShowString(sapx,ssy,ggg,&rlf_s);
  1966.                 ssy+=16;
  1967.                 LOL=LOL->NextOrder;
  1968.                 if(ssy>500)return;
  1969.             }while(int(LOL));
  1970.         };
  1971.         ssy=smapy;
  1972.         sapx=smapx+smaplx*16+100;
  1973.     };
  1974. };
  1975. void miniShowFlyingMonsters();
  1976. void miniShowSuperFog();
  1977. void miniGFieldShow(){
  1978.     int i;
  1979.     int j;
  1980.     int scr;
  1981.     int til;
  1982.     int uuu=(tmt&31);
  1983.     char ggg[600];
  1984.     tmt++;
  1985.     if(FogMode){
  1986.         for(j=0;j<smaply;j++)
  1987.             for(i=0;i<smaplx;i++)if(fmap[j+mapy][i+mapx]>512){
  1988.                 //int til=int(&mtiles[0][0])+(int(tmap[i+mapx-1][j+mapy-1])<<8);
  1989.                 int til=int(RenderMiniSquare(i+mapx,j+mapy));
  1990.                 if(til){
  1991.                     scr=int(ScreenPtr)+(i<<4)+smapx+((j<<4)+smapy)*SCRSizeX;
  1992.                     int SDX=SCRSizeX-16;
  1993.                     __asm{
  1994.                         push    esi
  1995.                         push    edi
  1996.                         mov        eax,16
  1997.                         cld
  1998.                         mov        edi,scr
  1999.                         mov        esi,til
  2000. Lab12:                    mov        ecx,4
  2001.                         rep        movsd
  2002.                         add        edi,SDX
  2003.                         dec        eax
  2004.                         jnz        Lab12
  2005.                         pop        edi
  2006.                         pop        esi
  2007.                     };    
  2008.                 };
  2009.                 //if(LLock[j+mapy][i+mapx])
  2010.                 //    Xbar((i<<4)+smapx+6,(j<<4)+smapy+6,4,4,255);
  2011.             };
  2012.     }else{
  2013.         for(j=0;j<smaply;j++)
  2014.             for(i=0;i<smaplx;i++){
  2015.                 //int til=int(&mtiles[0][0])+(int(tmap[i+mapx-1][j+mapy-1])<<8);
  2016.                 int til=int(RenderMiniSquare(i+mapx,j+mapy));
  2017.                 if(til){
  2018.                     scr=int(ScreenPtr)+(i<<4)+smapx+((j<<4)+smapy)*SCRSizeX;
  2019.                     int SDX=SCRSizeX-16;
  2020.                     __asm{
  2021.                         push    esi
  2022.                         push    edi
  2023.                         mov        eax,16
  2024.                         cld
  2025.                         mov        edi,scr
  2026.                         mov        esi,til
  2027. Lab13:                    mov        ecx,4
  2028.                         rep        movsd
  2029.                         add        edi,SDX
  2030.                         dec        eax
  2031.                         jnz        Lab13
  2032.                         pop        edi
  2033.                         pop        esi
  2034.                     };    
  2035.                 };
  2036.                 //if(LLock[j+mapy][i+mapx])
  2037.                 //    Xbar((i<<4)+smapx+6,(j<<4)+smapy+6,4,4,255);
  2038.             };
  2039.     };
  2040.     SetRLCWindow(smapx,smapy,(smaplx<<4),(smaply<<4),SCRSizeX);
  2041.     //ShowResScreen();
  2042.     for(j=0;j<smaply;j++){
  2043.         for(i=-1;i<=smaplx;i++){
  2044.             int p=Died[j+mapy][i+mapx];
  2045.             if(p!=0xFFFF){
  2046.                 OneObject* GG=Group[p];
  2047.                 Octant* Oc2=GG->CurAnm;
  2048.                 OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  2049.                 byte clr=GG->NNUM;
  2050.                 int spr=Oc1->spr;
  2051.                 if(spr<4096)
  2052.                 if(Group[p]->Invert) 
  2053.                 ShowRLCItem(((i+1)<<4)+smapx-(Oc1->dx>>1),(j<<4)+smapy+(Oc1->dy>>1),
  2054.                     &miniMImage[Oc1->FileID],spr+4096,clr);
  2055.                 else
  2056.                     ShowRLCItem((i<<4)+smapx+(Oc1->dx>>1),(j<<4)+smapy+(Oc1->dy>>1),
  2057.                         &miniMImage[Oc1->FileID],spr,clr);
  2058.             };
  2059.         };
  2060.         for(i=-1;i<=smaplx;i++){
  2061.             int p=Mops[j+mapy][i+mapx];
  2062.             if(p!=0xFFFF){
  2063.                 OneObject* GG=Group[p];
  2064.                 int    ddy=GG->Addy>>1;
  2065.                 if(ddy<0){
  2066.                     byte clr=GG->NNUM;
  2067.                     Octant* Oc2=GG->CurAnm;
  2068.                     int    ddx=GG->Addx>>1;
  2069.                     OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  2070.                     int spr=Oc1->spr;
  2071.                     //-----------
  2072.                     //int hy=GetHig((int(GG->x)<<5)+GG->Addx,(int(GG->y)<<5)+GG->Addy);
  2073.                     //-----------
  2074.                     if(spr<4096)
  2075.                     if(Group[p]->Invert) 
  2076.                         ShowRLCItem(ddx+((i+1)<<4)+smapx-(Oc1->dx>>1),ddy+(j<<4)+smapy+(Oc1->dy>>1),
  2077.                             &miniMImage[Oc1->FileID],spr+4096,clr);
  2078.                     else
  2079.                         ShowRLCItem(ddx+(i<<4)+smapx+(Oc1->dx>>1),ddy+(j<<4)+smapy+(Oc1->dy>>1),
  2080.                             &miniMImage[Oc1->FileID],spr,clr);
  2081.                     ShowMiniHealth(GG);
  2082.                     //ShowProperty(GG);
  2083.                 };
  2084.             };
  2085.         };
  2086.         for(i=-3;i<smaplx;i++){
  2087.             int p=i+mapx>0?Mops[j+mapy][i+mapx]:0xffff;
  2088.             if(p!=0xFFFF){
  2089.                 OneObject* GG=Group[p];
  2090.                 int    ddy=GG->Addy>>1;
  2091.                 if(ddy==0){
  2092.                     byte clr=GG->NNUM;
  2093.                     if(!(GG->capBuilding&&(GG->x!=i+mapx||GG->y!=j+mapy))){
  2094.                         Octant* Oc2=GG->CurAnm;
  2095.                         //-----------
  2096.                         //int hy=GetHig((int(GG->x)<<5)+GG->Addx,(int(GG->y)<<5)+GG->Addy);
  2097.                         //-----------
  2098.                         int    ddx=GG->Addx>>1;
  2099.                         OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  2100.                         int spr=Oc1->spr;
  2101.                         if(spr<4096)
  2102.                         if(Group[p]->Invert) 
  2103.                             ShowRLCItem(ddx+((i+1)<<4)+smapx-(Oc1->dx>>1),ddy+(j<<4)+smapy+(Oc1->dy>>1),
  2104.                                 &miniMImage[Oc1->FileID],spr+4096,clr);
  2105.                         else
  2106.                             ShowRLCItem(ddx+(i<<4)+smapx+(Oc1->dx>>1),ddy+(j<<4)+smapy+(Oc1->dy>>1),
  2107.                                 &miniMImage[Oc1->FileID],spr,clr);
  2108.                         ShowMiniHealth(GG);
  2109.                         //ShowProperty(GG);
  2110.                     };
  2111.                 
  2112.                 };
  2113.             };
  2114.         };
  2115.         for(i=0;i<smaplx;i++){
  2116.             int p=Mops[j+mapy][i+mapx];
  2117.             if(p!=0xFFFF){
  2118.                 OneObject* GG=Group[p];
  2119.                 int    ddy=GG->Addy>>1;
  2120.                 if(ddy>0){
  2121.                     byte clr=GG->NNUM;
  2122.                     Octant* Oc2=GG->CurAnm;
  2123.                     //-----------
  2124.                     //int hy=GetHig((int(GG->x)<<5)+GG->Addx,(int(GG->y)<<5)+GG->Addy);
  2125.                     //-----------
  2126.                     int    ddx=GG->Addx>>1;
  2127.                     OneSlide* Oc1=&(Oc2->Movie[GG->CurrentSprite]);
  2128.                     int spr=Oc1->spr;
  2129.                     if(spr<4096)
  2130.                     if(Group[p]->Invert) 
  2131.                         ShowRLCItem(ddx+((i+1)<<4)+smapx-(Oc1->dx>>1),ddy+(j<<4)+smapy+(Oc1->dy>>1),
  2132.                             &miniMImage[Oc1->FileID],spr+4096,clr);
  2133.                     else
  2134.                         ShowRLCItem(ddx+(i<<4)+smapx+(Oc1->dx>>1),ddy+(j<<4)+smapy+(Oc1->dy>>1),
  2135.                             &miniMImage[Oc1->FileID],spr,clr);
  2136.                     ShowMiniHealth(GG);
  2137.                     //ShowProperty(GG);
  2138.                 };
  2139.             };
  2140.         }
  2141.     };
  2142.     //for(int jj=0;jj<10;jj++)
  2143.     //ShowSuperFluentFog(smapx+32,smapy+32,31,31,31,0);
  2144.     ProcessExpl();
  2145.     miniShowFlyingMonsters();
  2146.     if(FogMode){
  2147.         ProcessFog();
  2148.     };
  2149.     int v1=3;
  2150.     int v2=158;
  2151.     //ShowSuperFluentFog32_160(200,200,v1,v1,v1,v2);
  2152.     //ShowSuperFluentFog32_160(200+32,200,v1,v1,v2,v1);
  2153.     //ShowSuperFluentFog32_160(200,200+32,v1,v2,v1,v1);
  2154.     //ShowSuperFluentFog32_160(200+32,200+32,v2,v1,v1,v1);
  2155.     if(EditMapMode){
  2156.         if(ChoosePosition)
  2157.             sprintf(ggg,"╚π≡εΩ %d : ┬√ßε≡ ±≥α≡≥εΓεΘ ∩ετΦ÷ΦΦ.",MyNation);
  2158.         else sprintf(ggg,"╚π≡εΩ %d.",MyNation+1);
  2159.         ShowString(smapx+32,smapy+64,ggg,&f16x16w);
  2160.     };
  2161.     SetRLCWindow(0,0,COPYSizeX,RSCRSizeY,SCRSizeX);
  2162.     if(BuildMode){
  2163.         if(mouseX>=smapx&&mouseY>=smapy&&mouseX<smapx*(smaplx-blx+1)*32&&mouseY<smapy+(smaply-bly+1)*32){
  2164.             int xxx=mouseX&(65535-15);
  2165.             int yyy=mouseY&(65535-15);
  2166.             xxx=mapx+((xxx-smapx)>>4);    
  2167.             yyy=mapy+((yyy-smapy)>>4);
  2168.             if(!(CheckGold(xxx,yyy,BNat->Mon[BuildingID])&&ManualFogCheck(xxx,yyy,BNat->Mon[BuildingID]->SizeX)&&BNat->CheckBuilding(BuildingID,xxx,yyy)))
  2169.                 RedMiniBar(xxx,yyy,blx,bly);else
  2170.                 WhiteMiniBar(xxx,yyy,blx,bly);
  2171.             xxx=mouseX&(65535-15);
  2172.             yyy=mouseY&(65535-15);
  2173.             ShowRLCItem(xxx+(OSB->dx>>1),yyy+(OSB->dy>>1),
  2174.                 &miniMImage[OSB->FileID],OSB->spr,MyNation);
  2175.             
  2176.         };
  2177.     };
  2178.     if(BuildWall)TMPCluster.ShowCluster();
  2179.     if(FogMode)
  2180.         miniShowSuperFog();
  2181.     ProcessHint();
  2182.     ShowDestn();
  2183.     if(SeqErrorsCount){
  2184.         for(i=0;i<20;i++)
  2185.                 Hline(smapx,i*32+smapy,RSCRSizeX,255);
  2186.     };
  2187.     if(EditMapMode){
  2188.         for(i=0;i<8;i++){
  2189.             RESRC[i][1]=100000;
  2190.             RESRC[i][2]=100000;
  2191.             RESRC[i][3]=100000;
  2192.         };
  2193.     }else ShowWinner();
  2194.     //information
  2195.     if(HelpMode){
  2196.         int scx=smapx+64;
  2197.         int scy=smapy+128;
  2198.         if(EditMapMode){
  2199.             ShowString(scx+100,scy,"╨σαΩ≥ε≡ Ωα≡≥√. (F1 - ≤ß≡α≥ⁿ φαΣ∩Φ±Φ)",&f16x16w);
  2200.             scy+=20;
  2201.             ShowString(scx,scy,"'P' - Γ√ßε≡ εß·σΩ≥α",&f16x16w);
  2202.             scy+=20;
  2203.             ShowString(scx,scy,"F1  - Help",&f16x16w);
  2204.             scy+=20;
  2205.             ShowString(scx,scy,"F2  - ╥≡αΓα",&f16x16w);
  2206.             scy+=20;
  2207.             ShowString(scx,scy,"F3  - ╧≤±≥√φ ",&f16x16w);
  2208.             scy+=20;
  2209.             ShowString(scx,scy,"F4  - ╦σ±",&f16x16w);
  2210.             scy+=20;
  2211.             ShowString(scx,scy,"F5  - ┬εΣα",&f16x16w);
  2212.             scy+=20;
  2213.             ShowString(scx,scy,"F6  - ╩α∞φΦ",&f16x16w);
  2214.             scy+=20;
  2215.             ShowString(scx,scy,"F7  - ╤ετΣα≥ⁿ Γ√∩≤Ωδε±≥ⁿ",&f16x16w);
  2216.             scy+=20;
  2217.             ShowString(scx,scy,"F8  - ╤ετΣα≥ⁿ Γ∩αΣΦφ≤",&f16x16w);
  2218.             scy+=20;
  2219.             //ShowString(scx,scy,"F8  - ╤πδαµΦΓαφΦσ",&f16x16w);
  2220.             //scy+=20;
  2221.             ShowString(scx,scy,"F9  - ≡σµΦ∞ ≤∩≡αΓδσφΦ ",&f16x16w);
  2222.             scy+=20;
  2223.             ShowString(scx,scy,"'1'..'9' - ┬√ßε≡ ≡ατ∞σ≡α ∩σ≡α",&f16x16w);
  2224.             scy+=20;
  2225.             ShowString(scx,scy,"'W' - ╧ε±≥≡εΘΩα ±≥σφ√",&f16x16w);
  2226.             scy+=20;
  2227.             ShowString(scx,scy,"'L' - ┬√ßε≡ ±≥α≡≥εΓεΘ ∩ετΦ÷ΦΦ",&f16x16w);
  2228.             scy+=20;
  2229.             ShowString(scx,scy,"'R' - ═α≈αδⁿφ√σ ≡σ±≤≡±√",&f16x16w);
  2230.             scy+=20;
  2231.             ShowString(scx,scy,"NUM 1..8 - ┬√ßε≡ φα÷ΦΦ",&f16x16w);
  2232.             scy+=20;
  2233.         };
  2234.     };
  2235.     ShowRMap();
  2236.     if(EditMapMode&&NSL[MyNation]){
  2237.         OneObject* OBB=Group[Selm[MyNation][0]];
  2238.         if(int(OBB)){
  2239.             if(EditMapMode){
  2240.                 if(OBB->PathX){
  2241.                     for(int i=OBB->CurIPoint;i<OBB->NIPoints;i++){
  2242.                         int xx=smapx+((int(OBB->PathX[i])-mapx)<<4);
  2243.                         int yy=smapy+((int(OBB->PathY[i])-mapy)<<4);
  2244.                         Xbar(xx+13,yy+13,6,6,255);
  2245.                     };
  2246.                 };
  2247.             };
  2248.         };
  2249.     };
  2250.     if(EditMapMode)return;
  2251.     if(InfoMode)return;
  2252.     int ssy=smapy+3;
  2253.     ssy+=20;
  2254.     sprintf(ggg,"LastKey=%d" ,LastKey);
  2255.     ShowString(smapx,ssy,ggg,&f16x16w);
  2256.     ssy+=16;
  2257.     int uxxx=mapx+((mouseX-smapx)>>5);
  2258.     int uyyy=mapy+((mouseY-smapy)>>5);
  2259.     OutCInf(uxxx,uyyy);
  2260.     sprintf(ggg,"(%d,%d)",uxxx,uyyy);
  2261.     ShowString(smapx,smapy+smaply*32-64-32,ggg,&f16x16w);
  2262.     Nation* NT=&NATIONS[MyNation];
  2263.     sprintf(ggg,"AI=%d" ,NT->AI_Level+1);
  2264.     ShowString(smapx,ssy,ggg,&f16x16w);
  2265.     ssy+=16;
  2266.     sprintf(ggg,"Farms:%d,Gidot:%d" ,NT->NFarms,NT->NGidot);
  2267.     ShowString(smapx,ssy,ggg,&f16x16w);
  2268.     ssy+=16;
  2269.     sprintf(ggg,"%d,%d" ,LASTIND,LASTRAND);
  2270.     ShowString(smapx,ssy,ggg,&f16x16w);
  2271.     ssy+=16;
  2272.     sprintf(ggg,"%d" ,COUNTER);
  2273.     COUNTER=0;
  2274.     ShowString(smapx,ssy,ggg,&f16x16w);
  2275.     ssy+=16;
  2276.     sprintf(ggg,"Time:%d" ,tmtmt);
  2277.     ShowString(smapx,ssy,ggg,&f16x16w);
  2278.     ssy+=16;
  2279.     sprintf(ggg,"Sequene errors:%d (%d)" ,SeqErrorsCount,LastRandDif);
  2280.     ShowString(smapx,ssy,ggg,&f16x16w);
  2281.     ssy+=16;
  2282.     //if(!InfoMode)return;
  2283.     sprintf(ggg,"Strong factor:%d" ,NForces[MyNation].StrongFactor);
  2284.     ShowString(smapx,ssy,ggg,&f16x16w);
  2285.     ssy+=16;
  2286.     sprintf(ggg,"RSCRSizeX:%d" ,RSCRSizeX);
  2287.     ShowString(smapx,ssy,ggg,&f16x16w);
  2288.     ssy+=16;
  2289.     sprintf(ggg,"minix=%d,miniy=%d" ,minix,miniy);
  2290.     ShowString(smapx,ssy,ggg,&f16x16w);
  2291.     ssy+=16;
  2292.     sprintf(ggg,"mx=%d,my=%d,lp=%d" ,mouseX,mouseY,Lpressed);
  2293.     ShowString(smapx,ssy,ggg,&f16x16w);
  2294.     ssy+=16;
  2295.     sprintf(ggg,"LPitch:%d" ,ddsd.lPitch);
  2296.     ShowString(smapx,ssy,ggg,&f16x16w);
  2297.     ssy+=16;
  2298.     if(EgoFlag)ShowString(smapx,ssy,"╨σµΦ∞ ±ΓαδΦΓαφΦ  ε≥ Γ≡απα",&f16x16w);
  2299.     else ShowString(smapx,ssy,"╨σµΦ∞ ßε≡ⁿß√ ± Γ≡απε∞",&f16x16w);
  2300.     ssy+=16;
  2301.     sprintf(ggg,"FPS:%d, Waiting: %d" ,Flips,WaitCycle);
  2302.     counter=0;
  2303.     ShowString(smapx,ssy,ggg,&f16x16w);
  2304.     ssy+=16;
  2305.     sprintf(ggg,"┬±σπε ≥Γα≡■Ω:%d",NMONS);
  2306.     ShowString(smapx,ssy,ggg,&f16x16w);
  2307.     ssy+=20;
  2308.     int sapx=smapx+4;
  2309.     if(!NSL[MyNation])return;
  2310.     OneObject* OBB=Group[Selm[MyNation][0]];
  2311.     if(int(OBB)){
  2312.         sprintf(ggg,"═ε∞σ≡ Φτß≡αφφεΘ ≥Γα≡■ΩΦ :%d,(x=%d,y=%d)",
  2313.             OBB->Index,
  2314.             OBB->x,
  2315.             OBB->y);
  2316.         ShowString(smapx,ssy,ggg,&f16x16w);
  2317.         ssy+=16;
  2318.         sprintf(ggg,"═≤∞σ≡ ∩δσ∞σφΦ:%d",OBB->NMask);
  2319.         ShowString(sapx,ssy,ggg,&f16x16w);
  2320.         ssy+=16;
  2321.         sprintf(ggg,"Vx,Vy=%d,%d",OBB->RealVx,OBB->RealVy);
  2322.         ShowString(sapx,ssy,ggg,&f16x16w);
  2323.         ssy+=16;
  2324.         if(OBB->CrowdRef){
  2325.             ssy+=10;
  2326.             Crowd* CR=OBB->CrowdRef;
  2327.             ShowString(sapx,ssy,CR->Message,&f16x16w);
  2328.             ssy+=16;
  2329.             sprintf(ggg,"└≥αΩεΓα≥ⁿ:");
  2330.             char gxx[10];
  2331.             for(int u=0;u<32;u++){
  2332.                 int pp=CR->ForAtt[u];
  2333.                 if(pp!=0xFFFF){
  2334.                     sprintf(gxx,"%d(%d) ",pp,u);
  2335.                     strcat(ggg,gxx);
  2336.                 };
  2337.             };
  2338.             ShowString(sapx,ssy,ggg,&f16x16w);
  2339.             ssy+=16;
  2340.             sprintf(ggg,"╫Φ±δσφφε±≥ⁿ:%d",CR->NMembers);
  2341.             ShowString(sapx,ssy,ggg,&f16x16w);
  2342.             ssy+=16;
  2343.         };
  2344.         if(OBB->MoveInRect){
  2345.             sprintf(ggg,"╩ΓαΣ≡α≥ φατφα≈σφΦ :(%d,%d)-(%d,%d)",
  2346.                 OBB->destX,
  2347.                 OBB->destY,
  2348.                 OBB->destX1,
  2349.                 OBB->destY1);
  2350.             ShowString(sapx,ssy,ggg,&f16x16w);
  2351.             ssy+=16;
  2352.             sprintf(ggg,"╥ε≈Ωα φατφα≈σφΦ :(%d,%d)",
  2353.                 OBB->lastX,
  2354.                 OBB->lastY);
  2355.             ShowString(sapx,ssy,ggg,&f16x16w);
  2356.             ssy+=20;
  2357.         };
  2358.         if(int(OBB->LocalOrder)){
  2359.             ShowString(sapx-4,ssy,"╪≥ε ∞φσ φεφ≈σ Σσδα≥ⁿ.",&f16x16w);
  2360.             ssy+=16;
  2361.             Order1* LOL=OBB->LocalOrder;
  2362.             do{
  2363.                 switch(LOL->OrderType){
  2364.                 case 2:    sprintf(ggg,"╧εΓσδσφΦσ:(╧εΣⁿ Ωα Γ:x=%d,y=%d)",
  2365.                             LOL->info.MoveToXY.x,
  2366.                             LOL->info.MoveToXY.y);
  2367.                         break;
  2368.                 case 77:sprintf(ggg,"╧εΓσδσφΦσ:(╙ΘΣΦ ± Σε≡επΦ, εΩα φφ√Θ!:dir=%d)%d",
  2369.                             LOL->info.MoveFrom.dir);
  2370.                         break;
  2371.                 case 3:sprintf(ggg,"╧εΓσδσφΦσ:(╠ε≈Φ≥ⁿ ≥Γα≡ⁿ:%d)",
  2372.                             OBB->EnemyID);
  2373.                         break;
  2374.                 default:sprintf(ggg,"╧εΓσδσφΦσ:(─≤≡φΦ÷i  Ωi±ⁿ:%d)",
  2375.                             LOL->OrderType);
  2376.                 };
  2377.                 ShowString(sapx,ssy,ggg,&rlf_s);
  2378.                 ssy+=16;
  2379.                 LOL=LOL->NextOrder;
  2380.                 if(ssy>500)return;
  2381.             }while(int(LOL));
  2382.         };
  2383.         ssy=smapy;
  2384.         sapx=smapx+smaplx*16+100;
  2385.     };
  2386. };
  2387. void ShowNucl();
  2388. void GMiniShow(){
  2389. if(!MiniMade)CreateMiniMap();
  2390.     int ssx;
  2391.     int ssy;
  2392.     if(msx>=128)ssx=msx>>3;else ssx=msx>>2;
  2393.     if(msy>=128)ssy=msy>>1;else ssy=msy;
  2394.     for(int i=0;i<ssy;i++){
  2395.         int scr=int(ScreenPtr)+minix+(i+miniy)*SCRSizeX;
  2396.         int til=int(&minimap)+i*maxmap;
  2397.         //int til=int(OrdUsage)+i*128;
  2398.         __asm{
  2399.             push    esi
  2400.             push    edi
  2401.             mov        ecx,ssx
  2402.             cld
  2403.             mov        esi,til
  2404.             mov        edi,scr
  2405.             rep        movsd
  2406. uiyt:        pop        edi
  2407.             pop        esi
  2408.         }
  2409.     }
  2410.     word mp;
  2411.     OneObject* OO;
  2412.     byte mxx,myy,val;
  2413.     for(int g=0;g<MAXOBJECT;g++){
  2414.         OO=Group[g];
  2415.         if(OO){
  2416.             mxx=(OO->x-1)>>1;
  2417.             myy=(OO->y-1)>>1;
  2418.             val=CLRT[OO->NNUM];
  2419.             int scr=int(ScreenPtr)+minix+mxx+(myy+miniy)*SCRSizeX;
  2420.             __asm{
  2421.                 mov    eax,scr
  2422.                 mov    bl,val
  2423.                 mov    [eax],bl
  2424.             };
  2425.         };
  2426.     };
  2427.     if(EditMapMode){
  2428.         int x=mapPos[(MyNation<<1)]>>1;
  2429.         int y=mapPos[(MyNation<<1)+1]>>1;
  2430.         SetRLCWindow(minix,miniy,msx>>1,msy>>1,SCRSizeX);
  2431.         Hline(minix+x-2,miniy+y,minix+x-2+4,255);
  2432.         Vline(minix+x,miniy+y-2,miniy+y-2+4,255);
  2433.         SetRLCWindow(0,0,COPYSizeX,RSCRSizeY,SCRSizeX);
  2434.     };
  2435.     if(FogMode)AcceptMiniMap();
  2436.     ShowNucl();
  2437.     Xbar(minix+(mapx>>1),miniy+(mapy>>1),smaplx>>1,smaply>>1,14);
  2438.     ShowMiniDestn();
  2439.     int mx2=msx>>1;
  2440.     int my2=msy>>1;
  2441.     Hline(minix-1,miniy-1,minix+mx2,15);
  2442.     Hline(minix-1,miniy+my2,minix+mx2,15);
  2443.     Vline(minix-1,miniy-1,miniy+my2,15);
  2444.     Vline(minix+mx2,miniy,miniy+my2,15);
  2445. };
  2446. //------------------------------------
  2447. #define step 1
  2448. void SetEgoFlag(bool Ego){
  2449.     word MID;
  2450.     OneObject* OB;
  2451.     for(int i=0;i<Nsel;i++){
  2452.         MID=SlMons[i];
  2453.         if(MID!=0xFFFF){
  2454.             OB=Group[MID];
  2455.             if(int(OB))OB->Egoist=Ego;
  2456.         };
  2457.     };
  2458. };
  2459. extern int  ReliefBrush;
  2460. extern int  TerrBrush;
  2461. bool SelSoundDone;
  2462. extern int SelSoundType;
  2463. extern bool SelSoundReady;
  2464. void DoSelSound(int type){
  2465.     if(!SelSoundDone){
  2466.         SelSoundDone=true;
  2467.         SelSoundReady=true;
  2468.         SelSoundType=type;
  2469.     };
  2470. };
  2471. extern bool fixed;
  2472. extern bool realLpressed;
  2473. extern bool realRpressed;
  2474. void MFix(){
  2475.     fixed=true;
  2476.     if(Lpressed)Lpressed=realLpressed;
  2477.     if(Rpressed)Rpressed=realRpressed;
  2478. };
  2479. void HandleMouse(int x,int y)
  2480. {    
  2481.     bool cooren=false;
  2482.     bool mini=false;
  2483.     int xmx,ymy;
  2484.     if(x>=minix&&y>=miniy&&x<minix+(msx>>1)&&y<miniy+(msy>>1)){
  2485.         SetRLCWindow(minix,miniy,msx>>1,msy>>1,SCRSizeX);
  2486.         Hline(x-4,y,x-4+8,255);
  2487.         Vline(x,y-4,y-4+8,255);
  2488.         SetRLCWindow(0,0,COPYSizeX,RSCRSizeY,SCRSizeX);
  2489.         cooren=true;
  2490.         xmx=(x-minix)<<1;
  2491.         ymy=(y-miniy)<<1;
  2492.         if(xmx<1)xmx=1;
  2493.         if(ymy<1)ymy=1;
  2494.         if(xmx>=msx)xmx=msx-1;
  2495.         if(ymy>=msy)ymy=msy-1;
  2496.         xmx=(xmx<<5)+16;
  2497.         ymy=(ymy<<5)+16;
  2498.         mini=true;
  2499.     }else{
  2500.         if(x>smapx&&y>smapy&&x<smapx+(smaplx<<5)&&y<smapy+(smaply<<5)){
  2501.             xmx=(mapx<<5)+((x-smapx)<<(5-Shifter));
  2502.             ymy=(mapy<<5)+((y-smapy)<<(5-Shifter));
  2503.             cooren=true;
  2504.         };
  2505.     };
  2506.     if(GetCoord){
  2507.         if(Lpressed){
  2508.             if(cooren){
  2509.                 if(UNIM)UNIM(0,xmx>>5,ymy>>5);
  2510.             };
  2511.             Lpressed=false;
  2512.             curptr=0;
  2513.             curdx=0;
  2514.             curdy=0;
  2515.             GetCoord=false;
  2516.             DoSelSound(1);
  2517.             MFix();
  2518.             return;
  2519.         }
  2520.         if(Rpressed){
  2521.             curptr=0;
  2522.             curdx=0;
  2523.             curdy=0;
  2524.             GetCoord=false;
  2525.             MFix();
  2526.             return;
  2527.         };
  2528.     };
  2529.     if(SpecCmd==1)
  2530.         CmdCreateGoodSelection(MyNation,0,0,msx<<5,msy<<5);
  2531.     if(SpecCmd==2)CmdCreateGoodSelection(MyNation,mapx<<5,mapy<<5,(mapx+smaplx-1)<<5,(mapy+smaply-1)<<5);
  2532.     //Select all peasants
  2533.     if(SpecCmd==3)CmdCreateGoodKindSelection(MyNation,0,0,msx<<5,msy<<5,0);
  2534.     //On screen
  2535.     if(SpecCmd==4)CmdCreateGoodKindSelection(MyNation,mapx<<5,mapy<<5,(mapx+smaplx-1)<<5,(mapy+smaply-1)<<5,0);
  2536.     //Select all warriors
  2537.     if(SpecCmd==5)CmdCreateGoodKindSelection(MyNation,0,0,msx<<5,msy<<5,2);
  2538.     //On screen
  2539.     if(SpecCmd==6)CmdCreateGoodKindSelection(MyNation,mapx<<5,mapy<<5,(mapx+smaplx-1)<<5,(mapy+smaply-1)<<5,2);
  2540.     //Select all towers
  2541.     if(SpecCmd==7)CmdCreateGoodKindSelection(MyNation,0,0,msx<<5,msy<<5,1);
  2542.     //On screen
  2543.     if(SpecCmd==8)CmdCreateGoodKindSelection(MyNation,mapx<<5,mapy<<5,(mapx+smaplx-1)<<5,(mapy+smaply-1)<<5,1);
  2544.     //Select all buildings
  2545.     if(SpecCmd==9)CmdCreateGoodKindSelection(MyNation,0,0,msx<<5,msy<<5,4);
  2546.     //On screen
  2547.     if(SpecCmd==10)CmdCreateGoodKindSelection(MyNation,mapx<<5,mapy<<5,(mapx+smaplx-1)<<5,(mapy+smaply-1)<<5,4);
  2548.     //Select all dragons
  2549.     if(SpecCmd==13)CmdCreateGoodKindSelection(MyNation,0,0,msx<<5,msy<<5,5);
  2550.     //On screen
  2551.     if(SpecCmd==14)CmdCreateGoodKindSelection(MyNation,mapx<<5,mapy<<5,(mapx+smaplx-1)<<5,(mapy+smaply-1)<<5,5);
  2552.     if(SpecCmd==200)CmdDie(MyNation);
  2553.     if(SpecCmd==201)CmdSitDown(MyNation);
  2554.     if(SpecCmd==11){
  2555.         word NSel=NSL[MyNation];
  2556.         if(NSel){
  2557.             word MID=Selm[MyNation][0];
  2558.             if(MID!=0xFFFF){
  2559.                 OneObject* OB=Group[MID];
  2560.                 if(OB)CmdCreateGoodTypeSelection(MyNation,0,0,msx<<5,msy<<5,OB->NIndex);
  2561.             };
  2562.         };
  2563.     };
  2564.     if(SpecCmd==12){
  2565.         word NSel=NSL[MyNation];
  2566.         if(NSel){
  2567.             word MID=Selm[MyNation][0];
  2568.             if(MID!=0xFFFF){
  2569.                 OneObject* OB=Group[MID];
  2570.                 if(OB)CmdCreateGoodTypeSelection(MyNation,mapx<<5,mapy<<5,(mapx+smaplx-1)<<5,(mapy+smaply-1)<<5,OB->NIndex);
  2571.             };
  2572.         };
  2573.     };
  2574.     SpecCmd=0;
  2575.     byte MyMask=NATIONS[MyNation].NMask;
  2576.     ControlZones();
  2577.     WallHandleMouse(x,y);
  2578.     if(BuildWall)goto Edgetest;
  2579.     int xxx;
  2580.     int yyy;
  2581.     if(cooren){
  2582.         xxx=xmx>>5;
  2583.         yyy=ymy>>5;
  2584.  
  2585.         if(Lpressed&&!mini){
  2586.             if(ChoosePosition){
  2587.                 mapPos[(MyNation<<1)]=xxx;
  2588.                 mapPos[(MyNation<<1)+1]=yyy;
  2589.                 ChoosePosition=false;
  2590.             };
  2591.             if(HeightEditMode){
  2592.                 CreateBlob(xxx-1,yyy-1,4*BlobMode,ReliefBrush);
  2593.                 goto Edgetest;
  2594.             };
  2595.             if(MEditMode){
  2596.                 PutPoint(xxx-1,yyy-1,TerrBrush,EditMedia);
  2597.                 goto Edgetest;
  2598.             };
  2599.             if(Creator<200){
  2600.                 //for(int i=0;i<2;i++)for(int j=0;j<2;j++)
  2601.                 CmdCreateTerrain(MyNation,xxx,yyy,Creator);
  2602.                 MFix();
  2603.                 return;
  2604.             };
  2605.             if(Creator==254){
  2606.                 OILMAP[yyy>>1][xxx>>1]=60000;
  2607.             };
  2608.             if(BuildMode){
  2609.                 if(CheckGold(xxx,yyy,BNat->Mon[BuildingID])&&ManualFogCheck(xxx,yyy,NATIONS[MyNation].Mon[BuildingID]->SizeX))
  2610.                     CmdCreateBuilding(MyNation,xxx,yyy,BuildingID);
  2611.                 if(!(GetKeyState(VK_SHIFT)&0x8000))BuildMode=false;
  2612.                 Lpressed=false;
  2613.                 MFix();
  2614.                 return;
  2615.             };
  2616.         };
  2617.     };
  2618.     if(cooren){
  2619.         int gx=xmx;
  2620.         int gy=ymy;
  2621.         int gx1=StartX;
  2622.         int gy1=StartY;
  2623.         if(gx>gx1){int z=gx;gx=gx1;gx1=z;};
  2624.         if(gy>gy1){int z=gy;gy=gy1;gy1=z;};
  2625.         int xxx=xmx>>5;
  2626.         int yyy=ymy>>5;
  2627.         int xxx1=StartX>>5;
  2628.         int yyy1=StartY>>5;
  2629.         if(xxx1<xxx){int z=xxx;xxx=xxx1;xxx1=z;};
  2630.         if(yyy1<yyy){int z=yyy;yyy=yyy1;yyy1=z;};
  2631.         if(Lpressed&&!mini){
  2632.             if(!SelSoundDone){
  2633.                 SelSoundDone=true;
  2634.                 SelSoundReady=true;
  2635.                 SelSoundType=0;
  2636.             };
  2637.             SetRLCWindow(smapx,smapy,smaplx<<Shifter,smaply<<Shifter,SCRSizeX);
  2638.             Xbar(smapx+((StartX-(mapx<<5))>>(5-Shifter)),smapy+((StartY-(mapy<<5))>>(5-Shifter)),
  2639.                 x-(smapx+((StartX-(mapx<<5))>>(5-Shifter))),
  2640.                 y-(smapy+((StartY-(mapy<<5))>>(5-Shifter))),254);
  2641.             int nn=0;
  2642.             CmdCreateGoodSelection(MyNation,gx,gy,gx1,gy1);
  2643.         } else{
  2644.             if(!mini){
  2645.                 StartX=xmx;
  2646.                 StartY=ymy;
  2647.                 SelSoundReady=false;
  2648.                 SelSoundDone=false;
  2649.             };
  2650.         };
  2651.         if(Rpressed&&NSL[MyNation]>0&&!mini){
  2652.             DoSelSound(1);
  2653.             Rpressed=false;
  2654.             if(GetKeyState(VK_CONTROL)&0x8000){
  2655.                 CmdSetDst(MyNation,xxx,yyy);
  2656.                 return;
  2657.             };
  2658.             byte rk=GetResourceKind(xxx,yyy);
  2659.             if(rk!=0){
  2660.                 CmdTakeRes(MyNation,xxx,yyy,rk);
  2661.                 CmdSendToXY(MyNation,xxx,yyy);
  2662.                 goto Edgetest;
  2663.             };
  2664.             word LNK=Links[yyy][xxx];
  2665.             if(LNK!=0xFFFF){
  2666.                 WallCluster* WC=&GWALLS.GWC[LNK];
  2667.                 if(WC->OwnerID==MyNation)
  2668.                     CmdRepairWall(MyNation,LNK);
  2669.                 else CmdDamageWall(MyNation,LNK);
  2670.             }else{
  2671.                 word Att=GetEnemy(gx,gy,MyNation);//Mops[yyy][xxx];
  2672.                 word Fri=GetFriend(gx,gy,MyNation);
  2673.                 if(Fri!=0xFFFF){
  2674.                     OneObject* FOBJ=Group[Fri];
  2675.                     if(FOBJ->Transport){
  2676.                         CmdSendToTransport(MyNation,Fri);
  2677.                         return;
  2678.                     };
  2679.                     if(FOBJ->capTeleport&&FOBJ->Ready){
  2680.                         CmdSendToPoint(MyNation,FOBJ->x+1,FOBJ->y+2);
  2681.                         return;
  2682.                     };
  2683.                     if((FOBJ->NMask&MyMask)&&FOBJ->Ref.General->OnOil&&FOBJ->Stage==FOBJ->NStages)
  2684.                         CmdGetOil(MyNation,Fri);
  2685.                     else if(FOBJ->capBuilding&&FOBJ->Life<FOBJ->MaxLife)
  2686.                         CmdBuildObj(MyNation,Fri);
  2687.                     else CmdSendToXY(MyNation,xxx,yyy);
  2688.                 };
  2689.                 if(Att!=0xFFFF){
  2690.                     OneObject* AOBJ=Group[Att];
  2691.                     if(int(AOBJ)){
  2692.                         if(AOBJ->capTeleport&&AOBJ->Ready){
  2693.                             CmdSendToPoint(MyNation,AOBJ->x+1,AOBJ->y+2);
  2694.                             return;
  2695.                         };
  2696.                         if(!(AOBJ->NMask&MyMask))
  2697.                             CmdAttackObj(MyNation,Att);
  2698.                         else CmdSendToXY(MyNation,xxx,yyy);
  2699.                     }else CmdSendToXY(MyNation,xxx,yyy);
  2700.                 }else CmdSendToXY(MyNation,xxx,yyy);
  2701.             };
  2702.         }else{
  2703.             if(Rpressed&&NSL[MyNation]>0)CmdSendToXY(MyNation,xmx>>5,ymy>>5);
  2704.         };
  2705.     };
  2706. Edgetest:
  2707.     if ((x<6)&&(mapx-step>0)) mapx-=step;
  2708.     if ((y<6)&&(mapy-step>0)) mapy-=step;
  2709.     if ((x>RealLx-29)&&(mapx+smaplx+step<msx)) mapx+=step;
  2710.     if ((y>RealLy-6)&&(mapy+smaply+step<msy)) 
  2711.         mapy+=step;
  2712.     if((Lpressed)&&(mouseX>minix)&&(mouseY>miniy)&&
  2713.         (mouseX<minix+(msx>>1))&&(mouseY<miniy+(msy>>1))){
  2714.         mapx=(x-minix-(smaplx>>2))<<1;
  2715.         mapy=(y-miniy-(smaply>>2))<<1;
  2716.         if(mapx<=0)mapx=1;
  2717.         if(mapy<=0)mapy=1;
  2718.         if(mapx+smaplx>msx+1)mapx=msx-smaplx+1;
  2719.         if(mapy+smaply>msy+1)mapy=msy-smaply+1;
  2720.     }
  2721.     MFix();
  2722. };
  2723. void doooo(){
  2724.     Group[0]->Selected=true;
  2725.     SlMons[0]=0;
  2726.     Nsel=1;
  2727.     mapx=20;
  2728.     mapy=20;
  2729.     Group[0]->SendTo(32,32,0);
  2730. };
  2731. void ReRenderMap();
  2732. void SetMiniMode(){
  2733.     if(MiniMode)return;
  2734.     ReRenderMap();
  2735.     mapx=mapx-(smaplx>>1);
  2736.     mapy=mapy-(smaply>>1);
  2737.     if(mapx<1)mapx=1;
  2738.     if(mapy<1)mapy=1;
  2739.     smaplx=smaplx<<1;
  2740.     smaply=smaply<<1;
  2741.     MiniMode=true;
  2742.     Shifter=4;
  2743.     Multip=1;
  2744.     if(mapx+smaplx>msx)mapx=msx-smaplx;
  2745.     if(mapy+smaply>msy)mapy=msy-smaply;
  2746. };
  2747. void ClearMiniMode(){
  2748.     MiniMode=false;
  2749.     ReRenderMap();
  2750.     Shifter=5;
  2751.     Multip=0;
  2752.     mapx+=(smaplx>>2);
  2753.     mapy+=(smaply>>2);
  2754.     smaplx=(RSCRSizeX-160)>>5;
  2755.     smaply=RSCRSizeY>>5;
  2756. };
  2757.  
  2758.