cave.c

game duke3d source

        return;

    if(soundplaying[j].ptr == (char *) NULL)
    {
        getmem(&soundplaying[j].ptr,sounds[sndnum].len);
        iodata(sounds[sndnum].fn,soundplaying[j].ptr,sounds[sndnum].len,IO_LOAD);
    }

    soundplaying[j].sndno = sndnum;
    soundplaying[j].i = i;
}

void pan3dsounds(long i)
{
    long j;

    for(j=0;j<MAXCHANNELS;j++)
        if(soundplaying[j].ptr != (char *) NULL)
    {
        // Pan it here to current player;
    }
}


// Drawing Code

void shiftpalette(char r,char g,char b,long e)
{
    int i;
    char temparray[768];

    toutp(0x3c8,0);

    for(i=0;i<768;i+=3)
    {
        temparray[i+0] =
            palette[i+0]+((((long)r-(long)palette[i+0])*(long)(e&127))>>6);
        temparray[i+1] =
            palette[i+1]+((((long)g-(long)palette[i+1])*(long)(e&127))>>6);
        temparray[i+2] =
            palette[i+2]+((((long)b-(long)palette[i+2])*(long)(e&127))>>6);

        toutp(0x3c9,temparray[i+0]);
        toutp(0x3c9,temparray[i+1]);
        toutp(0x3c9,temparray[i+2]);
    }
}

void fadepalette(char dir,char fspeed)
{
    long i;
    if(dir)
        for(i = 0;i < 63;i += fspeed)
    {
        shiftpalette(0,0,0,i);
        limitrate();
    }
    else
        for(i = 0;i < 63;i += fspeed)
    {
        shiftpalette(0,0,0,63-i);
        limitrate();
    }
}

void light(long x, long y, long z, long myang, long deg, long rad)
{
    long dadist, daplc, daang, dasin, dacos, truex, truey, dashade, anginc;
    unsigned char *mapptr, *didits1, *didits2;

    getmem(&didits1,65536L);
    getmem(&didits2,65536L);

    clearbuf(didits1,16384);
    clearbuf(didits2,16384);

    z >>= 12;

    anginc = 1 + (rad>>4);

    for(daang=myang-deg;daang < myang+deg; daang += anginc )
    {
        dacos = sintable[(daang+512)&2047]>>4;
        dasin = sintable[(daang)&2047]>>4;

        truex = x;
        truey = y;

        for(dadist = 1;dadist < rad; dadist++)
        {
            daplc = ((truex>>10)<<8)+(truey>>10);
            mapptr = &map.h1[daplc];

            if(didits1[daplc] == 0)
            {
                didits1[daplc] = 1;
                dashade = scale(63, dadist + (labs(z - *mapptr)>>1), rad);
                mapptr += (65536L<<2);

                if(dashade < 0) *mapptr = 0;
                else if(dashade < *mapptr) *mapptr = dashade;
                if( z < *(mapptr-(65536L<<2)) ) break;
                mapptr -= (65536L*3);
            }
            else mapptr += 65536L;

            if(didits2[daplc] == 0)
            {
                didits2[daplc] = 1;
                dashade = scale(63, dadist + (labs(z - *mapptr)>>1), rad);
                mapptr += (65536L<<2);

                if(dashade < 0) *mapptr = 0;
                else if(dashade < *mapptr) *mapptr = dashade;
                if( z > *(mapptr-(65536L<<2)) ) break;
            }

            truex += dacos;
            truey += dasin;
        }
    }

    freemem(&didits2);
    freemem(&didits1);

}

