?login_element?

Subversion Repositories NedoOS

Rev

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