home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / BEERSRC.ZIP / SLIB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-27  |  7.9 KB  |  430 lines
  1.  
  2.  
  3. #ifndef __COMPACT__
  4.    #error Memory Model must be compact
  5. #endif
  6.  
  7. #include <string.h>
  8. #include <stdlib.h>
  9. #include <conio.h>
  10. #include <stdio.h>
  11. #include <alloc.h>
  12. #include <io.h>
  13. #include <fcntl.h>
  14. #include <sys\stat.h>
  15. #include <dos.h>
  16.  
  17.  
  18. #define   MAXSPRITES        100
  19.  
  20.  
  21. #include "xmode.h"
  22. #define MAIN_MODULE
  23. #include "baller.h"
  24.  
  25. #define MIDX                 100
  26. #define MIDY                 80
  27.  
  28. #define STATLINE             210
  29.  
  30.  
  31. int    nsprs;
  32. int    sspr = -1;
  33. struct sTableEntry spr[MAXSPRITES];
  34.  
  35. int    handle;
  36. int    n = 0;
  37.  
  38. struct sprstrc *font;
  39.  
  40.  
  41. #pragma argsused
  42. void error(char *s, int code, ...)
  43. {
  44.  
  45. }
  46.  
  47.  
  48. int loadsprite(char *file)
  49. {
  50.    int      filvar;
  51.    unsigned size;
  52.  
  53.    if (nsprs < MAXSPRITES) {
  54.  
  55.       sspr = nsprs; nsprs++;
  56.       filvar = open(file, O_RDONLY | O_BINARY, S_IREAD);
  57.       if (filvar == -1) return -1;
  58.  
  59.       size = filelength(filvar);
  60.       if ((spr[sspr].sprite = malloc(size)) == NULL) return -1;
  61.  
  62.       read(filvar, spr[sspr].sprite, size);
  63.       close(filvar);
  64.  
  65.       return 0;
  66.    }
  67.  
  68.    return -1;
  69. }
  70.  
  71. void status(void)
  72. {
  73.    char   text[80];
  74.  
  75.    clearregion(STATLINE-8, 16);
  76.  
  77.    sprintf(text, "PIC.%d    FLAGS.%XH", n, spr[sspr].flags);
  78.    writetext(0, STATLINE, text, font);
  79.  
  80. }
  81.  
  82.  
  83.  
  84. int roll(int n, int lb, int ub, int dir)
  85. {
  86.    if (dir == 1) {
  87.       n++; if (n > ub) n = lb;
  88.    } else {
  89.       n--; if (n < lb) n = ub;
  90.    }
  91.  
  92.    return n;
  93. }
  94.  
  95. void delspr(void)
  96. {
  97.    int  i;
  98.  
  99.    if (sspr != -1) {
  100.  
  101.       for (i = sspr + 1; i < nsprs; i++) {
  102.      spr[i-1] = spr[i];
  103.       }
  104.       nsprs--;
  105.  
  106.       if (nsprs == 0) sspr = -1;
  107.       else {
  108.      sspr--; if (sspr < 0) sspr = nsprs - 1;
  109.       }
  110.    }
  111.  
  112. }
  113.  
  114. void removedouble(void)
  115. {
  116.    int   size;
  117.    int   i;
  118.  
  119.    if (spr[sspr].sprite->maxn <= 1) return;
  120.  
  121.    size = spr[sspr].sprite->xs * spr[sspr].sprite->ys;
  122.    for (i = 2; i < spr[sspr].sprite->maxn; i+=2) {
  123.       memmove(&spr[sspr].sprite->data[size*(i/2)],
  124.           &spr[sspr].sprite->data[size*i],
  125.           size);
  126.    }
  127.    spr[sspr].sprite->maxn /= 2;
  128.    spr[sspr].sprite = realloc(spr[sspr].sprite,
  129.             spr[sspr].sprite->maxn*size + sizeof(struct sprstrc));
  130.  
  131. }
  132.  
  133.  
  134. void newsprite(void)
  135. {
  136.    killsprite(handle);
  137.    handle = defsprite(spr[sspr].sprite, spr[sspr].flags);
  138.    n = 0;
  139. }
  140.  
  141.  
  142. int getkey(void)
  143. {
  144.    int  ch1, ch2;
  145.    char  text[80];
  146.  
  147.  
  148.    ch1 = getch();
  149.    if(ch1 == 0) ch2 = getch();
  150.  
  151.    if (ch1 == 0) {
  152.       switch (ch2) {
  153.  
  154.      case 'C': // F9
  155.      case 'D':
  156.            removesprite(handle, MIDX, MIDY);  // F10
  157.            sspr = roll(sspr, 0, nsprs - 1, ch2 - 'C');
  158.            newsprite();
  159.            break;
  160.  
  161.      case 'M': // Cursor Right
  162.      case 'K': // Cursor Left
  163.         if (sspr != -1) {
  164.            n = roll(n, 0, spr[sspr].sprite->maxn-1, (ch2 == 'M') ? 1 : 0);
  165.                 }
  166.         break;
  167.       }
  168.       status();
  169.    } else {
  170.       switch (ch1) {
  171.  
  172.      case 'l': // Load
  173.            killallsprites();
  174.            shutxmode();
  175.            printf("Sprite to load [.SPR]: ");
  176.            fflush(stdin);
  177.            scanf("%s", text);
  178.            strcat(text, ".SPR");
  179.            if (loadsprite(text) == -1) {
  180.               perror("loadsprite");
  181.               if (--nsprs == 0) sspr = -1; else sspr = 0;
  182.               n = 0;
  183.            }
  184.            initxmode();
  185.            if (sspr != -1) {
  186.               spr[sspr].flags = 12;
  187.               handle = defsprite(spr[sspr].sprite, spr[sspr].flags);
  188.               n = 0;
  189.            }
  190.            break;
  191.  
  192.      case 'e': // flags.
  193.            if (sspr != -1) {
  194.            killallsprites();
  195.            shutxmode();
  196.            printf("2,4 = xAlign, 8h=Double\n");
  197.            printf("Flags [%xh]: ", spr[sspr].flags);
  198.            fflush(stdin);
  199.            gets(text);
  200.            if (strlen(text) != 0) sscanf(text, "%x", &spr[sspr].flags);
  201.            initxmode();
  202.            handle = defsprite(spr[sspr].sprite, spr[sspr].flags);
  203.            n = 0;
  204.            }
  205.            break;
  206.  
  207.      case 'd': // Delete.
  208.            removesprite(handle, MIDX, MIDY);
  209.            delspr();
  210.            if (sspr != -1) {
  211.               spr[sspr].flags = 12;
  212.               handle = defsprite(spr[sspr].sprite, spr[sspr].flags);
  213.               n = 0;
  214.            }
  215.            break;
  216.  
  217.      case 'r': // Remove double.
  218.            removedouble();
  219.                    newsprite();
  220.            break;
  221.  
  222.      case 'q': return 1;
  223.  
  224.       }
  225.  
  226.       status();
  227.  
  228.    }
  229.  
  230.    return 0;
  231.  
  232. }
  233.  
  234.  
  235. void Und_Los(void)
  236. {
  237.  
  238.    initxmode();
  239.  
  240.    if (sspr != -1) {
  241.       handle = defsprite(spr[sspr].sprite, spr[sspr].flags);
  242.       n = 0;
  243.    }
  244.  
  245.    status();
  246.  
  247.    do {
  248.       if (sspr != -1) {
  249.      removesprite(handle, MIDX, MIDY);
  250.      putsprite(handle, MIDX, MIDY, n);
  251.       }
  252.    } while (!getkey());
  253.  
  254.    killallsprites();
  255.  
  256.    shutxmode();
  257.  
  258. }
  259.  
  260.  
  261. int loadfont(void)
  262. {
  263.    int      filvar;
  264.    long        size;
  265.    int      nentries;
  266.    int      i;
  267.  
  268.    if ((filvar = open("font1.spr", O_RDONLY | O_BINARY, S_IREAD)) == -1) {
  269.       return -1;
  270.    }
  271.    size = filelength(filvar);
  272.  
  273.    if ((font = malloc(size)) == NULL) {
  274.       close(filvar);
  275.       return -1;
  276.    }
  277.    read(filvar, font, size);
  278.    close(filvar);
  279.  
  280.    return 0;
  281.  
  282. }
  283.  
  284.  
  285.  
  286.  
  287. int saveslib(char *file)
  288. {
  289.    int       filvar, i;
  290.    long      ptr, ptr0;
  291.    long      fptr1, fptr2;
  292.    unsigned  size;
  293.  
  294.    filvar = open(file, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, S_IWRITE);
  295.    if (filvar == -1) return -1;
  296.  
  297.    write(filvar, &nsprs, 2);
  298.    fptr1 = tell(filvar);
  299.    ptr = nsprs*sizeof(struct sTableEntry);
  300.    write(filvar, spr, ptr);
  301.  
  302.    for (i = 0; i < nsprs; i++) {
  303.       size = spr[i].sprite->xs*spr[i].sprite->ys*spr[i].sprite->maxn + 6;
  304.       write(filvar, spr[i].sprite, size);
  305.       fptr2 = tell(filvar);
  306.       lseek(filvar, fptr1, SEEK_SET);
  307.       ptr0 = (ptr & 0xf) + ((ptr & 0xffff0) << 12);
  308.       write(filvar, &ptr0, 4); write(filvar, &spr[i].flags, 2);
  309.       ptr += size;
  310.       fptr1 = tell(filvar);
  311.       lseek(filvar, fptr2, SEEK_SET);
  312.  
  313.    }
  314.  
  315.    close(filvar);
  316.  
  317.    return 0;
  318. }
  319.  
  320.  
  321. int readslib(char *file)
  322. {
  323.  
  324.    int      filvar;
  325.    long        size;
  326.    int      i;
  327.    struct   sTableEntry *ptr;
  328.    char     huge *h;
  329.  
  330.    if ((filvar = open(file, O_RDONLY | O_BINARY, S_IREAD)) == -1) {
  331.       return -1;
  332.    }
  333.    read(filvar, &nsprs, 2);
  334.  
  335.    size = filelength(filvar) - 2;
  336.    if ((ptr = farmalloc(size)) == NULL) {
  337.       close(filvar);
  338.       abort();
  339.    }
  340.    h = (char *) ptr;
  341.    while (size > 65000) {
  342.       read(filvar, h, 65000);
  343.       h += 65000; size -= 65000;
  344.    }
  345.    read(filvar, h, size);
  346.    close(filvar);
  347.  
  348.  
  349. // Relocate pointers to single data elements.
  350.    for (i = 0; i < nsprs; i++) {
  351.       (long)ptr[i].sprite += (long)ptr;
  352.    }
  353.  
  354.    for (i = 0; i < nsprs; i++) {
  355.       size = ptr[i].sprite->xs*ptr[i].sprite->ys*ptr[i].sprite->maxn;
  356.       spr[i].sprite = malloc(size+sizeof(struct sprstrc));
  357.       if (spr[i].sprite == NULL) abort();
  358.       spr[i].flags = ptr[i].flags;
  359.       memcpy(spr[i].sprite, ptr[i].sprite, size+sizeof(struct sprstrc));
  360.    }
  361.  
  362.    farfree(ptr);
  363.    return 0;
  364.  
  365. }
  366.  
  367. void shutsprites(void)
  368. {
  369.    if (spr != NULL) free(spr);
  370. }
  371.  
  372.  
  373. void main(void)
  374. {
  375.    char  libfile[80];
  376.    int   choice;
  377.  
  378.    printf("\n\nSPRITE LIBRARY MANAGER Ver 2.007!\n");
  379.    printf("[c] copyrigth 1992/93 by ALPHA-HELIX.\n");
  380.  
  381.    loadfont();
  382.  
  383.    do {
  384.  
  385.    do {
  386.       printf("\n\n");
  387.       printf("1 - Manager.\n");
  388.       printf("7 - Save lib.\n");
  389.       printf("8 - Load sprite library\n");
  390.       printf("9 - Quit SLM.\n");
  391.  
  392.       printf("\nYour choice -> "); choice = getche() - '0';
  393.       printf("\n\n");
  394.  
  395.       switch (choice) {
  396.      case 1: Und_Los();
  397.          break;
  398.  
  399.      case 7: printf("Save: Sprite Library [.SLI]: ");
  400.          fflush(stdin);
  401.          scanf("%s", libfile);
  402.          strcat(libfile, ".SLI");
  403.          if (saveslib(libfile) == -1) {
  404.             perror("File not written: ");
  405.          }
  406.          break;
  407.  
  408.      case 8: printf("Load: Sprite Library [.SLI]: ");
  409.          fflush(stdin);
  410.          scanf("%s", libfile);
  411.          strcat(libfile, ".SLI");
  412.          shutsprites();
  413.          readslib(libfile);
  414.          sspr = 0;
  415.          break;
  416.       }
  417.  
  418.    } while (choice != 9);
  419.  
  420.    printf("\n\nQuit without saving (Y/N)? "); choice = getche();
  421.    } while (choice != 'y');
  422.  
  423.    shutsprites();
  424.    free(font);
  425.    printf("\nThanks for using SLM !\n\n\n\n");
  426.  
  427. }
  428.  
  429.  
  430.