void blast(long gridx, long gridy, long rad, char blastingcol)
{
    short tempshort;
    long i, j, dax, day, daz, dasqr, templong;

    templong = rad+2;
    for(i=-templong;i<=templong;i++)
        for(j=-templong;j<=templong;j++)
        {
            dax = ((gridx+i+256)&255);
            day = ((gridy+j+256)&255);

            if(dax < 1 || dax > 255 || day < 1 || day > 255)
                continue;

            dasqr = sqr(rad)-(sqr(i)+sqr(j));

            if (dasqr >= 0)
                daz = tsqrt(dasqr)<<1;
            else
                daz = -tsqrt(-dasqr)<<1;

            if ((self[screenpeek].posz>>12)-daz < map.h1[(dax<<8)+day])
            {
                map.h1[(dax<<8)+day] = (self[screenpeek].posz>>12)-daz;
                if (((self[screenpeek].posz>>12)-daz) < 0)
                    map.h1[(dax<<8)+day] = 0;
            }

            if ((self[screenpeek].posz>>12)+daz > map.h2[(dax<<8)+day])
            {
                map.h2[(dax<<8)+day] = (self[screenpeek].posz>>12)+daz;
                if (((self[screenpeek].posz>>12)+daz) > 255)
                    map.h2[(dax<<8)+day] = 255;
            }

/*            tempshort = map.h1[(dax<<8)+day];
            if (tempshort >= map.h2[(dax<<8)+day]) tempshort = (self[screenpeek].posz>>12);
            tempshort = labs(64-(tempshort&127))+(rand()&3)-2;
            if (tempshort < 0) tempshort = 0;
            if (tempshort > 63) tempshort = 63;
            map.c1[(dax<<8)+day] = (char)(tempshort+blastingcol);

            tempshort = map.h2[(dax<<8)+day];
            if (tempshort <= map.h1[(dax<<8)+day]) tempshort = (self[screenpeek].posz>>12);
            tempshort = labs(64-(tempshort&127))+(rand()&3)-2;
            if (tempshort < 0) tempshort = 0;
            if (tempshort > 63) tempshort = 63;
            map.c2[(dax<<8)+day] = (char)(tempshort+blastingcol);
*/

        }
}

