Subversion Repositories NedoOS

Rev

Rev 835 | Blame | Compare with Previous | Last modification | View Log | Download

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <memory.h>
  5. #include <string.h>
  6. #include <sstream>
  7. #include <iostream>
  8. #include "ArgsParser.h"
  9.  
  10.  
  11.  
  12. struct {
  13.         unsigned char* data;
  14.         int offset;
  15.         int bpp;
  16.         int wdt,hgt;
  17.         bool flip;
  18. } BMP;
  19.  
  20. unsigned char mem[65536];
  21.  
  22. FILE *fileBatMLZ;
  23. FILE *fileBatSCL;
  24.  
  25. unsigned char *tileData;
  26.  
  27. int fileCnt;
  28.  
  29. struct {
  30.         int tile;
  31.         int wdt,hgt;
  32. } IMGLIST[256];
  33.  
  34. ArgsParser args;
  35. //#define STARTUP_ADR   0xe000
  36. //#define STACK_SIZE    0x0400
  37.  
  38. //#define MUS_COUNT     0x49fe
  39. //#define SMP_COUNT     0x49ff
  40. //#define MUSLIST_ADR   0x4a00  //3*256
  41. //#define SMPLIST_ADR   0x4d00  //4*256
  42. //#define SFX_ADR               0x5100
  43.  
  44. //#define PAL_ADR               0x0000
  45. //#define IMGLIST_ADR   0x1000
  46.  
  47. //#define TSPR_ADR      0xfa00
  48.  
  49. //ЇшъёшЁютрээ√х эюьхЁр ёЄЁрэшЎ
  50.  
  51. //#define SPRBUF_PAGE   8       //4 ёЄЁрэшЎ√
  52. //#define SPRTBL_PAGE   6       //ярЁрьхЄЁ√ ёяЁрщЄют
  53.  
  54. //#define CC_PAGE0      12      //ъюф
  55. //#define CC_PAGE1      13
  56. //#define CC_PAGE2      14
  57. //#define CC_PAGE3      15
  58.  
  59. //#define SND_PAGE      0       //ъюф чтєър ш ¤ЇЇхъЄ√
  60. //#define PAL_PAGE      4       //ярышЄЁ√
  61.  
  62. //#define GFX_PAGE      16      //уЁрЇшър эрўшэрхЄё  ё ЇшъёшЁютрээющ ёЄЁрэшЎ√
  63. int globalPageNum;
  64. #define PACK_PIXELS(col1,col2) (((col1)&7)|(((col1)&8)<<3)|(((col2)&7)<<3)|(((col2)&8)<<4))
  65.  
  66. int stringToInt(char* str) {
  67.         if(strchr(str,'x')!=NULL) {
  68.                 unsigned int x;  
  69.                 std::stringstream ss;
  70.                 ss << std::hex << str;
  71.                 ss >> x;
  72.                 return x;
  73.         }
  74.         return atoi(str);
  75. }
  76.  
  77.  
  78. void clear_mem(void)
  79. {
  80.         memset(mem,0,65536);
  81. }
  82.  
  83.  
  84.  
  85. int get_hex(char n)
  86. {
  87.         if(n>='0'&&n<='9') return n-'0';
  88.         if(n>='a'&&n<='f') return n-'a'+10;
  89.         if(n>='A'&&n<='F') return n-'A'+10;
  90.  
  91.         return -1;
  92. }
  93.  
  94.  
  95.  
  96. int get_hex_byte(char *str)
  97. {
  98.         return (get_hex(str[0])<<4)+get_hex(str[1]);
  99. }
  100.  
  101. //ўЄхэшх Intel HEX Їрщыр т ярь Є№, схч тё ъшї яЁютхЁюъ
  102.  
  103. int load_ihx(const char* name)
  104. {
  105.         FILE *file;
  106.         char line[1024];
  107.         int i,off,ptr,len,size;
  108.  
  109.         file=fopen(name,"rt");
  110.  
  111.         if(!file) return 0;
  112.  
  113.         size=0;
  114.  
  115.         while(fgets(line,sizeof(line),file)!=NULL)
  116.         {
  117.                 len=get_hex_byte(&line[1]);
  118.                 ptr=(get_hex_byte(&line[3])<<8)+get_hex_byte(&line[5]);
  119.                 off=9;
  120.  
  121.                 for(i=0;i<len;i++)
  122.                 {
  123.                         mem[ptr++]=get_hex_byte(&line[off]);
  124.                         off+=2;
  125.                 }
  126.                
  127.                 if(ptr>size) size=ptr;
  128.         }
  129.  
  130.         fclose(file);
  131.  
  132.         return size;
  133. }
  134.  
  135.  
  136.  
  137. bool load_bin(int adr,const char* name)
  138. {
  139.         FILE *file;
  140.         int size;
  141.  
  142.         file=fopen(name,"rb");
  143.  
  144.         if(!file) return false;
  145.  
  146.         fseek(file,0,SEEK_END);
  147.         size=ftell(file);
  148.         fseek(file,0,SEEK_SET);
  149.  
  150.         if(adr+size>0x10000)
  151.         {
  152.                 fclose(file);
  153.                 return false;
  154.         }
  155.  
  156.         fread(mem+adr,size,1,file);
  157.         fclose(file);
  158.  
  159.         return true;
  160. }
  161. int load_bin2(int adr,const char* name)
  162. {
  163.         FILE *file;
  164.         int size;
  165.  
  166.         file=fopen(name,"rb");
  167.  
  168.         if(!file) return false;
  169.  
  170.         fseek(file,0,SEEK_END);
  171.         size=ftell(file);
  172.         fseek(file,0,SEEK_SET);
  173.  
  174.         if(adr+size>0x10000)
  175.         {
  176.                 fclose(file);
  177.                 return 0;
  178.         }
  179.  
  180.         fread(mem+adr,size,1,file);
  181.         fclose(file);
  182.  
  183.         return size;
  184. }
  185.  
  186.  
  187. //яЁютхЁър ёЄЁрэшЎ√ эр эрышўшх эхэєыхт√ї фрээ√ї
  188.  
  189. bool page_is_empty(int page)
  190. {
  191.         int i;
  192.  
  193.         page<<=14;
  194.  
  195.         for(i=0;i<16384;i++)
  196.         {
  197.                 if(mem[i+page]) return false;
  198.         }
  199.  
  200.         return true;
  201. }
  202.  
  203.  
  204.  
  205. bool page_save(int slot,int page, char* pageName, int filenum, FILE * fileOutAsm)
  206. {
  207.         char name[1024];
  208.         FILE *file;
  209.         if(stringToInt(args.getArg(ALT_PAGE_NUMERING))!=0) page=globalPageNum;
  210.         sprintf(name,"%s%d",pageName,filenum);
  211.         fprintf(fileOutAsm,"%s = %d\n",name,page);
  212.         //printf("%s = %d\n",name,page);
  213.  
  214.         if (stringToInt(args.getArg(ALT_PAGE_NUMERING))==0){
  215.                 fprintf(fileBatMLZ,"megalz page_%i.bin >nul\n",page);
  216.                 fprintf(fileBatMLZ,"call _getsize.bat page_%i.bin.mlz %i\n",page,page);
  217.                 fprintf(fileBatSCL,"trdtool + disk.scl page_%i.bin.mlz\n",page);
  218.                 sprintf(name,"_temp_/page_%i.bin",page);
  219.         } else {
  220.                 fprintf(fileBatMLZ,"megalz page_%03i.bin >nul\n",page);
  221.                 fprintf(fileBatMLZ,"call _getsize.bat page_%03i.bin.mlz %i\n",page,page);
  222.                 fprintf(fileBatSCL,"trdtool + disk.scl page_%03i.bin.mlz\n",page);
  223.                 sprintf(name,"_temp_/page_%03i.bin",page);
  224.         }
  225.  
  226.         file=fopen(name,"wb");
  227.  
  228.         if(!file) return false;
  229.  
  230.         fwrite(&mem[slot<<14],16384,1,file);
  231.         fclose(file);
  232.  
  233.         fileCnt++;
  234.         globalPageNum++;
  235.         return true;
  236. }
  237.  
  238. bool store_bin(int size, int number)
  239. {
  240.         char name[1024];
  241.         sprintf(name,"_temp_/code%d.bin",number);
  242.         FILE *file;
  243.         file=fopen(name,"wb");
  244.  
  245.         if(!file) return false;
  246.  
  247.         fwrite(&mem,size,1,file);
  248.         fclose(file);
  249.  
  250.         return true;
  251. }
  252.  
  253. void error(void)
  254. {
  255.         fclose(fileBatMLZ);
  256.         fclose(fileBatSCL);
  257.  
  258.         if(tileData) free(tileData);
  259. }
  260.  
  261.  
  262.  
  263. bool load_palette(const char* filename,unsigned char* dst)
  264. {
  265.         FILE *file;
  266.         unsigned char bmp[256];
  267.         int i,pp,size,bpp,r,g,b;
  268.  
  269.         file=fopen(filename,"rb");
  270.  
  271.         if(!file) return false;
  272.  
  273.         fseek(file,0,SEEK_END);
  274.         size=ftell(file);
  275.         if(size>256) size=256;
  276.         fseek(file,0,SEEK_SET);
  277.         fread(bmp,size,1,file);
  278.         fclose(file);
  279.        
  280.         if(bmp[0]!='B'||bmp[1]!='M')
  281.         {
  282.                 printf("ERR: Not BMP file format (%s)\n",filename);
  283.                 return false;
  284.         }
  285.        
  286.         bpp=bmp[28]+(bmp[29]<<8);
  287.        
  288.         if(bpp!=4&&bpp!=8)
  289.         {
  290.                 printf("ERR: Only uncompressed 16 and 256 colors BMP supported (%s)\n",filename);
  291.                 return false;
  292.         }
  293.  
  294.         pp=54;
  295.  
  296.         for(i=0;i<16;i++)
  297.         {
  298.                 b=bmp[pp++]>>6;
  299.                 g=bmp[pp++]>>6;
  300.                 r=bmp[pp++]>>6;
  301.  
  302.                 dst[i]=(b<<4)|(g<<2)|r;
  303.                 pp++;
  304.         }
  305.  
  306.         return true;
  307. }
  308.  
  309.  
  310.  
  311. inline void convert_tile(unsigned char* tile,int tx,int ty)
  312. {
  313.         int i,j,pp,pd;
  314.         unsigned char chr[8][8];
  315.        
  316.         switch(BMP.bpp)
  317.         {
  318.         case 4:
  319.                 {
  320.                         pd=BMP.flip?BMP.offset+(ty<<3)*(BMP.wdt>>1)+(tx<<2):BMP.offset+(BMP.hgt-1-(ty<<3))*(BMP.wdt>>1)+(tx<<2);
  321.                        
  322.                         for(i=0;i<8;++i)
  323.                         {
  324.                                 pp=pd;
  325.  
  326.                                 for(j=0;j<8;j+=2)
  327.                                 {
  328.                                         chr[i][j+0]=BMP.data[pp]>>4;
  329.                                         chr[i][j+1]=BMP.data[pp]&15;
  330.                                         ++pp;
  331.                                 }
  332.  
  333.                                 pd+=BMP.flip?(BMP.wdt>>1):0-(BMP.wdt>>1);
  334.                         }
  335.                 }
  336.                 break;
  337.  
  338.         case 8:
  339.                 {
  340.                         pd=BMP.flip?BMP.offset+(ty<<3)*BMP.wdt+(tx<<3):BMP.offset+(BMP.hgt-1-(ty<<3))*BMP.wdt+(tx<<3);
  341.                        
  342.                         for(i=0;i<8;++i)
  343.                         {
  344.                                 pp=pd;
  345.  
  346.                                 for(j=0;j<8;++j)
  347.                                 {
  348.                                         chr[i][j]=BMP.data[pp++]&15;
  349.                                 }
  350.  
  351.                                 pd+=BMP.flip?BMP.wdt:0-BMP.wdt;
  352.                         }
  353.                 }
  354.                 break;
  355.         }
  356.  
  357.         pp=0;
  358.  
  359.         for(i=0;i<8;++i)
  360.         {
  361.                 tile[pp+0]=PACK_PIXELS(chr[i][0],chr[i][1]);
  362.                 tile[pp+3]=PACK_PIXELS(chr[i][2],chr[i][3]);
  363.                 tile[pp+1]=PACK_PIXELS(chr[i][4],chr[i][5]);
  364.                 tile[pp+2]=PACK_PIXELS(chr[i][6],chr[i][7]);
  365.                 pp+=4;
  366.         }
  367. }
  368.  
  369.  
  370.  
  371. unsigned int read_dword(unsigned char* data)
  372. {
  373.         return data[0]+(data[1]<<8)+(data[2]<<16)+(data[3]<<24);
  374. }
  375.  
  376.  
  377.  
  378. unsigned int read_word(unsigned char* data)
  379. {
  380.         return data[0]+(data[1]<<8);
  381. }
  382.  
  383.  
  384.  
  385. unsigned char* load_graphics(const char* filename,int &tilecnt,int &tsizex,int &tsizey)
  386. {
  387.         FILE *file;
  388.         int i,j,ptr,rle,size,tssize;
  389.         unsigned char* tileset;
  390.  
  391.         file=fopen(filename,"rb");
  392.  
  393.         if(!file) return NULL;
  394.  
  395.         fseek(file,0,SEEK_END);
  396.         size=ftell(file);
  397.         fseek(file,0,SEEK_SET);
  398.         BMP.data=(unsigned char*)malloc(size);
  399.         fread(BMP.data,size,1,file);
  400.         fclose(file);
  401.        
  402.         if(BMP.data[0]!='B'||BMP.data[1]!='M')
  403.         {
  404.                 printf("ERR: Not BMP file format (%s)\n",filename);
  405.                 return NULL;
  406.         }
  407.        
  408.         BMP.offset=read_dword(&BMP.data[10]);
  409.         BMP.wdt=read_dword(&BMP.data[18]);
  410.         BMP.hgt=read_dword(&BMP.data[22]);
  411.         BMP.bpp=read_word (&BMP.data[28]);
  412.         rle=read_dword(&BMP.data[30]);
  413.        
  414.         if((BMP.wdt&7)||(BMP.hgt&7))
  415.         {
  416.                 printf("ERR: Width and height should be 8px aligned (%s)\n",filename);
  417.                 return NULL;
  418.         }
  419.  
  420.         if(rle!=0||(BMP.bpp!=4&&BMP.bpp!=8))
  421.         {
  422.                 printf("ERR: Only uncompressed 16 and 256 colors BMP supported (%s)\n",filename);
  423.                 return NULL;
  424.         }
  425.  
  426.         tsizex=BMP.wdt>>3;
  427.         tsizey=BMP.hgt>>3;
  428.        
  429.         BMP.flip=(BMP.hgt>0)?false:true;
  430.         if(BMP.flip) BMP.hgt=0-BMP.hgt;
  431.        
  432.         tilecnt=(BMP.wdt>>3)*(BMP.hgt>>3);
  433.         tssize=tilecnt<<5;
  434.         tileset=(unsigned char*)malloc(tssize);
  435.        
  436.         ptr=0;
  437.        
  438.         for(i=0;i<tsizey;i++)
  439.         {
  440.                 for(j=0;j<tsizex;j++)
  441.                 {
  442.                         convert_tile(&tileset[ptr],j,i);
  443.                         ptr+=32;
  444.                 }
  445.         }
  446.  
  447.         return tileset;
  448. }
  449.  
  450.  
  451.  
  452. void trim_str(char* line)
  453. {
  454.         unsigned int i;
  455.  
  456.         for(i=0;i<strlen(line);i++)
  457.         {
  458.                 if(line[i]<0x20)
  459.                 {
  460.                         line[i]=0;
  461.                         break;
  462.                 }
  463.         }
  464. }
  465.  
  466.  
  467.  
  468. #include "makesprite.h"
  469. #include "makesample.h"
  470.  
  471.  
  472.  
  473. void main(int argc,char* argv[])
  474. {
  475.         char cc_page[4]={stringToInt(args.getArg(CC_PAGE0)),
  476.                 stringToInt(args.getArg(CC_PAGE1)),
  477.                 stringToInt(args.getArg(CC_PAGE2)),
  478.                 stringToInt(args.getArg(CC_PAGE3))};
  479.         FILE *list,*file;
  480.         char line[1024];
  481.         unsigned char *data;
  482.         int i,pp,off,ptr,size,size2,page,img_count;
  483.         int mus_offset[256],mus_page[256];
  484.         int smp_offset[256],smp_page[256],smp_pitch[256];
  485.         int mus_count,mus_page_start,mus_pages,gfx_pages;
  486.         int code_size,code_pages;
  487.         int spr_page_start,spr_pages;
  488.         int smp_page_start,smp_pages,smp_count;
  489.         int tile_ptr,tile_cnt;
  490.         int wdt,hgt,cnt,pitch;
  491.         int pageNumCntr;
  492.         globalPageNum=0;
  493.         args.parse(argc,argv);
  494.         if(argc>1) {
  495.                 if(strstr(argv[1],"HELP")!=NULL) {
  496.                         args.printHelp();
  497.                         return;
  498.                 }
  499.         }
  500.  
  501.         if(stringToInt(args.getArg(ALT_PAGE_NUMERING))!=0) {
  502.                 globalPageNum=stringToInt(args.getArg(ALT_PAGE_NUMERING));
  503.         }
  504.         FILE *fileOutAsm;
  505.         fileOutAsm=fopen("_temp_/pages.asm","wb");
  506.  
  507.         tileData=NULL;
  508.         fileCnt=0;
  509.  
  510.         fileBatMLZ=fopen("_temp_/compress.bat","wt");
  511.         fileBatSCL=fopen("_temp_/createscl.bat","wt");
  512.  
  513.         fprintf(fileBatMLZ,"PATH=..\\..\\evosdk\n");
  514.         fprintf(fileBatMLZ,"echo messageStr > filelist.asm\n");
  515.         fprintf(fileBatMLZ,"echo \tdb %%title%%,0 >> filelist.asm\n");
  516.         fprintf(fileBatMLZ,"echo fileList >> filelist.asm\n");
  517.  
  518.         fprintf(fileBatSCL,"trdtool # disk.scl\n");
  519.         fprintf(fileBatSCL,"trdtool + disk.scl boot.$b\n");
  520.  
  521.         atexit(error);
  522.  
  523.         //уЁрЇшър шчюсЁрцхэшщ
  524.        
  525.         clear_mem();
  526.  
  527.         list=fopen(args.getArg(IMAGE_LIST),"rt");
  528.  
  529.         if(!list)
  530.         {
  531.                 printf("Error: Image list is missing\n");
  532.                 exit(1);
  533.         }
  534.         cc_page[0]=stringToInt(args.getArg(CC_PAGE0));
  535.         cc_page[1]=stringToInt(args.getArg(CC_PAGE1));
  536.         cc_page[2]=stringToInt(args.getArg(CC_PAGE2));
  537.         cc_page[3]=stringToInt(args.getArg(CC_PAGE3));
  538.  
  539.         page=stringToInt(args.getArg(GFX_PAGE));
  540.         gfx_pages=0;
  541.         ptr=0;
  542.         img_count=0;
  543.         tile_ptr=0;
  544.  
  545.         while(fgets(line,sizeof(line),list)!=NULL)
  546.         {
  547.                 if(img_count==256)
  548.                 {
  549.                         printf("ERR: Too many images\n");
  550.                         exit(1);
  551.                 }
  552.  
  553.                 if(!memcmp(line,"rem",3)||!memcmp(line,":",1)) continue;
  554.  
  555.                 trim_str(line);
  556.  
  557.                 tileData=load_graphics(line,tile_cnt,wdt,hgt);
  558.  
  559.                 if(!tileData)
  560.                 {
  561.                         printf("ERR: Can't open image (%s)\n",line);
  562.                         exit(1);
  563.                 }
  564.  
  565.                 IMGLIST[img_count].tile=tile_ptr;
  566.                 IMGLIST[img_count].wdt=wdt;
  567.                 IMGLIST[img_count].hgt=hgt;
  568.                 img_count++;
  569.                 tile_ptr+=tile_cnt;
  570.  
  571.                 off=0;
  572.                 pageNumCntr=0;
  573.                 for(i=0;i<tile_cnt;i++)
  574.                 {
  575.                         memcpy(&mem[ptr],&tileData[off],32);
  576.                         ptr+=32;
  577.                         off+=32;
  578.  
  579.                         if(ptr>=16384)
  580.                         {
  581.                                 page_save(0,page,"graphicsData",pageNumCntr,fileOutAsm);
  582.                                 pageNumCntr++;
  583.                                 ptr=0;
  584.                                 page++;
  585.                                 gfx_pages++;
  586.                         }
  587.                 }
  588.  
  589.                 //free(tileData);
  590.                 //if(tileData) free(tileData);
  591.  
  592.                 off+=16;
  593.         }
  594.        
  595.         if(ptr)
  596.         {
  597.                 page_save(0,page,"graphicsData",pageNumCntr,fileOutAsm);
  598.                 gfx_pages++;
  599.                 pageNumCntr++;
  600.         }
  601.  
  602.         fclose(list);
  603.  
  604.         mus_page_start=off?page+1:page;
  605.  
  606.         //ярышЄЁ√ ш ярЁрьхЄЁ√ шчюсЁрцхэшщ
  607.  
  608.         clear_mem();
  609.         pageNumCntr=0;
  610.         //list=fopen(argv[5],"rt");
  611.         list=fopen(args.getArg(PALETTE_LIST),"rt");
  612.  
  613.         if(!list)
  614.         {
  615.                 printf("Error: Palette list is missing\n");
  616.                 exit(1);
  617.         }
  618.  
  619.         //off=PAL_ADR;
  620.         off=stringToInt(args.getArg(PAL_ADR));
  621.         cnt=0;
  622.  
  623.         while(fgets(line,sizeof(line),list)!=NULL)
  624.         {
  625.                 if(cnt==256)
  626.                 {
  627.                         printf("ERR: Too many palettes\n");
  628.                         exit(1);
  629.                 }
  630.  
  631.                 if(!memcmp(line,"rem",3)||!memcmp(line,":",1)) continue;
  632.  
  633.                 trim_str(line);
  634.  
  635.                 if(!load_palette(line,&mem[off]))
  636.                 {
  637.                         printf("ERR: Can't load palette from image (%s)\n",line);
  638.                         exit(1);
  639.                 }
  640.  
  641.                 off+=16;
  642.                 cnt++;
  643.         }
  644.  
  645.         fclose(list);
  646.  
  647.         //off=IMGLIST_ADR;
  648.         off=stringToInt(args.getArg(IMGLIST_ADR));
  649.  
  650.         for(i=0;i<img_count;i++)
  651.         {
  652.                 mem[off++]=IMGLIST[i].tile&255;
  653.                 mem[off++]=IMGLIST[i].tile>>8;
  654.                 mem[off++]=IMGLIST[i].wdt;
  655.                 mem[off++]=IMGLIST[i].hgt;
  656.         }
  657.  
  658.         page_save(0,stringToInt(args.getArg(PAL_PAGE)),"palletesData",pageNumCntr,fileOutAsm);
  659.  
  660.         //фрээ√х ьєч√ъш
  661.  
  662.         clear_mem();
  663.         pageNumCntr=0;
  664.         //list=fopen(argv[4],"rt");
  665.         list=fopen(args.getArg(MUSIC_LIST),"rt");
  666.         if(!list)
  667.         {
  668.                 printf("Error: Music list is missing\n");
  669.                 exit(1);
  670.         }
  671.  
  672.         off=0;
  673.         page=mus_page_start;
  674.         mus_count=0;
  675.         mus_pages=0;
  676.  
  677.         while(fgets(line,sizeof(line),list)!=NULL)
  678.         {
  679.                 if(mus_count==256)
  680.                 {
  681.                         printf("ERR: Too many music files\n");
  682.                         exit(1);
  683.                 }
  684.  
  685.                 if(!memcmp(line,"rem",3)||!memcmp(line,":",1)) continue;
  686.  
  687.                 trim_str(line);
  688.  
  689.                 file=fopen(line,"rb");
  690.  
  691.                 if(!file)
  692.                 {
  693.                         printf("Error: Can't open file from music list (%s)\n",line);
  694.                         fclose(list);
  695.                         exit(1);
  696.                 }
  697.  
  698.                 fseek(file,0,SEEK_END);
  699.                 size=ftell(file);
  700.                 fseek(file,0,SEEK_SET);
  701.  
  702.                 if(size>16384)
  703.                 {
  704.                         printf("Error: Music file is too large, 16384 bytes max (%s)\n",line);
  705.                         fclose(list);
  706.                         exit(1);
  707.                 }
  708.  
  709.                 data=(unsigned char*)malloc(size);
  710.                 fread(data,size,1,file);
  711.                 fclose(file);
  712.  
  713.                 if(off+size>16384)
  714.                 {
  715.                         page_save(0,page,"musicData",pageNumCntr,fileOutAsm);
  716.                         clear_mem();
  717.                         pageNumCntr++;
  718.                         off=0;
  719.                         ++page;
  720.                         ++mus_pages;
  721.                 }
  722.  
  723.                 mus_offset[mus_count]=0x8000+off;
  724.                 mus_page[mus_count]=page;
  725.                 ++mus_count;
  726.  
  727.                 memcpy(&mem[off],data,size);
  728.                 off+=size;
  729.  
  730.                 free(data);
  731.         }
  732.  
  733.         if(mus_count&&off)
  734.         {
  735.                 page_save(0,page,"musicData",pageNumCntr,fileOutAsm);
  736.                 ++page;
  737.                 ++mus_pages;
  738.                 pageNumCntr++;
  739.         }
  740.  
  741.         fclose(list);
  742.        
  743.         smp_page_start=page;
  744.  
  745.         //фрээ√х ё¤ьяыют
  746.  
  747.         clear_mem();
  748.         pageNumCntr=0;
  749.         //list=fopen(argv[7],"rt");
  750.         list=fopen(args.getArg(SAMPLE_LIST),"rt");
  751.         if(!list)
  752.         {
  753.                 printf("Error: Sample list is missing\n");
  754.                 exit(1);
  755.         }
  756.  
  757.         off=0;
  758.         page=smp_page_start;
  759.         smp_count=0;
  760.         smp_pages=0;
  761.  
  762.         while(fgets(line,sizeof(line),list)!=NULL)
  763.         {
  764.                 if(smp_count==256)
  765.                 {
  766.                         printf("ERR: Too many samples\n");
  767.                         exit(1);
  768.                 }
  769.  
  770.                 if(!memcmp(line,"rem",3)||!memcmp(line,":",1)) continue;
  771.  
  772.                 trim_str(line);
  773.  
  774.                 data=load_wav(line,size,pitch);
  775.  
  776.                 if(!data)
  777.                 {
  778.                         printf("Error: Can't open file from sample list (%s)\n",line);
  779.                         fclose(list);
  780.                         exit(1);
  781.                 }
  782.  
  783.                 smp_offset[smp_count]=off;
  784.                 smp_page  [smp_count]=page^255;
  785.                 smp_pitch [smp_count]=pitch;
  786.  
  787.                 smp_count++;
  788.                 pp=0;
  789.  
  790.                 while(pp<size)
  791.                 {
  792.                         mem[off++]=data[pp++];
  793.  
  794.                         if(off>=16384)
  795.                         {
  796.                                 page_save(0,page,"sampleData",pageNumCntr,fileOutAsm);
  797.                                 pageNumCntr++;
  798.                                 clear_mem();
  799.                                 off=0;
  800.                                 page++;
  801.                                 smp_pages++;
  802.                         }
  803.                 }
  804.  
  805.                 free(data);
  806.         }
  807.  
  808.         if(smp_count&&off)
  809.         {
  810.                 page_save(0,page,"sampleData",pageNumCntr,fileOutAsm);
  811.                 page++;
  812.                 pageNumCntr++;
  813.                 smp_pages++;
  814.         }
  815.  
  816.         fclose(list);
  817.  
  818.         spr_page_start=page;
  819.  
  820.         //яыххЁ√ ьєч√ъш ш чтєър, фрээ√х чтєъют, ёяшёъш ё¤ьяыют ш ЄЁхъют
  821.        
  822.         clear_mem();
  823.         pageNumCntr=0;
  824.         //printf(" sound.bin\n");
  825.         //printf("=%s\n",args.getArg(SOUND_BIN_FILE));
  826.         if(!load_bin(0x4000,args.getArg(SOUND_BIN_FILE)))
  827.         {
  828.                 printf("Error: sound.bin not found\n");
  829.                 exit(1);
  830.         }
  831.         //printf(" sound.bin\n");
  832.         //if(strcmp(argv[3],"")) load_bin(SFX_ADR,argv[3]);
  833.         if(strcmp(args.getArg(SFX_LIST),"")) load_bin(stringToInt(args.getArg(SFX_ADR)),args.getArg(SFX_LIST));
  834.         mem[stringToInt(args.getArg(MUS_COUNT))]=mus_count;
  835.         off=stringToInt(args.getArg(MUSLIST_ADR));
  836.  
  837.         for(i=0;i<mus_count;i++)
  838.         {
  839.                 mem[off+0  ]=mus_offset[i]&255;
  840.                 mem[off+256]=mus_offset[i]>>8;
  841.                 mem[off+512]=mus_page  [i];
  842.                 ++off;
  843.         }
  844.  
  845.         mem[stringToInt(args.getArg(SMP_COUNT))]=smp_count;
  846.         off=stringToInt(args.getArg(SMPLIST_ADR));
  847.  
  848.         for(i=0;i<smp_count;i++)
  849.         {
  850.                 mem[off+0  ]=smp_offset[i]&255;
  851.                 mem[off+256]=smp_offset[i]>>8;
  852.                 mem[off+512]=smp_page  [i];
  853.                 mem[off+768]=smp_pitch [i];
  854.                 ++off;
  855.         }
  856.         //printf(" sound.bin\n");
  857.         page_save(1,stringToInt(args.getArg(SND_PAGE)),"soundData",pageNumCntr,fileOutAsm);
  858.        
  859.         //ёяЁрщЄ√
  860.         //printf(" Sprite\n");
  861.         pageNumCntr=0;
  862.         //list=fopen(argv[8],"rt");
  863.         list=fopen(args.getArg(SPRITE_LIST),"rt");
  864.         if(!list)
  865.         {
  866.                 printf("Error: Sprite list is missing\n");
  867.                 exit(1);
  868.         }
  869.  
  870.         mkspr_init(spr_page_start);
  871.  
  872.         spr_pages=0;
  873.  
  874.         while(fgets(line,sizeof(line),list)!=NULL)
  875.         {
  876.                 if(cnt==256)
  877.                 {
  878.                         printf("ERR: Too many sprites\n");
  879.                         exit(1);
  880.                 }
  881.  
  882.                 if(!memcmp(line,"rem",3)||!memcmp(line,":",1)) continue;
  883.  
  884.                 trim_str(line);
  885.  
  886.                 i=mkspr_add(line,stringToInt(args.getArg(SPRITE_SLOT)),fileOutAsm,&pageNumCntr);
  887.  
  888.                 if(i<0) {
  889.                         //printf(" mazafaka %d\n",i);
  890.                         exit(1);
  891.                 }
  892.  
  893.                 spr_pages=i-spr_page_start+1;
  894.         }
  895.  
  896.         if(mempos!=mem) {
  897.                 page_save(stringToInt(args.getArg(SPRITE_SLOT)),sprpg,"spriteData",pageNumCntr,fileOutAsm);
  898.                 pageNumCntr++;
  899.         }
  900.  
  901.         //ярЁрьхЄЁ√ ёяЁрщЄют
  902.         pageNumCntr=0;
  903.         if(spr_pages)
  904.         {
  905.                 memcpy(mem,tspraddr,16384);
  906.                 page_save(stringToInt(args.getArg(SPRTBL_SLOT)),stringToInt(args.getArg(SPRTBL_PAGE)),"spriteTableData",pageNumCntr,fileOutAsm);
  907.                 pageNumCntr++;
  908.         }
  909.  
  910.         //ъюф яЁюуЁрьь√
  911.  
  912.         clear_mem();
  913.        
  914.         //size=load_ihx(argv[1]);
  915.         size=load_ihx(args.getArg(BINARY_FILE));
  916.         //printf("code size =%d",size);
  917.         if(size>0)
  918.         {
  919.                 store_bin(size,0);
  920.  
  921.                 //printf("Error: Can't load Intel HEX from file\n");
  922.                 //exit(1);
  923.                 code_size=size;
  924.                
  925.                 if(code_size>=stringToInt(args.getArg(STARTUP_ADR))-stringToInt(args.getArg(STACK_SIZE)))
  926.                 {
  927.                         printf("Error: Out of memory, compiled code is too large\n");
  928.                         printf("code size: %d total space: %d\n",code_size,stringToInt(args.getArg(STARTUP_ADR))-stringToInt(args.getArg(STACK_SIZE)));
  929.                         exit(1);
  930.                 }
  931.  
  932.                 //if(!load_bin(atoi(args.getArg("STARTUP_ADR")),argv[2]))
  933.                 size2=load_bin2(stringToInt(args.getArg(STARTUP_ADR)),args.getArg(STARTUP_FILE));
  934.                 if(size2==0)
  935.                 {
  936.                         printf("Error: Can't load startup code\n");
  937.                         exit(1);
  938.                 }
  939.                 store_bin(size+size2,1);
  940.                 code_pages=0;
  941.                 pageNumCntr=0;
  942.                 if (stringToInt(args.getArg(ALT_PAGE_NUMERING))==0){
  943.                         for(i=0;i<4;i++)
  944.                         {
  945.                                 if(!page_is_empty(i))
  946.                                 {
  947.                                         page_save(i,cc_page[i],"codeData",pageNumCntr,fileOutAsm);
  948.                                         code_pages++;
  949.                                         pageNumCntr++;
  950.                                 }
  951.                         }
  952.                 }
  953.         }
  954.         fprintf(fileOutAsm,"totalPages = %d\n",fileCnt);
  955.         //чртхЁ°хэшх т√тюфр фрээ√ї фы  чруЁєчўшър
  956.  
  957.         fprintf(fileBatMLZ,"echo \tdb 0,%i >>filelist.asm\n",stringToInt(args.getArg(CC_PAGE3)));
  958.         fprintf(fileBatMLZ,"echo \tdw %i >>filelist.asm\n",stringToInt(args.getArg(STARTUP_ADR)));
  959.         fprintf(fileBatMLZ,"echo progressStep >>filelist.asm\n");
  960.         fprintf(fileBatMLZ,"echo \tdw %i >> filelist.asm\n",32*256/fileCnt/2);
  961.  
  962.         //шэЇюЁьрЎш  юс шёяюы№чютрэшш ярь Єш
  963.  
  964.         if(spr_page_start+spr_pages>=192)
  965.         {
  966.                 printf("ERR: Too many RAM pages used (192)\n");
  967.                 exit(1);
  968.         }
  969.  
  970.         page=4/*code_pages*/+4/*sprbuf*/+mus_pages+smp_pages+gfx_pages+spr_pages+1+1+(spr_pages?1:0);//snd, pal, sprtbl
  971.  
  972.         //printf("\nCompiled code size %i bytes (%i max, %i left)\n\n",code_size,stringToInt(args.getArg(STARTUP_ADR))-stringToInt(args.getArg(STACK_SIZE)),stringToInt(args.getArg(STARTUP_ADR))-stringToInt(args.getArg(STACK_SIZE))-code_size);
  973.  
  974.         //printf("%i RAM pages (%iK) used:\n",page,page*16);
  975.         /*printf("Code:\t\t\t%i,%i,%i,%i\n",stringToInt(args.getArg(CC_PAGE0)),
  976.                 stringToInt(args.getArg(CC_PAGE1)),
  977.                 stringToInt(args.getArg(CC_PAGE2)),
  978.                 stringToInt(args.getArg(CC_PAGE3)));*/
  979.         /*printf("Sprites buffer:\t\t%i,%i,%i,%i\n",stringToInt(args.getArg(SPRBUF_PAGE)),
  980.                 stringToInt(args.getArg(SPRBUF_PAGE))+1,stringToInt(args.getArg(SPRBUF_PAGE))+2,stringToInt(args.getArg(SPRBUF_PAGE))+3);
  981.         printf("Graphics data:\t\t");*/
  982.         /*if(gfx_pages)
  983.         {
  984.                
  985.                 for(i=0;i<gfx_pages;i++){
  986.                        
  987.                         printf("%i%c",stringToInt(args.getArg(GFX_PAGE))+i,i<gfx_pages-1?',':'\n');
  988.                 }
  989.                
  990.         }
  991.         else
  992.         {
  993.                 printf("no data\n");
  994.         }*/
  995.         /*printf("Palettes and params:\t%i\n",stringToInt(args.getArg(PAL_PAGE)));
  996.         printf("Sound code and sfx:\t%i\n",stringToInt(args.getArg(SND_PAGE)));
  997.         printf("Music data:\t\t");
  998.         if(mus_pages)
  999.         {
  1000.                 for(i=0;i<mus_pages;i++) printf("%i%c",mus_page_start+i,i<mus_pages-1?',':'\n');
  1001.         }
  1002.         else
  1003.         {
  1004.                 printf("no data\n");
  1005.         }*/
  1006.         /*printf("Sample data:\t\t");
  1007.         if(smp_pages)
  1008.         {
  1009.                 for(i=0;i<smp_pages;i++) printf("%i%c",smp_page_start+i,i<smp_pages-1?',':'\n');
  1010.         }
  1011.         else
  1012.         {
  1013.                 printf("no data\n");
  1014.         }*/
  1015.         /*printf("Sprite data:\t\t");
  1016.         if(spr_pages)
  1017.         {
  1018.                 for(i=0;i<spr_pages;i++) printf("%i%c",spr_page_start+i,i<spr_pages-1?',':'\n');
  1019.                 printf("Sprite parameters:\t%i\n",stringToInt(args.getArg(SPRTBL_PAGE)));
  1020.         }
  1021.         else
  1022.         {
  1023.                 printf("no data\n");
  1024.                 printf("Sprite parameters:\tno data\n");
  1025.         }*/
  1026.         //printf("Total count of files:\t%d",fileCnt);
  1027.         //printf("\n");
  1028.  
  1029.         //return 0;
  1030. }