Return to sounds.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / demo / pacman

Annotation of researchv9/jtools/src/demo/pacman/sounds.c, revision 1.1.1.1

1.1       root        1: /*----------------------------------------------------------------------*/
                      2: /*                                                                     */
                      3: /*     PACMAN for BBN BitGraphs                                        */
                      4: /*                                                                     */
                      5: /*               File:                                                 */
                      6: /*           Contents:                                                 */
                      7: /*             Author: Bob Brown (rlb)                                 */
                      8: /*                     Purdue CS                                       */
                      9: /*               Date: May, 1982                                       */
                     10: /*        Description:                                                 */
                     11: /*                                                                     */
                     12: /*                                                                     */
                     13: /*                                                                     */
                     14: /*----------------------------------------------------------------------*/
                     15: 
                     16: #include "style.h"
                     17: #include "pacman.h"
                     18: 
                     19: /*
                     20: #define IOADDR(n)      ((char *) (384*1024L+(n<<6)+056))
                     21: char *rport = IOADDR(2);
                     22: char *reg = IOADDR(0);
                     23: char *wport = IOADDR(1);
                     24: */
                     25: 
                     26: int tonegen(), snd_dot();
                     27: 
                     28: int
                     29: sounddot()
                     30: {
                     31:        if ( Silent ) return;
                     32:        snd_dot(NULL,0);
                     33: }
                     34: int
                     35: snd_dot(junk,part)
                     36: char *junk;
                     37: int part;
                     38: {
                     39:        switch(part){
                     40:        case 0:
                     41:                tonegen(1,1200,12);
                     42:                eladd(SNDDOTDELAY,snd_dot,NULL,1);
                     43:                break;
                     44:        case 1:
                     45:                tonegen(1,1000,15);
                     46:                eladd(SNDDOTDELAY,snd_dot,NULL,2);
                     47:                break;
                     48:        case 2:
                     49:                tonegen(1,0);
                     50:        }
                     51: }
                     52: /*
                     53: ** This is the sound when a monster is killed
                     54: */
                     55: #define KILLFROM 200
                     56: #define KILLTO 50
                     57: 
                     58: soundkill()
                     59: {
                     60:        tonegen(1,KILLFROM,13);
                     61:        psgsweep(0,KILLFROM,KILLTO,5);
                     62:        tonegen(1,0,0);
                     63: }
                     64: psgsweep(t,f1,f2,v)
                     65: {
                     66:        int i,f;
                     67:        i = (f1 > f2) ? -1 : 1;
                     68:        for (f = f1; f != f2; f += i) {
                     69:                tonegen(t+1,f,v);
                     70:                sleep(1);
                     71:        }
                     72: }
                     73: int
                     74: tonegen(t,p,v)
                     75: register t,p,v;
                     76: {
                     77: /*
                     78:        char enable = 077;
                     79:        if ( p > 0 ) {
                     80:                enable &= ~(1<<(t-1));
                     81:                psgwrite(p&0xff,(t-1)*2);
                     82:                psgwrite((p>>8),t*2-1);
                     83:                psgwrite(v,7+t);
                     84:                psgwrite(enable,7);
                     85:        } else
                     86:                psgwrite(0,7+t);
                     87: */
                     88: }
                     89: /*
                     90: psgwrite(i,n)
                     91: {
                     92:        *reg = n;
                     93:        *wport = i;
                     94: }
                     95: 
                     96: psgread(n)
                     97: {
                     98:        register i;
                     99:        *reg = n;
                    100:        i = *rport;
                    101:        return (i&0377);
                    102: }
                    103: */
                    104: soundoff()
                    105: {
                    106: /*
                    107:        psgwrite(0,8);
                    108:        psgwrite(0,9);
                    109:        psgwrite(0,10);
                    110: */
                    111: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.