void grouvline (long x)
{
    long dist[2], dinc[2], incr[2];
    short grid[2], dir[2];
    unsigned char *mapptr;

    char oh1, oh2;
    short um, dm, h, i, horiz;
    long plc1, plc2, cosval, sinval;
    long snx, sny, dax, c, shade, cnt;
    long posx, posy, posz, posa;

    plc1 = (x>>2) + FP_OFF(scrbuf);
    plc2 = plc1 + muly80[ (ydim-1) ];

    switch(pixs)
    {
        case 1:
            if ((x&2) > 0)
            {
                plc1 += 32000<<vidmode;
                plc2 += 32000<<vidmode;
            }
            if ((x&1) > 0)
            {
                plc1 += 16000<<vidmode;
                plc2 += 16000<<vidmode;
            }
            break;
        case 2:
            if ((x&2) > 0)
            {
                plc1 += 16000<<vidmode;
                plc2 += 16000<<vidmode;
            }
            break;
    }

    posx = self[screenpeek].posx;
    posy = self[screenpeek].posy;
    posz = self[screenpeek].posz;
    posa = self[screenpeek].ang;
    horiz = self[screenpeek].horiz;

    cosval = sintable[(posa+2560)&2047];
    sinval = sintable[(posa+2048)&2047];

    dax = (x<<1) + (pixs-1) - xdim;

    incr[0] = cosval - scale(sinval,dax,xdim);
    incr[1] = sinval + scale(cosval,dax,xdim);

    if (incr[0] < 0) dir[0] = -1, incr[0] = -incr[0]; else dir[0] = 1;
    if (incr[1] < 0) dir[1] = -1, incr[1] = -incr[1]; else dir[1] = 1;
    snx = (posx&1023); if (dir[0] == 1) snx ^= 1023;
    sny = (posy&1023); if (dir[1] == 1) sny ^= 1023;
    cnt = ((snx*incr[1] - sny*incr[0])>>10);

    grid[0] = ((posx>>10)&255); grid[1] = ((posy>>10)&255);

    if (incr[0] != 0)
    {
        dinc[0] = divscale(65536>>vidmode,incr[0],12);
        dist[0] = mulscale(dinc[0],snx,10);
    }
    if (incr[1] != 0)
    {
        dinc[1] = divscale(65536>>vidmode,incr[1],12);
        dist[1] = mulscale(dinc[1],sny,10);
    }

    um = (0)-horiz;
    dm = (ydim-1)-horiz;

    i = incr[0]; incr[0] = incr[1]; incr[1] = -i;

    shade = 0;
    while (dist[cnt>=0] < 8192)
    {
        i = (cnt>=0);

        grid[i] = ((grid[i]+dir[i])&255);
        dist[i] += dinc[i];
        cnt += incr[i];
        shade++;
    }

    mapptr = &map.h1[(grid[0]<<8)+grid[1]];

    while (shade < 256)
    {
        i = (cnt>=0);
        oh1 = *mapptr;
        oh2 = *(mapptr+65536);

        h = groudiv((long)oh1,dist[i],posz);
        if (um <= h)
        {
            c = (shade>>2) + *(mapptr + (65536<<2)); // map.s1[bufplc];
            if(c > 63) c = 63;
            c = palookup[c][*(mapptr + (65536<<1))]; // map.c1[bufplc]
            if (h > dm) break;
            plc1 = drawtopslab(plc1,h-um+1,c);
            um = h+1;
        }

        h = groudiv((long)oh2,dist[i],posz);
        if (dm >= h)
        {
            c = (shade>>2) + *(mapptr + (65536*5)); // map.s2[bufplc];
            if(c > 63) c = 63;
            c = palookup[c][*(mapptr + (65536*3))]; // map.c2[bufplc]
            if (h < um) break;
            plc2 = drawbotslab(plc2,dm-h+1,c);
            dm = h-1;
        }

        grid[i] = ((grid[i]+dir[i])&255);
        mapptr = &map.h1[(grid[0]<<8)+grid[1]];

        if (*mapptr > oh1) // map.h1[bufplc]
        {
            h = groudiv((long)*mapptr,dist[i],posz); // map.h1[bufplc]

            if (um <= h)
            {
                c = (shade>>2) + *(mapptr + (65536<<2)); // map.s1[bufplc];
                if(c > 63) c = 63;
                c = palookup[c][*(mapptr + (65536<<1))]; // map.c1[bufplc]
                if (h > dm) break;
                plc1 = drawtopslab(plc1,h-um+1,c);
                um = h+1;
            }
        }


        if (*(mapptr + 65536) < oh2) // map.h2[bufplc]
        {
            h = groudiv((long)*(mapptr + 65536),dist[i],posz); // map.h2[bufplc]
            if (dm >= h)
            {
                c = (shade>>2) + *(mapptr + (65536*5)); // map.s2[bufplc];
                if(c > 63) c = 63;
                c = palookup[c][*(mapptr + (65536*3))]; // map.c2[bufplc]
                if (h < um) break;
                plc2 = drawbotslab(plc2,dm-h+1,c);
                dm = h-1;
            }
        }

        dist[i] += dinc[i];
        cnt += incr[i];
        shade++;
    }

    if (dm >= um)
    {
        if (shade >= 256) c = 0;
        drawtopslab(plc1,dm-um+1,c);
    }
}


void drawobject(long thex, long they, long thez, char *tileptr,char shade)
{
    long x, y, x1, y1, x2, y2, dasizx, dasizy, xscale, yscale;
    char *p;

    dasizx = *(tileptr++);
    dasizy = *(tileptr++);

	x1 = thex;
	y1 = they;
    x2 = x1 + dasizx;
    y2 = y1 + dasizy;

    if ((x2 >= xdim) || (x2 < 0) || (x1 >= xdim) || (y2 < 0) || (y1 >= ydim))
        return;

    if(thez > (65536L<<1)) return;
//    else if(thez > 256)
//    {
  //      xscale = 1 + mulscale(dasizx,thez,18);
    //    yscale = 1 + mulscale(dasizy,thez,18);
//    }
//    else

    xscale = yscale = 1;

    p = scrbuf + muly80[y1];

    switch(pixs)
    {
        case 1:
            for(y=y1;y<y2;y++)
            {
                for(x=x1;x<x2;x+=xscale)
                {
                    if(*tileptr < 255)
                        *(p + (mul16000[(x&3)]<<vidmode) + (x>>2)) =
                            *tileptr;
                    tileptr += xscale;
                }
                p += 80;
            }
            break;
        case 2:
            for(y=y1;y<y2;y++)
            {
                for(x=x1;x<x2;x+=(xscale<<1))
                {
                    if(*tileptr < 255)
                        *(p + (mul16000[(x>>1)&1]<<vidmode) + (x>>2)) =
                            *tileptr;
                    tileptr += (xscale<<1);
                }
                tileptr += (x-x2)*(xscale<<1);
                p += 80;
            }
            break;

        case 4:
            for(y=y1;y<y2;y++)
            {
                for(x=x1;x<x2;x+=(xscale<<2))
                {
                    if(*tileptr < 255)
                        *(p + (x>>2) ) = palookup[shade][*tileptr];
                    tileptr += (xscale<<2);
                }
                tileptr += (x-x2)*(xscale<<2);
                p += 80;
            }
            break;
    }
}

