home *** CD-ROM | disk | FTP | other *** search
/ Multimedia Classic / MultimediaClassic.mdf / audio_cd / cthugha.dos / flames.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-19  |  11.7 KB  |  735 lines
  1. //
  2. // Cthugha - Audio Seeded Image Processing
  3. //
  4. // Zaph, Digital Aasvogel Group, Torps Productions 1993-1994
  5. //
  6.  
  7.  
  8. #include <stdio.h>
  9. #include <dos.h>
  10. #include <io.h>
  11. #include <fcntl.h>
  12. #include <stdlib.h>
  13. #include <math.h>
  14. #include <conio.h>
  15. #include <bios.h>
  16. #include <memory.h>
  17. #include <assert.h>
  18.  
  19. #include "cthugha.h"
  20. #include "charset.h"
  21. #include "zorilkey.h"
  22. #include "audio.h"
  23. #include "translat.h"
  24.  
  25. #define NUMSTRINGS 20
  26.  
  27. char stringtable[NUMSTRINGS][21]={
  28. //    "---------|---------"
  29.     " Wheres the music? ",
  30.     "       JOLT !      ",
  31.     "      Hey, You!!   ",
  32.     " Turn The Music On ",
  33.     "    Lets Party!!!  ",
  34.     " Pink Floyd Rules  ",
  35.     "Sounds of Silence ?",
  36.     "     The Torps     ",
  37.     "     Play DOOM     ",
  38.     "     Drink COKE    ",
  39.     "     Hello ??      ",
  40.     "Number 5 is ALIVE!!",
  41.     "Spooky....         ",
  42.     "Wheres Cthugha 6.0?",
  43.     "   Subliminal Ads  ",
  44.     "Read a book        ",
  45.     "     Get a life....",
  46.     "      SMILE!       ",
  47.     "    Cthugha 5.0    ",
  48.     " Torps Productions "
  49. };
  50.  
  51.  
  52. extern int peaks,peakframes,peaknoise;
  53. extern int massage_audio(void);
  54. extern int allow_fft,use_fft;
  55.  
  56. void (*flame)(void);
  57.  
  58. static void flame_upslow(void);
  59. static void flame_upsubtle(void);
  60. static void flame_upfast(void);
  61. static void flame_leftslow(void);
  62. static void flame_leftsubtle(void);
  63. static void flame_leftfast(void);
  64. static void flame_rightslow(void);
  65. static void flame_rightsubtle(void);
  66. static void flame_rightfast(void);
  67. static void flame_water(void);
  68. static void flame_watersubtle(void);
  69. static void flame_skyline(void);
  70. static void flame_weird(void);
  71.  
  72. int numflames=-1;
  73. void (*flamearray[])(void)={
  74.     flame_leftslow,
  75.     flame_leftsubtle,
  76.     flame_leftfast,
  77.     flame_upslow,
  78.     flame_upsubtle,
  79.     flame_upfast,
  80.     flame_rightslow,
  81.     flame_rightsubtle,
  82.     flame_rightfast,
  83.     flame_water,
  84.     flame_watersubtle,
  85.     flame_skyline,
  86.     flame_weird,
  87.     NULL
  88. };
  89. // Change the flame function pointer...
  90.  
  91. int change_flame(int flamenum)
  92. {
  93.  
  94.     if (numflames<0) {
  95.         numflames=0;
  96.         while (flamearray[numflames]!=NULL)
  97.             numflames++;
  98.         assert(numflames);
  99.     }
  100.  
  101.     flamenum=flamenum%numflames;
  102.     flame=flamearray[flamenum];
  103.  
  104.     return flamenum;
  105. }
  106.  
  107. // The flame main loop
  108. // Runs the flame, 
  109. // Gets the stereo, 
  110. // produces the wave
  111. // and then displays it...
  112.  
  113. extern int was_quiet;
  114. extern void wave(void);
  115.  
  116. extern int time_to_change;
  117.  
  118. extern void display_up(void);
  119. extern void display_dn(void);
  120. extern void draw_text(int xpos, int ypos, int size, int colour, char *tbuf);
  121. extern int quiet_change;
  122. void flame_cro(void)
  123. {
  124.     int count,temp;
  125.     static quiet=0,showstring=0;
  126.     static linenum=42;
  127.  
  128.     count=rand()%rand_time+min_time;
  129.  
  130. //    memset(buff[BUFF_BOTTOM+1],0,BUFF_WIDTH*2);
  131.  
  132.     for (temp=0; temp<BUFF_WIDTH; temp++) {
  133.         buff[BUFF_BOTTOM][temp]=0;
  134.         buff[BUFF_BOTTOM+1][temp]=0;
  135.         buff[BUFF_BOTTOM+2][temp]=0;
  136.         buff[BUFF_BOTTOM+3][temp]=0;
  137.     }
  138.  
  139.     while ((_bios_keybrd(_KEYBRD_READY)==0) && (count>0)) {
  140.         count--;
  141.  
  142.         flame();
  143.  
  144. //        draw_text(0,0,1,0,"Cthugha V5.0");
  145. //        draw_text(1,1,1,255,"Cthugha V5.0");
  146.  
  147.         if (translate)
  148.             translate_screen();
  149.  
  150.         if (get_stereo()) {
  151.             if (massageStyle)
  152.                 massage_audio();
  153.             if (allow_fft && use_fft) {
  154.                 FFT(0);
  155.                 FFT(1);
  156.             }
  157.             wave();
  158.             if (quiet_change)
  159.                 if (quiet>quiet_change) {
  160.                     was_quiet=1;
  161.                     quiet=0;
  162.                 } else {  // We *HAD* silence, but now its noisy again!!
  163.                     if (was_quiet) {
  164.                         was_quiet=0;
  165.                         count=0;
  166.                     }
  167.                 }
  168.             if (peakframes>0) {
  169.                 if (peaknoise) {
  170.                     peaks++;
  171.                     if (peaks>peakframes) {
  172.                         peaks=0;
  173.                         time_to_change=1;
  174.                         count=0;
  175.                     }
  176.                 }
  177.  
  178.             }
  179.         } else {
  180.             quiet++;
  181.             if (quiet>255) {
  182.                 draw_text(0,linenum,2,table[curtable][0],stringtable[showstring]);
  183.                 draw_text(1,linenum+1,2,table[curtable][quiet-255],stringtable[showstring]);
  184.                 if (quiet>512) {
  185.                     quiet=0;
  186.                     showstring=rand()%NUMSTRINGS;
  187.                     linenum=rand()%80;
  188.                 }
  189.             }
  190.         }
  191.  
  192.         switch (curdisplay) {
  193.             case 0:
  194.             default:
  195.                 display_up();
  196.                 break;
  197.             case 1:
  198.                 display_dn();
  199.                 break;
  200.         }
  201.  
  202.     }
  203.  
  204. }
  205.  
  206. // Standard flame (upwards)
  207. static void flame_upslow(void)
  208. {
  209.         _asm {
  210.             pusha;
  211.  
  212.             mov cx,64636;
  213.             mov dx,SEG buff;
  214.             mov es,dx;
  215.             mov dx,OFFSET buff;
  216.             mov di,BUFF_WIDTH;
  217.             }
  218. jp11:    _asm {
  219.             xor ax,ax;
  220.             xor bx,bx;
  221.             mov al,es:[di-1];
  222.             mov bl,es:[di];
  223.             add ax,bx;
  224.             mov bl,es:[di+1];
  225.             add ax,bx;
  226.             mov bl,es:[di+BUFF_WIDTH];
  227.             add ax,bx;
  228.             shr ax,2;
  229.             jz jp12;
  230.             dec ax;
  231.             }
  232. jp12:    _asm {
  233.             mov byte ptr es:[di-BUFF_WIDTH],al;
  234.             inc di;
  235.             loop jp11;
  236.  
  237.             popa;
  238.         }
  239. }
  240.  
  241. static void flame_upsubtle(void)
  242. {
  243.         _asm {
  244.             pusha;
  245.  
  246.             mov cx,64636;
  247.             mov dx,SEG buff;
  248.             mov es,dx;
  249.             mov dx,OFFSET buff;
  250.             mov di,BUFF_WIDTH;
  251.             }
  252. jp11:    _asm {
  253.             xor ax,ax;
  254.             mov al,es:[di-1];
  255.             add al,es:[di];
  256.             add al,es:[di+1];
  257.             add al,es:[di+BUFF_WIDTH];
  258.             shr ax,2;
  259.             jz jp12;
  260.             dec ax;
  261.             }
  262. jp12:    _asm {
  263.             mov byte ptr es:[di-BUFF_WIDTH],al;
  264.             inc di;
  265.             loop jp11;
  266.  
  267.             popa;
  268.         }
  269. }
  270. // Flame left
  271. static void flame_leftslow(void)
  272. {
  273.         _asm {
  274.             pusha;
  275.  
  276.             mov cx,64636;
  277.             mov dx,SEG buff;
  278.             mov es,dx;
  279.             mov dx,OFFSET buff;
  280.             mov di,BUFF_WIDTH;
  281.             }
  282. jp21:    _asm {
  283.             xor ax,ax;
  284.             xor bx,bx;
  285.             mov al,es:[di-(BUFF_WIDTH-1)];
  286.             mov bl,es:[di];
  287.             add ax,bx;
  288.             mov bl,es:[di+1];
  289.             add ax,bx;
  290.             mov bl,es:[di+BUFF_WIDTH];
  291.             add ax,bx;
  292.             shr ax,2;
  293.             jz jp22;
  294.             dec ax;
  295.             }
  296. jp22:    _asm {
  297.             mov byte ptr es:[di-BUFF_WIDTH],al;
  298.             inc di;
  299.             loop jp21;
  300.  
  301.             popa;
  302.  
  303.     }
  304. }
  305.  
  306. // Flame right
  307. static void flame_rightslow(void)
  308. {
  309.         _asm {
  310.             pusha;
  311.  
  312.             mov cx,64636;
  313.             mov dx,SEG buff;
  314.             mov es,dx;
  315.             mov dx,OFFSET buff;
  316.             mov di,BUFF_WIDTH+1;
  317.             }
  318. jp31:    _asm {
  319.             xor ax,ax;
  320.             xor bx,bx;
  321.             mov al,es:[di-(BUFF_WIDTH+1)];
  322.             mov bl,es:[di];
  323.             add ax,bx;
  324.             mov bl,es:[di-1];
  325.             add ax,bx;
  326.             mov bl,es:[di+BUFF_WIDTH];
  327.             add ax,bx;
  328.             shr ax,2;
  329.             jz jp32;
  330.             dec ax;
  331.             }
  332. jp32:        _asm {
  333.             mov byte ptr es:[di-BUFF_WIDTH],al;
  334.             inc di;
  335.             loop jp31;
  336.  
  337.             popa;
  338.  
  339.     }
  340. }
  341.  
  342. // Flame over water effect
  343. static void flame_water(void)
  344. {
  345.         _asm {
  346.             pusha;
  347.  
  348.             mov cx,32318+BUFF_WIDTH;
  349.             mov dx,SEG buff;
  350.             mov es,dx;
  351.             mov dx,OFFSET buff;
  352.             mov di,BUFF_WIDTH;
  353.             }
  354. jp41:    _asm {
  355.             xor ax,ax;
  356.             xor bx,bx;
  357.             mov al,es:[di-1];
  358.             mov bl,es:[di];
  359.             add ax,bx;
  360.             mov bl,es:[di+1];
  361.             add ax,bx;
  362.             mov bl,es:[di+BUFF_WIDTH];
  363.             add ax,bx;
  364.             }
  365. jp42b:     _asm {
  366.             shr ax,2;
  367.             jz jp42;
  368.             dec ax;
  369.             }
  370. jp42:    _asm {
  371.             mov byte ptr es:[di-BUFF_WIDTH],al;
  372.             inc di;
  373.             loop jp41;
  374.  
  375.             popa;
  376.     }
  377.         _asm {
  378.             pusha;
  379.  
  380.             mov cx,32318;
  381.             mov dx,SEG buff;
  382.             mov es,dx;
  383.             mov dx,OFFSET buff;
  384. //            mov di,64636;
  385.             mov di,64320;
  386.             }
  387.  
  388. jpz41:   _asm {
  389.             xor ax,ax;
  390.             xor bx,bx;
  391.             mov al,es:[di-(BUFF_WIDTH-1)];
  392.             mov bl,es:[di];
  393.             add ax,bx;
  394.             mov bl,es:[di+1];
  395.             add ax,bx;
  396.             mov bl,es:[di-BUFF_WIDTH];
  397.             add ax,bx;
  398.             shr ax,2;
  399. //            jz jpz42;
  400. //            dec ax;
  401.             }
  402. jpz42:    _asm {
  403.             mov byte ptr es:[di+BUFF_WIDTH],al;
  404.             dec di;
  405.             loop jpz41;
  406.  
  407.             popa;
  408.     }
  409. }
  410.  
  411.  
  412.  
  413. static void flame_skyline(void)
  414. {
  415.         _asm {
  416.             pusha;
  417.  
  418.             mov cx,64636;
  419.             mov dx,SEG buff;
  420.             mov es,dx;
  421.             mov dx,OFFSET buff;
  422.             mov di,BUFF_WIDTH;
  423.             }
  424. jp11:    _asm {
  425.             xor ax,ax;
  426.             xor bx,bx;
  427.             mov al,es:[di-1];
  428.             mov bl,es:[di];
  429.             add ax,bx;
  430.             mov bl,es:[di+1];
  431.             add ax,bx;
  432. //            mov bl,es:[di+BUFF_WIDTH];
  433.             mov bl,es:[di];
  434.             add ax,bx;
  435.  
  436.             jz jp12;
  437.             dec ax;
  438.  
  439.             shr ax,2;
  440.  
  441.             }
  442. jp12:    _asm {
  443.             mov byte ptr es:[di-BUFF_WIDTH],al;
  444.             inc di;
  445.             loop jp11;
  446.  
  447.             popa;
  448.  
  449.         }
  450. }
  451.  
  452. static void flame_upfast(void)
  453. {
  454.         _asm {
  455.             pusha;
  456.  
  457. //            mov cx,16159;
  458. //            mov cx,64636;
  459.             mov cx,64000+BUFF_WIDTH;
  460.             mov dx,SEG buff;
  461.             mov es,dx;
  462.             mov dx,OFFSET buff;
  463. //            mov di,BUFF_WIDTH;
  464.             mov di,64000+BUFF_WIDTH;
  465.             }
  466. jp11:    _asm {
  467.             xor ax,ax;
  468.             xor bx,bx;
  469.             mov al,es:[di];
  470.             mov bl,es:[di+BUFF_WIDTH-1];
  471.             add ax,bx;
  472.             mov bl,es:[di+BUFF_WIDTH+1];
  473.             add ax,bx;
  474.             mov bl,es:[di+BUFF_WIDTH];
  475.             add ax,bx;
  476.             shr ax,2;
  477.             jz jp12;
  478.             dec ax;
  479.             }
  480. jp12:    _asm {
  481.             mov byte ptr es:[di],al;
  482. //            inc di;
  483.             dec di;
  484.             loop jp11;
  485.  
  486.             popa;
  487.         }
  488. }
  489.  
  490.  
  491.  
  492. // long flame (with triangle artifacts)
  493. static void flame_leftfast(void)
  494. {
  495.         _asm {
  496.  
  497.             pusha;
  498.  
  499. //            mov cx,16159;
  500. //            mov cx,64636;
  501.             mov cx,64000+BUFF_WIDTH;
  502.             mov dx,SEG buff;
  503.             mov es,dx;
  504.             mov dx,OFFSET buff;
  505. //            mov di,BUFF_WIDTH;
  506.             mov di,64000+BUFF_WIDTH;
  507.             }
  508. jp11:    _asm {
  509.             xor ax,ax;
  510.             xor bx,bx;
  511.             mov al,es:[di];
  512.             mov bl,es:[di+BUFF_WIDTH+1];
  513.             add ax,bx;
  514.             mov bl,es:[di+BUFF_WIDTH+1];
  515.             add ax,bx;
  516.             mov bl,es:[di+BUFF_WIDTH];
  517.             add ax,bx;
  518.             shr ax,2;
  519.             jz jp12;
  520.             dec ax;
  521.             }
  522. jp12:    _asm {
  523.             mov byte ptr es:[di],al;
  524. //            inc di;
  525.             dec di;
  526.             loop jp11;
  527.  
  528.             popa;
  529.         }
  530. }
  531.  
  532. // long flame (with triangle artifacts)
  533. static void flame_rightfast(void)
  534. {
  535.         _asm {
  536.  
  537.             pusha;
  538.  
  539. //            mov cx,16159;
  540. //            mov cx,64636;
  541.             mov cx,64000+BUFF_WIDTH;
  542.             mov dx,SEG buff;
  543.             mov es,dx;
  544.             mov dx,OFFSET buff;
  545. //            mov di,BUFF_WIDTH;
  546.             mov di,64000+BUFF_WIDTH;
  547.             }
  548. jp11:    _asm {
  549.             xor ax,ax;
  550.             xor bx,bx;
  551.             mov al,es:[di];
  552.             mov bl,es:[di+BUFF_WIDTH-1];
  553.             add ax,bx;
  554.             mov bl,es:[di+BUFF_WIDTH-1];
  555.             add ax,bx;
  556.             mov bl,es:[di+BUFF_WIDTH];
  557.             add ax,bx;
  558.             shr ax,2;
  559.             jz jp12;
  560.             dec ax;
  561.             }
  562. jp12:    _asm {
  563.             mov byte ptr es:[di],al;
  564. //            inc di;
  565.             dec di;
  566.             loop jp11;
  567.  
  568.             popa;
  569.         }
  570. }
  571.  
  572.  
  573.  
  574.  
  575. static void flame_leftsubtle(void)
  576. {
  577.         _asm {
  578.             pusha;
  579.  
  580.             mov cx,64636;
  581.             mov dx,SEG buff;
  582.             mov es,dx;
  583.             mov dx,OFFSET buff;
  584.             mov di,BUFF_WIDTH;
  585.             }
  586. jp21:    _asm {
  587.             xor ax,ax;
  588.             mov al,es:[di-(BUFF_WIDTH-1)];
  589.             add al,es:[di];
  590.             add al,es:[di+1];
  591.             add al,es:[di+BUFF_WIDTH];
  592.             shr ax,2;
  593.             jz jp22;
  594.             dec ax;
  595.             }
  596. jp22:    _asm {
  597.             mov byte ptr es:[di-BUFF_WIDTH],al;
  598.             inc di;
  599. //            stosb;
  600.             loop jp21;
  601.  
  602.             popa;
  603.  
  604.     }
  605. }
  606.  
  607. // Flame right
  608. static void flame_rightsubtle(void)
  609. {
  610.         _asm {
  611.             pusha;
  612.  
  613.             mov cx,64636;
  614.             mov dx,SEG buff;
  615.             mov es,dx;
  616.             mov dx,OFFSET buff;
  617.             mov di,BUFF_WIDTH+1;
  618.             }
  619. jp31:    _asm {
  620.             xor ax,ax;
  621.             add al,es:[di-(BUFF_WIDTH+1)];
  622.             add al,es:[di];
  623.             add al,es:[di-1];
  624.             add al,es:[di+BUFF_WIDTH];
  625.             shr ax,2;
  626.             jz jp32;
  627.             dec ax;
  628.             }
  629. jp32:        _asm {
  630.             mov byte ptr es:[di-BUFF_WIDTH],al;
  631.             inc di;
  632.             loop jp31;
  633.  
  634.             popa;
  635.  
  636.     }
  637. }
  638.  
  639. // Flame over water effect
  640. static void flame_watersubtle(void)
  641. {
  642.         _asm {
  643.             pusha;
  644.  
  645.             mov cx,32318+BUFF_WIDTH;
  646.             mov dx,SEG buff;
  647.             mov es,dx;
  648.             mov dx,OFFSET buff;
  649.             mov di,BUFF_WIDTH;
  650.             }
  651. jp41:    _asm {
  652.             xor ax,ax;
  653.             mov al,es:[di-1];
  654.             add al,es:[di];
  655.             add al,es:[di+1];
  656.             add al,es:[di+BUFF_WIDTH];
  657.             }
  658. jp42b:     _asm {
  659.             shr ax,2;
  660.             jz jp42;
  661.             dec ax;
  662.             }
  663. jp42:    _asm {
  664.             mov byte ptr es:[di-BUFF_WIDTH],al;
  665.             inc di;
  666.             loop jp41;
  667.  
  668.             popa;
  669.     }
  670.         _asm {
  671.             pusha;
  672.  
  673.             mov cx,32318;
  674.             mov dx,SEG buff;
  675.             mov es,dx;
  676.             mov dx,OFFSET buff;
  677.             mov di,64636;
  678.             }
  679.  
  680. jpz41:   _asm {
  681.             xor ax,ax;
  682.             mov al,es:[di-(BUFF_WIDTH-1)];
  683.             add al,es:[di];
  684.             add al,es:[di+1];
  685.             add al,es:[di-BUFF_WIDTH];
  686.             shr ax,2;
  687. //            jz jpz42;
  688. //            dec ax;
  689.             }
  690. jpz42:    _asm {
  691.             mov byte ptr es:[di+BUFF_WIDTH],al;
  692.             dec di;
  693.             loop jpz41;
  694.  
  695.             popa;
  696.     }
  697. }
  698.  
  699.  
  700. static void flame_weird(void)
  701. {
  702.         _asm {
  703.             pusha;
  704.  
  705.             mov cx,64636;
  706.             mov dx,SEG buff;
  707.             mov es,dx;
  708.             mov dx,OFFSET buff;
  709.             mov di,BUFF_WIDTH;
  710.             }
  711. jp11:    _asm {
  712.             xor ax,ax;
  713.             mov al,es:[di];
  714.             or al,es:[di-1];
  715.             or al,es:[di+1];
  716.             or al,es:[di+BUFF_WIDTH];
  717.  
  718. //            shr ax,2;
  719.  
  720.             jz jp12;
  721.             dec ax;
  722.  
  723.             }
  724. jp12:    _asm {
  725.             mov byte ptr es:[di-BUFF_WIDTH],al;
  726.             inc di;
  727.             loop jp11;
  728.  
  729.             popa;
  730.  
  731.         }
  732. }
  733.  
  734.  
  735.