home *** CD-ROM | disk | FTP | other *** search
/ Groovy Bytes: Behind the Moon / groovybytes.iso / GROOVY / DEMOS / MISC_DEM / SUNKNOWN.ZIP / FLAMSCRL.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-07  |  11.9 KB  |  696 lines
  1. // FLAMSCRL /////////////////////////////////////////////////////////////////
  2.  
  3. // Andreas 0.
  4.  
  5. // INCLUDES /////////////////////////////////////////////////////////////////
  6.  
  7. #include <string.h>
  8. #include <fstream.h>
  9. #include <conio.h>
  10. #include <stdlib.h>
  11. #include <dos.h>
  12. #include <stdio.h>
  13.  
  14. #include "seg.h"
  15. #include "xgraf.h"
  16. #include "timer.h"
  17.  
  18. // DEFINES //////////////////////////////////////////////////////////////////
  19.  
  20. #define MINSPEED 150
  21. #define ABSMIN     90
  22. #define WIDTH 40
  23. #define HEIGHT 100
  24. #define SCREEN 88
  25. #define PAGEBASE (2*16000)
  26. #define FLAME 1
  27. #define FONTPOS (WIDTH*(HEIGHT+10))
  28. #define MASKPOS (WIDTH*(HEIGHT+10)+8200)
  29. #define LETTERSTART 4
  30. #define FLAMSTART 0
  31. #define FLAMEND   4
  32. #define MOVSB mov al,[si]; asm mov es:[di],al; asm inc si; asm inc di
  33.  
  34. // EXTERNALS ////////////////////////////////////////////////////////////////
  35.  
  36. // FUNCTIONS
  37.  
  38. extern "C" void movef32(void);
  39. extern "C" void smidigo(void);
  40.  
  41. // VARS
  42.  
  43. extern byte rgb[768],
  44.        *pressed,
  45.        callmidi,
  46.        guson;
  47. extern int relspeed;
  48. extern timer_C timer;
  49.  
  50. // PROTOTYPES ///////////////////////////////////////////////////////////////
  51.  
  52. void compilemask(byte *stripe,byte *res);
  53. void setpalette(void);
  54. void xoffset(word xoff);
  55. void setlogwidth(word w);
  56. void fade(byte *plt);
  57.  
  58. // FUNCTIONS ////////////////////////////////////////////////////////////////
  59.  
  60. // FLAMSCRL
  61.  
  62. void flamscrl(void)
  63. {
  64.     char text[]=" WELCOME TO THE SUPERUNKNOWN    ";
  65.   int tempdi,
  66.       tempax,
  67.       tempbx,
  68.       tempcx,
  69.       tempdx,
  70.       tempsi;
  71.     byte tempch,
  72.          fadepal[64*3],
  73.        size=0,
  74.        doit=1,
  75.        dec_it=0,
  76.        bokstavnr=0,
  77.        blockpos=0,
  78.        maskpos=0,
  79.        index=0,
  80.        blapal[768],
  81.        randtab[256],
  82.        frame_byte=0;
  83.     word startframe=10,
  84.        aa=0,
  85.        pb=0,
  86.        bokstavln=0,
  87.        adr=0,
  88.        frames=0;
  89.     int x,
  90.       y,
  91.       delta;
  92.  
  93.     for(x=0;x<256;x++)
  94.         randtab[x]=random(2)*16+48;
  95.  
  96.     seg_C flammeseg;
  97.     byte *flamme=flammeseg.ptr;
  98.     long p_P= (long) flamme;
  99.  
  100.     seg_C dataseg;
  101.     byte *data=dataseg.ptr;
  102.     long data_P= (long) data;
  103.  
  104.     seg_C lineseg(20);
  105.     byte *linja=lineseg.ptr;
  106.  
  107.     word b;
  108.         for(b=0;b<65535;b++)
  109.         flamme[b]=0;
  110.  
  111.     FILE *brixfil = fopen(BRIXFILE, "rb" );
  112.  
  113.     byte cc;
  114.     for(int yy=0;yy<16*14;yy++)
  115.     for(int xx=0;xx<16;xx++)
  116.     {
  117.         fread(&cc,1,1,brixfil);
  118.         data[adr]=cc;
  119.         adr++;
  120.     }
  121.     fclose(brixfil);
  122.  
  123.     FILE *palfil = fopen(FLAMEPAL,"rb");
  124.     fread(&rgb,1,32,palfil);
  125.     fread(&rgb,1,768,palfil);
  126.     fclose(palfil);
  127.  
  128.     for(x=0;x<768;x++) rgb[x]>>=2;
  129.  
  130.     adr=WIDTH*(HEIGHT+10);
  131.  
  132.     FILE *maskfil = fopen(MASKFILE,"rb");
  133.  
  134.     for(yy=0;yy<15*28;yy++)
  135.     for(int xx=0;xx<19;xx++)
  136.     {
  137.         fread(&cc,1,1,maskfil);
  138.         if (xx<16 && xx)
  139.     {
  140.             flamme[adr]=cc;
  141.             data[adr]=cc;
  142.             adr++;
  143.         }
  144.     }
  145.     fclose(maskfil);
  146.  
  147.     outport(SC_INDEX,0x0f02);
  148.     frame();
  149.  
  150.     asm mov ax,0xa000
  151.     asm mov es,ax
  152.     asm xor ax,ax
  153.     asm xor di,di
  154.     asm mov cx,32768
  155.     asm rep stosb
  156.     asm mov cx,32768
  157.     asm rep stosb
  158.  
  159.     setlogwidth(320+32);
  160.     setpalette();
  161.  
  162.     seg_C rleseg(35);
  163.     byte *rle = rleseg.ptr;
  164.  
  165.     rle[0]=0;
  166.     rle[1]=0;
  167.   rle[2]=0;
  168.     rle[3]=16;
  169.     rle[4]=0;
  170.     rle[6]=0;
  171.   rle[5]=3*SCREEN;
  172.     rle[7]=2*16;
  173.     rle[8]=64;
  174.  
  175.     for(x=0;x<80;x++)
  176.     for(y=0;y<31;y++)
  177.         flamme[MASKPOS+y+x*31]=rle[y];
  178.  
  179.     while (text[size]!='\0')
  180.     {
  181.         if (text[size]==' ') text[size]='@';
  182.         size++;
  183.     }
  184.  
  185.   while(bokstavnr<size-1)
  186.   {
  187.       frames++;
  188.       frame_byte+=17;
  189.       pb^=PAGEBASE;
  190.  
  191.         doit^=1;
  192.         if(doit)
  193.         {
  194.             dec_it^=1;
  195.  
  196.             asm mov bh,dec_it
  197.             asm push ds
  198.             asm mov cx,((HEIGHT)+2)*WIDTH
  199.             asm lds di,p_P
  200.             asm add di,WIDTH
  201. D1:
  202.             asm mov ax,[di]
  203.             asm add ah,al
  204.             asm mov al,ah
  205.             asm add ah,[di-1]
  206.             asm add ah,[di+WIDTH]
  207.             asm jz alla
  208.             asm sub ah,bh
  209.             asm shr ah,2
  210. alla:
  211.             asm xor bh,1
  212.             asm add al,[di+2]
  213.             asm add al,[di+WIDTH+1]
  214.             asm jz ahla
  215.             asm sub al,bh
  216.             asm shr al,2
  217. ahla:
  218.             asm cmp al,64
  219.             asm ja al_over
  220.             asm jmp check_ah
  221. al_over:
  222.             asm mov al,63
  223. check_ah:
  224.             asm cmp ah,64
  225.             asm ja ah_over
  226.             asm jmp D2
  227. ah_over:
  228.             asm mov ah,63
  229. D2:
  230.             asm xchg al,ah
  231.             asm mov [di-WIDTH],ax
  232.  
  233.             asm add di,2
  234.             asm sub cx,2
  235.             asm jz D3
  236.             asm jmp D1
  237. D3:
  238.             asm pop ds
  239.  
  240.             for(int j=0;j<WIDTH/2+1;j++)
  241.             {
  242.                 asm mov ax,j
  243.                 asm add al,frame_byte
  244.                 asm mov index,al
  245.                 if(frames>startframe && bokstavnr<(size-7))
  246.                     delta=randtab[index];
  247.                 else
  248.                     delta=0;
  249.  
  250.                 flamme[(HEIGHT+1)*WIDTH+(j<<1)+1]=delta;
  251.                 flamme[(HEIGHT+1)*WIDTH+(j<<1)]  =delta;
  252.             }
  253.         }
  254.  
  255.  
  256.       blockpos=aa%4;
  257.  
  258.       if(!blockpos)
  259.       {
  260.           bokstavln++;
  261.           bokstavln%=15;
  262.  
  263.           if(!bokstavln)
  264.           {
  265.               bokstavnr++;
  266.               bokstavnr%=size;
  267.           }
  268.           bokstavln+=(text[bokstavnr]-64)*15l;
  269.       }
  270.  
  271.       if(!(blockpos))
  272.       {
  273.           maskpos++;
  274.           maskpos%=15;
  275.           adr=maskpos*15l+((text[bokstavnr]-64)*15*15);
  276.           if (!adr)
  277.         adr=15;
  278.           for(y=0;y<12;y++)
  279.           linja[y]=flamme[FONTPOS+adr+y+3-15];
  280.           compilemask(linja,rle);
  281.       }
  282.  
  283.       for(y=0;y<31;y++)
  284.       {
  285.           flamme[MASKPOS+y+81*31]=rle[y];
  286.           flamme[MASKPOS+y+80*31]=rle[y];
  287.       }
  288.  
  289.  
  290.       asm pusha
  291.       asm push ds
  292.  
  293.       asm lds si,flamme
  294.       asm add si,MASKPOS
  295.       movef32(); // From ASMZOOM.ASM
  296.  
  297.       asm pop ds
  298.       asm popa
  299.  
  300.  
  301.       callmidi=0;
  302.       if (guson)
  303.           smidigo();
  304.       frame();
  305.       callmidi=guson;
  306.  
  307.       byte startplan=0;
  308.       byte sluttplan=1;
  309.       byte span=3;
  310.  
  311.       for(byte plan=startplan; plan<=sluttplan; plan++)
  312.       {
  313.           byte ahmask=span<<(plan*2);
  314.           for(byte start=FLAMSTART;start<FLAMEND;start++)
  315.           {
  316.             int retn = 2-4*(start&1);
  317.             int plussi=plan*(retn/2)+(WIDTH-1)*(start&1);
  318.  
  319.               asm mov di,aa
  320.               asm add di,2
  321.               asm add di,pb
  322.               asm add di,SCREEN*240-SCREEN*HEIGHT*2
  323.               asm xor ax,ax
  324.               asm mov al,start
  325.               asm mov bl,WIDTH/2
  326.               asm mul bl
  327.               asm add di,ax
  328.  
  329.               asm mov tempdi,di
  330.               asm mov ax,0xa000
  331.               asm mov es,ax
  332.               asm pusha
  333.               asm push ds
  334.               asm lds si,p_P
  335.               asm mov bx,si
  336.               asm add bx,MASKPOS
  337.  
  338.               asm add si,plussi
  339.               asm xor ah,ah
  340.               asm mov al,start
  341.               asm mov dx,31*WIDTH/2
  342.               asm mul dx
  343.               asm add bx,ax
  344.  
  345.               asm mov al,2
  346.               asm mov ah,ahmask
  347.               asm mov dx,SC_INDEX
  348.               asm out dx,ax
  349.               asm mov dh,WIDTH/2
  350.               asm mov tempch,ch
  351.               asm cld
  352.  
  353. s_newline:
  354.               asm mov ch,[bx]
  355.               asm or ch,ch
  356.               asm jnz okay
  357.               asm add di,1
  358.               asm add si,retn
  359.               asm add bx,31
  360.               asm dec dh
  361.               asm jz nomore
  362.               asm jmp s_newline
  363. okay:
  364.               asm mov tempbx,bx
  365.               asm inc bx
  366.               asm mov tempdi,di
  367.               asm mov tempsi,si
  368. s_newmask:
  369.               asm mov ax,[bx]
  370.               asm add di,ax
  371.               asm add bx,2
  372.               asm mov ax,[bx]
  373.               asm shr ax,1
  374.               asm add si,ax
  375.               asm add bx,2
  376.               asm mov cl,[bx]
  377.               asm inc bx
  378.               asm mov al,[bx]
  379.               asm inc bx
  380. s_newpix:
  381.               asm mov ah,[si]
  382.               asm add si,WIDTH
  383.               asm or ah,al
  384.               asm mov es:[di],ah
  385.               asm add di,SCREEN
  386.               asm mov es:[di],ah
  387.               asm add di,SCREEN
  388.               asm dec cl
  389.               asm jnz s_newpix
  390.               asm dec ch
  391.               asm jnz s_newmask
  392.               asm mov bx,tempbx
  393.               asm add bx,31
  394.               asm mov si,tempsi
  395.               asm add si,retn
  396.               asm mov di,tempdi
  397.               asm inc di
  398.               asm dec dh
  399.               asm jnz s_newline
  400. nomore:
  401.               asm pop ds
  402.               asm popa
  403.           }
  404.       }
  405.  
  406.       if((blockpos<2))
  407.       {
  408.           word tempsomething;
  409.           asm mov ax,15
  410.           asm mov bx,bokstavln
  411.           asm mul bx
  412.           asm push ds
  413.           asm lds si,data_P
  414.           asm mov tempsomething,ax
  415.           asm mov di,SCREEN-LETTERSTART
  416.           asm add di,aa
  417.           asm add di,pb
  418.           asm mov ax,0xa000
  419.           asm mov es,ax
  420.           asm mov ax,0x0102
  421.           asm mov dx,SC_INDEX
  422.           asm mov cl,0
  423. new_mask:
  424.           asm mov dx,SC_INDEX
  425.           asm mov al,02
  426.           asm out dx,ax
  427. b0:
  428.           asm mov ch,0
  429. b1:
  430.           asm mov dl,16
  431.           asm mov bx,WIDTH*(HEIGHT+10)
  432.           asm add bl,ch
  433.           asm add bx,tempsomething
  434.           asm mov si,bx
  435.           asm mov dh,[si]
  436.           asm cmp dh,'.'
  437.           asm jne b1_1
  438.           asm mov dh,0xc
  439.           asm jmp b2
  440. b1_1:
  441.           asm cmp dh,' '
  442.           asm jne b1_2
  443.           asm mov dh,0xd
  444.           asm jmp b2
  445. b1_2:
  446.           asm sub dh,49
  447.           asm cmp dh,10
  448.           asm jb  b2
  449.           asm sub dh,7
  450. b2:
  451.           asm mov bl,dh
  452.           asm xor bh,bh
  453.           asm shl bx,8
  454.           asm add bl,cl
  455.           asm mov si,bx
  456. new_b_pix:
  457.           asm MOVSB
  458.           asm add si,3
  459.           asm MOVSB
  460.           asm add si,3
  461.           asm MOVSB
  462.           asm add si,3
  463.           asm MOVSB
  464.           asm add si,3
  465.           asm add di,SCREEN-4
  466.           asm dec dl
  467.           asm jnz new_b_pix
  468.           asm inc ch
  469.           asm cmp ch,15
  470.           asm jne b1
  471.           asm cmp ah,8
  472.           asm je nomore2
  473.           asm sub di,SCREEN*240
  474.           asm shl ah,1
  475.           asm inc cl
  476.           asm jmp new_mask
  477. nomore2:
  478.           asm pop ds
  479.  
  480.           pb^=PAGEBASE;
  481.  
  482.           asm mov ax,15
  483.           asm mov bx,bokstavln
  484.           asm mul bx
  485.           asm push ds
  486.           asm lds si,data_P
  487.           asm mov tempsomething,ax
  488.           asm mov di,SCREEN-LETTERSTART
  489.           asm add di,aa
  490.           asm add di,pb
  491.           asm mov ax,0xa000
  492.           asm mov es,ax
  493.           asm mov ax,0x0102
  494.           asm mov dx,SC_INDEX
  495.           asm mov cl,0
  496. new_mask2:
  497.           asm mov dx,SC_INDEX
  498.           asm mov al,02
  499.           asm out dx,ax
  500. b02:
  501.           asm mov ch,0
  502. b12:
  503.           asm mov dl,16
  504.           asm mov bx,WIDTH*(HEIGHT+10)
  505.           asm add bl,ch
  506.           asm add bx,tempsomething
  507.           asm mov si,bx
  508.           asm mov dh,[si]
  509.           asm cmp dh,'.'
  510.           asm jne b1_12
  511.           asm mov dh,0xc
  512.           asm jmp b22
  513. b1_12:
  514.           asm cmp dh,' '
  515.           asm jne b1_22
  516.           asm mov dh,0xd
  517.           asm jmp b22
  518. b1_22:
  519.           asm sub dh,49
  520.           asm cmp dh,10
  521.           asm jb  b22
  522.           asm sub dh,7
  523. b22:
  524.           asm mov bl,dh
  525.           asm xor bh,bh
  526.           asm shl bx,8
  527.           asm add bl,cl
  528.           asm mov si,bx
  529. new_b_pix2:
  530.           asm MOVSB
  531.           asm add si,3
  532.           asm MOVSB
  533.           asm add si,3
  534.           asm MOVSB
  535.           asm add si,3
  536.           asm MOVSB
  537.           asm add si,3
  538.           asm add di,SCREEN-4
  539.           asm dec dl
  540.           asm jnz new_b_pix2
  541.           asm inc ch
  542.           asm cmp ch,15
  543.           asm jne b12
  544.           asm cmp ah,8
  545.           asm je nomore22
  546.           asm sub di,SCREEN*240
  547.           asm shl ah,1
  548.           asm inc cl
  549.           asm jmp new_mask2
  550. nomore22:
  551.           asm pop ds
  552.  
  553.           pb^=PAGEBASE;
  554.       }
  555.  
  556.       aa++;
  557.       aa++;
  558.       b++;
  559.       b%=(256/4);
  560.       xoffset(aa+pb);
  561.   }
  562.  
  563. thend:
  564.     outport(SC_INDEX,0x0f02);
  565.     frame();
  566.  
  567.     asm mov ax,0xa000
  568.     asm mov es,ax
  569.     asm xor ax,ax
  570.     asm xor di,di
  571.     asm mov cx,32768
  572.     asm rep stosb
  573.     asm mov cx,32768
  574.     asm rep stosb
  575.  
  576.     setlogwidth(320);
  577.     xoffset(0);
  578. }
  579.  
  580. // SETPALETTE
  581.  
  582. void setpalette()
  583. {
  584.   int  i;
  585.  
  586.   _SI = (word)&rgb[0];
  587.   asm mov cx,768
  588.   asm mov dx,0x03c8
  589.   asm xor al,al
  590.   asm out dx,al
  591.   asm inc dx
  592. l1:
  593.   asm outsb
  594.   asm dec cx
  595.   asm jnz l1
  596. }
  597.  
  598. // XOFFSET
  599.  
  600. void xoffset(word xoff)
  601. {
  602.     asm mov ax,xoff
  603.     asm mov bh,al
  604.     asm mov ch,ah
  605.     asm mov bl,0x0d
  606.     asm mov cl,0x0c
  607.     asm mov ah,8
  608.     asm mov dx,CRTC_INDEX
  609.     asm mov ax,bx
  610.     asm cli
  611.     asm out dx,ax
  612.     asm mov ax,cx
  613.     asm out dx,ax
  614.     asm sti
  615. }
  616.  
  617. // SETLOGWIDTH
  618.  
  619. void setlogwidth(word w)
  620. {
  621.     asm    mov   cx,w
  622.     asm    mov   dx,CRTC_INDEX
  623.     asm    mov   al,0x13
  624.     asm    out   dx,al
  625.     asm    inc   dx
  626.     asm    mov   ax,cx
  627.     asm    shr   ax,3
  628.     asm    out   dx,al
  629. }
  630.  
  631. // STRIPTYPE
  632.  
  633. byte striptype(byte in)
  634. {
  635.     if (in=='.')
  636.         return 64;
  637.     if (in==' ')
  638.         return 0;
  639.     return 255;
  640. }
  641.  
  642. // COMPILEMASK
  643.  
  644. void compilemask(byte *stripe,byte *res)
  645. {
  646.     byte here;
  647.     int treff=0;
  648.     word last_one=0;
  649.     word last_onef=0;
  650.     for (int scan=0; scan<12; scan++)
  651.     {
  652.         here=striptype(stripe[scan]);
  653.         if (relspeed<ABSMIN)
  654.             here=255;
  655.         if (here<255 && (here || relspeed>MINSPEED))
  656.         {
  657.             word adr=SCREEN*16*(scan)+SCREEN*8;
  658.             word adrf=WIDTH*16*(scan)+WIDTH*8;
  659.             res[1+treff*6]=(adr-last_one);
  660.             res[2+treff*6]=(adr-last_one)>>8;
  661.             res[3+treff*6]=(adrf-last_onef);
  662.             res[4+treff*6]=(adrf-last_onef)>>8;
  663.             byte len=0;
  664.             while (striptype(stripe[scan])==here && scan<12)
  665.             {
  666.                 len++;
  667.                 scan++;
  668.             }
  669.             res[5+treff*6]=len*8;
  670.             res[6+(treff++)*6]=here;
  671.             last_one=adr+SCREEN*len*16;
  672.             last_onef=adrf+WIDTH*len*16;
  673.         }
  674.     }
  675.     res[0]=treff;
  676. }
  677.  
  678. // FADE
  679.  
  680. void fade(byte *plt)
  681. {
  682.   _SI = (word) &plt[0];
  683.  
  684.   asm mov cx,64*3
  685.   asm mov dx,0x03c8
  686.   asm mov al,64
  687.   asm xor ah,ah
  688.   asm out dx,al
  689.   asm inc dx
  690. l1:
  691.   asm outsb
  692.   asm dec cx
  693.   asm jnz l1
  694. }
  695.  
  696.