void sortobjectstoview(void)
{
    long tempx, tempy, dadist, posx, posy;
    short i, j, daang, daangdif;
    viewobjecttype tempviewobject;

    daang = self[screenpeek].ang;
    posx = self[screenpeek].posx;
    posy = self[screenpeek].posy;

    viewobjectcnt = 0;

    for(j=0;j<MAXSTATUS;j++)
        for(i = map.headobject[j];i>=0;i=map.nextobject[i])
    {
        daangdif = angdif(daang,getangle(object[i].x-posx,object[i].y-posy));
        if( labs(daangdif) < (256) )
        {
            dadist = mulscale(object[i].x-posx,\
                sintable[(-daang+2560)&2047],14)-mulscale(object[i].y-posy,\
                sintable[(-daang+2048)&2047],14);

            if( dadist > 0xff ) // && dadist < 0x18000)
            {
                scrnobj[viewobjectcnt].viewobject = i;
                scrnobj[viewobjectcnt].viewobjectdist = dadist;
                scrnobj[viewobjectcnt].viewobjectang = daangdif;
                viewobjectcnt++;
            }
        }
    }

    // Bubble sort by z (furthest to closest)

    for(i=0;i<(viewobjectcnt-1);i++)
        for(j = (i+1);j<viewobjectcnt; j++)
            if(scrnobj[j].viewobjectdist > scrnobj[i].viewobjectdist)
        {
            copybytes(&scrnobj[i],     &tempviewobject, sizeof(viewobjecttype));
            copybytes(&scrnobj[j],     &scrnobj[i],     sizeof(viewobjecttype));
            copybytes(&tempviewobject, &scrnobj[j],     sizeof(viewobjecttype));
        }
}

void animateobjects(void)
{
    long i, j;

    if(self[screenpeek].flashlight)
        light(
            self[screenpeek].posx,
            self[screenpeek].posy,
            self[screenpeek].posz,
            self[screenpeek].ang,
            128,
            96);

    for(i=0;i<viewobjectcnt;i++)
    {
        j = scrnobj[i].viewobject;
        light(
           object[j].x,
           object[j].y,
           object[j].z,
           0,
           1024,
           96);
    }
}

void drawallobjects(void)
{
    long i, j, posx, posy, posz, horiz;
    long scrnx, scrny;

    posx = self[screenpeek].posx;
    posy = self[screenpeek].posy;
    posz = self[screenpeek].posz;
    horiz = self[screenpeek].horiz;

    for(j=0;j<viewobjectcnt;j++)
    {
        i = scrnobj[j].viewobject;

        scrnx = mulscale(MAXXDIM,256+scrnobj[j].viewobjectang,9);
        scrny = scale( object[i].z-posz, 32, scrnobj[j].viewobjectdist);

        drawobject(scrnx,horiz + scrny,scrnobj[j].viewobjectdist,atile,scrnobj[j].viewobjectdist>>10);
    }
}


void drawmap(void)
{
    long i, j;

    if(self[screenpeek].topdown == 0)
    {
        for(i=0;i<MAXXDIM;i+=pixs)
            grouvline(i);

        drawallobjects();
    }
    else
        clearbuf(scrbuf,16000,0xffffffff);

}

void nextpage(void)
{
    if (vidmode == 0)                            //Copy to screen
    {
        if (pixs == 4) showscreen4pix320200();