home *** CD-ROM | disk | FTP | other *** search
/ WarCraft 2000 - Nuclear Epidemic / W2000.nrg / SOURCE.War2000 / MapEdit.cpp < prev    next >
C/C++ Source or Header  |  1998-08-20  |  8KB  |  363 lines
  1. //---------------Map editor source------------------
  2. #include "ddini.h"
  3. #include "ResFile.h"
  4. #include "FastDraw.h"
  5. #include "mgraph.h"
  6. #include "mouse.h"
  7. #include "menu.h"
  8. #include "MapDiscr.h"
  9. #include "multipl.h"
  10. #include "fog.h"
  11. #include "walls.h"
  12. #include "Nature.h"
  13. #include <time.h>
  14. #include "Nucl.h"
  15. #include "TopZones.h"
  16. #include "Megapolis.h"
  17. #include "dialogs.h"
  18. #include <assert.h>
  19. #include "3DSurf.h"
  20. #define MediaMax 8
  21. #define CompoMax 8
  22. #define RepTileMax 32
  23. bool ChkWTile(int til);
  24. extern byte minimap[maxmap][maxmap];
  25. extern byte tiles[32][8192];
  26. extern byte Locking[1024];
  27. extern int sfVersion;
  28. void NLine(FILE* f);
  29. byte CMap[256][256];
  30. int NMedia;
  31. byte MComp[MediaMax][8];
  32. int NComp;
  33. byte ComSet[CompoMax][2];
  34. word* CTiles[CompoMax*32];
  35. byte MMedia[MediaMax][MediaMax];
  36. byte DefMedia[MediaMax];
  37. void CreateUnit(Nation* NT,byte x,byte y,word ID);
  38. void LoadMediaFile(){
  39.     int x1,x2;
  40.     FILE* f=fopen("tcomp.txt","rt");
  41.     fscanf(f,"%d",&NMedia);
  42.     NLine(f);
  43.     for(int i=0;i<NMedia;i++){
  44.         fscanf(f,"%d",&x1);
  45.         DefMedia[i]=byte(x1);
  46.     };
  47.     NLine(f);
  48.     fscanf(f,"%d",&NComp);
  49.     NLine(f);
  50.     for(i=0;i<NComp;i++){
  51.         fscanf(f,"%d%d",&x1,&x2);
  52.         NLine(f);
  53.         ComSet[i][0]=byte(x1);
  54.         ComSet[i][1]=byte(x2);
  55.         for(int j=0;j<16;j++){
  56.             fscanf(f,"%d",&x1);
  57.             int gg=(i<<4)+j;
  58.             CTiles[gg]=new word[x1+1];
  59.             CTiles[gg][0]=x1;
  60.             for(int k=0;k<x1;k++){
  61.                 fscanf(f,"%d",&x2);
  62.                 CTiles[gg][k+1]=x2;
  63.             };
  64.         };
  65.         NLine(f);
  66.     };
  67.     fclose(f);
  68.     //creation media composition sets (MComp)
  69.     for(i=0;i<NMedia;i++){
  70.         int MC=0;
  71.         for(int j=0;j<NComp;j++){
  72.             if(ComSet[j][0]==i){
  73.                 MC++;
  74.                 MComp[i][MC]=ComSet[j][1];
  75.             };
  76.             if(ComSet[j][1]==i){
  77.                 MC++;
  78.                 MComp[i][MC]=ComSet[j][0];
  79.             };
  80.         };
  81.         MComp[i][0]=MC;
  82.     };
  83.     //Middle media creation
  84.     //MMedia[Media1][Media2]==0xFF-full compartible 
  85.     //MMedia[Media1][Media2]==0xFE-incompartible
  86.     //                        < 0xFE -middle media
  87.     for(i=0;i<MediaMax;i++){
  88.         MMedia[i][i]=0xFF;
  89.         for(int j=0;j<i;j++){
  90.             //1. Full compartability checking
  91.             bool fn=true;
  92.             int nmc=MComp[i][0];
  93.             for(int p=1;p<=nmc;p++)if(MComp[i][p]==j){
  94.                 MMedia[i][j]=0xFF;
  95.                 MMedia[j][i]=0xFF;
  96.                 fn=false;
  97.             };
  98.             if(fn){
  99.                 byte nmc2=MComp[j][0];
  100.                 byte mm1;
  101.                 //2. middle compartability
  102.                 for(p=1;p<=nmc;p++){
  103.                     mm1=MComp[i][p];
  104.                     for(int t=1;t<=nmc2;t++){
  105.                         if(MComp[j][t]==mm1){
  106.                             fn=false;
  107.                             goto www;
  108.                         };
  109.                     };
  110.                 };
  111. www:            if(fn){
  112.                     MMedia[i][j]=0xFE;
  113.                     MMedia[j][i]=0xFE;
  114.                 }else{
  115.                     MMedia[i][j]=mm1;
  116.                     MMedia[j][i]=mm1;
  117.                 };
  118.             };
  119.         };
  120.     };
  121. };
  122. void CreateCMap(){
  123.     int NCM=NComp<<4;
  124.     int yy=0;
  125.     for(int x=1;x<=msx;x++)
  126.         for(int y=1;y<=msy;y++){
  127.             byte mt=tmap[x-1][y-1];
  128.             for(int f=0;f<NCM;f++){
  129.                 yy=CTiles[f][0];
  130.                 for(int g=1;g<=yy;g++){
  131.                     if(CTiles[f][g]==mt)goto uuu;
  132.                 };
  133.             };
  134. uuu:        if(f<NCM){
  135.                 int md=f>>4;
  136.                 byte c1=ComSet[md][0];
  137.                 byte c2=ComSet[md][1];
  138.                 if(f&1)CMap[y-1][x-1]=c2;else CMap[y-1][x-1]=c1;
  139.                 if(f&2)CMap[y-1][x]=c2;else CMap[y-1][x]=c1;
  140.                 if(f&4)CMap[y][x-1]=c2;else CMap[y][x-1]=c1;
  141.                 if(f&8)CMap[y][x]=c2;else CMap[y][x]=c1;
  142.             }else{
  143.                 CMap[y-1][x-1]=0;
  144.                 CMap[y][x-1]=0;
  145.                 CMap[y-1][x]=0;
  146.                 CMap[y][x]=0;
  147.             };
  148.         };
  149. };
  150. bool SetBestMedia(int x,int y,int dx,int dy){
  151.     if(x<0||y<0||x>=msx||y>=msy)return false;
  152.     byte fm=CMap[y+dy][x+dx];//fundamental
  153.     byte dm=DefMedia[fm];//default
  154.     byte goodm=0xFF;//final compartible media
  155.     byte cm,mm,pm=fm;//cm-current media, 
  156.                         //mm-media compartability,  
  157.                         //pm-previous media
  158.     bool Change=false;
  159.     int px,py;
  160.     //1. Checking of the cell validity
  161.     bool CValid=true;
  162.     for(px=0;px<2;px++)
  163.         for(py=0;py<2;py++)if(px||py){
  164.             cm=CMap[y+((dy+py)&1)][x+((dx+px)&1)];
  165.             if(cm!=fm){
  166.                 if(fm!=pm&&pm!=cm){
  167.                     CValid=false;
  168.                     //goto zzz1;
  169.                 };
  170.                 pm=cm;
  171.             };
  172.             mm=MMedia[fm][cm];
  173.             if(mm!=0xFF)CValid=false;
  174.         };
  175. //zzz:
  176.     if(!CValid){
  177. //zzz1:
  178.         byte Good=0;
  179.         //cell is invalid - need changes
  180.         for(px=0;px<2;px++)
  181.             for(py=0;py<2;py++)if(px||py){
  182.                 cm=CMap[y+((dy+py)&1)][x+((dx+px)&1)];
  183.                 mm=MMedia[fm][cm];
  184.                 if(mm!=0xFF){
  185.                     //incompartible media
  186.                     if(mm==0xFE&&Good<1){
  187.                         Good=1;
  188.                         goodm=dm;
  189.                     }else{
  190.                         if(mm==dm&&Good<4){
  191.                             Good=3;
  192.                             goodm=mm;
  193.                         }else{
  194.                             if(Good<3){
  195.                                 Good=2;
  196.                                 goodm=dm;
  197.                             };
  198.                         };
  199.                     };
  200.                 }else{
  201.                     if(cm==dm){
  202.                         Good=5;
  203.                         goodm=cm;
  204.                     }else{
  205.                         if(Good<5){
  206.                             Good=4;
  207.                             goodm=cm;
  208.                         };
  209.                     };
  210.                 };
  211.             };
  212.         if(goodm==0xFF)goodm=dm;
  213.         assert(goodm!=254);
  214.         for(px=0;px<2;px++)
  215.             for(py=0;py<2;py++)if(px||py){
  216.                 cm=CMap[y+((dy+py)&1)][x+((dx+px)&1)];
  217.                 if(cm!=fm){
  218.                     CMap[y+((dy+py)&1)][x+((dx+px)&1)]=goodm;
  219.                     Change=true;
  220.                 };
  221.         };
  222.     }; 
  223.     return Change;
  224. };
  225. void DefResource(int i,int j);
  226. void SetRAPoint(byte i,byte j);
  227. void SetTiles(int x,int y,int DX){
  228.     int xx=x+DX-1;
  229.     int yy=y+DX-1;
  230.     word til;
  231.     for(int gx=x-1;gx<=xx;gx++)
  232.         for(int gy=y-1;gy<=yy;gy++){
  233.             if(gx>=0&&gy>=0&&gx<msx&&gy<=msy){
  234.                 byte m1=CMap[gy][gx];
  235.                 byte m2=CMap[gy][gx+1];    
  236.                 byte m4=CMap[gy+1][gx];
  237.                 byte m8=CMap[gy+1][gx+1];
  238.                 byte mx=DefMedia[m1];
  239.                 byte mss=1;
  240.                 if(m2!=m1)mx=m2;
  241.                 else mss|=2;
  242.                 if(m4!=m1)mx=m4;
  243.                 else mss|=4;
  244.                 if(m8!=m1)mx=m8;
  245.                 else mss|=8;
  246.                 int fx;
  247.                 for(int p=0;p<NComp;p++){
  248.                     if(ComSet[p][0]==mx&&ComSet[p][1]==m1){
  249.                         fx=(p<<4)+mss;
  250.                         til=CTiles[fx][1+(int(rando()*int(CTiles[fx][0]))>>15)];
  251.                         goto ppp;
  252.                     };
  253.                     if(ComSet[p][1]==mx&&ComSet[p][0]==m1){
  254.                         fx=(p<<4)+(byte(~mss)&15);
  255.                         til=CTiles[fx][1+(int(rando()*int(CTiles[fx][0]))>>15)];
  256.                         goto ppp;
  257.                     };
  258.                 };
  259.  
  260. ppp:            if(!ChkWTile(til))GWALLS.DamageCell(gx+1,gy+1,0,30000);
  261.                 tmap[gx][gy]=til;
  262.                 DefResource(gx+1,gy+1);
  263.                 SetRAPoint(gx+1,gy+1);
  264.                 char *wwww=(char*)(&tiles);
  265.                 minimap[gy>>1][gx>>1]=wwww[33+/*33*16+1+*/(int(tmap[gx][gy])<<10)];
  266.                 word MP=Mops[gy+1][gx+1];
  267.                 int xx;
  268.                 int yy;
  269.                 word UT;
  270.                 byte NI;
  271.                 if(MP!=0xFFFF){
  272.                     OneObject* OB=Group[MP];
  273.                     xx=OB->x;
  274.                     yy=OB->y;
  275.                     UT=OB->NIndex;
  276.                     NI=OB->NNUM;
  277.                     OB->Eliminate();
  278.                 };
  279.                 byte LOC=Locking[til];
  280.                 byte LL=LLock[gy+1][gx+1];
  281.                 if(LOC&1){
  282.                     if(!LL){
  283.                         LLock[gy+1][gx+1]=1;
  284.                         IncLock(gx+1,gy+1);
  285.                     };
  286.                     TrMap[gy+1][gx+1]=1;
  287.                 }else{
  288.                     if(LL)DecLock(gx+1,gy+1);
  289.                     LLock[gy+1][gx+1]=0;
  290.                     TrMap[gy+1][gx+1]=0;
  291.                     PutZCell(gx+1,gy+1);
  292.                 };
  293.                 if(LOC&2){
  294.                     WLock[gy+1][gx+1]=1;
  295.                     WMap[gy+1][gx+1]=1;
  296.                 }else{
  297.                     WLock[gy+1][gx+1]=0;
  298.                     WMap[gy+1][gx+1]=0;
  299.                     //PutZCell(gx+1,gy+1);
  300.                 };
  301.                 if(MP!=0xFFFF){
  302.                     CreateUnit(&NATIONS[NI],xx,yy,UT);
  303.                 };
  304.                 ClearRender(gx+1,gy+1);
  305.             };
  306.         };
  307. };
  308. void CreateMiniMap();
  309. void PutPoint(int x,int y,int DX,byte Type){
  310.     for(int x1=x;x1<x+DX;x1++)
  311.         for(int y1=y;y1<y+DX;y1++){
  312.             if(y1>=0&&x1>=0&&x1<=msx&&y1<=msy){
  313.                 CMap[y1][x1]=Type;
  314.             };
  315.         };
  316.     int xx1=x-1;
  317.     int yy1=y-1;
  318.     int DX1=DX;
  319.     //Modifying nearby nature
  320.     for(int dd=DX-1;dd<DX+4;dd++){
  321.         bool Change=false;
  322.         if(SetBestMedia(xx1,yy1,1,1))Change=true;
  323.         if(SetBestMedia(xx1+DX1,yy1,0,1))Change=true;
  324.         if(SetBestMedia(xx1,yy1+DX1,1,0))Change=true;
  325.         if(SetBestMedia(xx1+DX1,yy1+DX1,0,0))Change=true;
  326.         for(int g=1;g<DX1;g++){
  327.             if(SetBestMedia(xx1+g,yy1,0,1))Change=true;
  328.             if(SetBestMedia(xx1,yy1+g,1,0))Change=true;
  329.             if(SetBestMedia(xx1+g,yy1+DX1,0,0))Change=true;
  330.             if(SetBestMedia(xx1+DX1,yy1+g,0,0))Change=true;
  331.         };
  332.         xx1--;
  333.         yy1--;
  334.         DX1+=2;
  335.         if(!Change)goto qqq;
  336.     };
  337.     
  338. qqq:SetTiles(xx1+2,yy1+2,DX1-2);
  339.     //CreateMiniMap();
  340.     //SetTiles(x-4,y-4,DX+6);
  341. };
  342. void ChkWCell(int x,int y){
  343.     if(x<1||y<1||x>msx||y>msy)return;
  344.     if(CMap[y-1][x-1]!=3||CMap[y-1][x]!=3||CMap[y][x-1]!=3||CMap[y][x]!=3){
  345.         if(CMap[y-1][x-1]==3)PutPoint(x-1,y-1,1,1);
  346.         if(CMap[y][x-1]==3)PutPoint(x-1,y,1,1);
  347.         if(CMap[y-1][x]==3)PutPoint(x,y-1,1,1);
  348.         if(CMap[y][x]==3)PutPoint(x,y,1,1);
  349.     };
  350. };
  351. void WaterCorrection(){
  352.     int mx2=msx>>1;
  353.     int my2=msy>>1;
  354.     for(int dx=0;dx<mx2;dx++)
  355.         for(int dy=0;dy<my2;dy++){
  356.             if(!WMap[dy<<1][dx<<1]){
  357.                 ChkWCell((dx<<1)+2,(dy<<1));
  358.                 ChkWCell((dx<<1)-2,(dy<<1));
  359.                 ChkWCell((dx<<1),(dy<<1)+2);
  360.                 ChkWCell((dx<<1),(dy<<1)-2);
  361.             };
  362.         };
  363. };