build.c

小型游戏引擎

	sprintf(snotbuf,"Tile number: %d",sprite[spritenum].picnum);
	statusbar_printext16(200,88,11,-1,snotbuf,0);

	sprintf(snotbuf,"Angle (2048 degrees): %d",sprite[spritenum].ang);
	statusbar_printext16(400,48,11,-1,snotbuf,0);
	sprintf(snotbuf,"X-Velocity: %d",sprite[spritenum].xvel);
	statusbar_printext16(400,56,11,-1,snotbuf,0);
	sprintf(snotbuf,"Y-Velocity: %d",sprite[spritenum].yvel);
	statusbar_printext16(400,64,11,-1,snotbuf,0);
	sprintf(snotbuf,"Z-Velocity: %d",sprite[spritenum].zvel);
	statusbar_printext16(400,72,11,-1,snotbuf,0);
	sprintf(snotbuf,"Owner: %d",sprite[spritenum].owner);
	statusbar_printext16(400,80,11,-1,snotbuf,0);
	sprintf(snotbuf,"Clipdist: %d",sprite[spritenum].clipdist);
	statusbar_printext16(400,88,11,-1,snotbuf,0);
	sprintf(snotbuf,"Extra: %d",sprite[spritenum].extra);
	statusbar_printext16(400,96,11,-1,snotbuf,0);
}


	/* Find closest point (*dax, *day) on wall (dawall) to (x, y) */
void getclosestpointonwall(long x, long y, long dawall, long *nx, long *ny)
{
	walltype *wal;
	long i, j, dx, dy;

	wal = &wall[dawall];
	dx = wall[wal->point2].x-wal->x;
	dy = wall[wal->point2].y-wal->y;
	i = dx*(x-wal->x) + dy*(y-wal->y);
	if (i <= 0) { *nx = wal->x; *ny = wal->y; return; }
	j = dx*dx+dy*dy;
	if (i >= j) { *nx = wal->x+dx; *ny = wal->y+dy; return; }
	i = divscale30(i,j);
	*nx = wal->x + mulscale30(dx,i);
	*ny = wal->y + mulscale30(dy,i);
}


int drawtilescreen(long pictopleft, long picbox)
{
	long i, j, vidpos, vidpos2, wallnum, xdime, ydime, cnt, pinc;
	long dax, day, scaledown, xtiles, ytiles, tottiles;
	char *picptr, snotbuf[80];

	xtiles = (xdim>>6); ytiles = (ydim>>6); tottiles = xtiles*ytiles;

	pinc = ylookup[1];
	clearview(0L);
	for(cnt=0;cnt<(tottiles<<(gettilezoom<<1));cnt++)         /* draw the 5*3 grid of tiles */
	{
		wallnum = cnt+pictopleft;
		if (wallnum < localartlookupnum)
		{
			wallnum = localartlookup[wallnum];
			if ((tilesizx[wallnum] != 0) && (tilesizy[wallnum] != 0))
			{
				if (waloff[wallnum] == 0) loadtile(wallnum);
				picptr = (char *)(waloff[wallnum]);
				xdime = tilesizx[wallnum];
				ydime = tilesizy[wallnum];

				dax = ((cnt%(xtiles<<gettilezoom))<<(6-gettilezoom));
				day = ((cnt/(xtiles<<gettilezoom))<<(6-gettilezoom));
				vidpos = ylookup[day]+dax+frameplace;
				if ((xdime <= (64>>gettilezoom)) && (ydime <= (64>>gettilezoom)))
				{
					for(i=0;i<xdime;i++)
					{
						vidpos2 = vidpos+i;
						for(j=0;j<ydime;j++)
						{
							*(char *)vidpos2 = *picptr++;
							vidpos2 += pinc;
						}
					}
				}
				else                          /* if 1 dimension > 64 */
				{
					if (xdime > ydime)
						scaledown = ((xdime+(63>>gettilezoom))>>(6-gettilezoom));
					else
						scaledown = ((ydime+(63>>gettilezoom))>>(6-gettilezoom));

					for(i=0;i<xdime;i+=scaledown)
					{
						if (waloff[wallnum] == 0) loadtile(wallnum);
						picptr = (char *)(waloff[wallnum]) + ydime*i;
						vidpos2 = vidpos;
						for(j=0;j<ydime;j+=scaledown)
						{
							*(char *)vidpos2 = *picptr;
							picptr += scaledown;
							vidpos2 += pinc;
						}
						vidpos++;
					}
				}
				if (localartlookupnum < MAXTILES)
				{
					dax = ((cnt%(xtiles<<gettilezoom))<<(6-gettilezoom));
					day = ((cnt/(xtiles<<gettilezoom))<<(6-gettilezoom));
					sprintf(snotbuf,"%d",localartfreq[cnt+pictopleft]);
					printext256(dax,day,whitecol,-1,snotbuf,1);
				}
			}
		}
	}

	cnt = picbox-pictopleft;    /* draw open white box */
	dax = ((cnt%(xtiles<<gettilezoom))<<(6-gettilezoom));
	day = ((cnt/(xtiles<<gettilezoom))<<(6-gettilezoom));

	for(i=0;i<(64>>gettilezoom);i++)
	{
		plotpixel(dax+i,day,whitecol);
		plotpixel(dax+i,day+(63>>gettilezoom),whitecol);
		plotpixel(dax,day+i,whitecol);
		plotpixel(dax+(63>>gettilezoom),day+i,whitecol);
	}

	i = localartlookup[picbox];
	sprintf(snotbuf,"%ld",i);
	printext256(0L,ydim-8,whitecol,-1,snotbuf,0);
	printext256(xdim-(strlen(names[i])<<3),ydim-8,whitecol,-1,names[i],0);

	return(0);
}


void getpoint(long searchxe, long searchye, long *x, long *y)
{
	if (posx <= -131072) posx = -131072;
	if (posx >= 131072) posx = 131072;
	if (posy <= -131072) posy = -131072;
	if (posy >= 131072) posy = 131072;

	*x = posx + divscale14(searchxe-320,zoom);
	*y = posy + divscale14(searchye-200,zoom);

	if (*x <= -131072) *x = -131072;
	if (*x >= 131072) *x = 131072;
	if (*y <= -131072) *y = -131072;
	if (*y >= 131072) *y = 131072;
}


long getlinehighlight(long xplc, long yplc)
{
	long i, dst, dist, closest, x1, y1, x2, y2, nx, ny;

	if (numwalls == 0)
		return(-1);
	dist = 0x7fffffff;
	closest = numwalls-1;
	for(i=0;i<numwalls;i++)
	{
		getclosestpointonwall(xplc,yplc,i,&nx,&ny);
		dst = klabs(xplc-nx)+klabs(yplc-ny);
		if (dst <= dist)
			dist = dst, closest = i;
	}

	if (wall[closest].nextwall >= 0)
	{    /* if red line, allow highlighting of both sides */
		x1 = wall[closest].x;
		y1 = wall[closest].y;
		x2 = wall[wall[closest].point2].x;
		y2 = wall[wall[closest].point2].y;
		if (dmulscale32(xplc-x1,y2-y1,-(x2-x1),yplc-y1) >= 0)
			closest = wall[closest].nextwall;
	}

	return(closest);
}


long getpointhighlight(long xplc, long yplc)
{
	long i, dst, dist, closest;

	if (numwalls == 0)
		return(-1);

	dist = 0;
	if (grid > 0)
		dist = 1024;

	closest = -1;
	for(i=0;i<numwalls;i++)
	{
		dst = klabs(xplc-wall[i].x) + klabs(yplc-wall[i].y);
		if (dst <= dist)
			dist = dst, closest = i;
	}
	for(i=0;i<MAXSPRITES;i++)
		if (sprite[i].statnum < MAXSTATUS)
		{
			dst = klabs(xplc-sprite[i].x) + klabs(yplc-sprite[i].y);
			if (dst <= dist)
				dist = dst, closest = i+16384;
		}
	return(closest);
}


int adjustmark(long *xplc, long *yplc, short danumwalls)
{
	long i, dst, dist, dax, day, pointlockdist;

	if (danumwalls < 0)
		danumwalls = numwalls;

	pointlockdist = 0;
	if ((grid > 0) && (gridlock > 0))
		pointlockdist = (128>>grid);

	dist = pointlockdist;
	dax = *xplc;
	day = *yplc;
	for(i=0;i<danumwalls;i++)
	{
		dst = klabs((*xplc)-wall[i].x) + klabs((*yplc)-wall[i].y);
		if (dst < dist)
		{
			dist = dst;
			dax = wall[i].x;
			day = wall[i].y;
		}
	}
	if (dist == pointlockdist)
		if ((gridlock > 0) && (grid > 0))
		{
			dax = ((dax+(1024>>grid))&(0xffffffff<<(11-grid)));
			day = ((day+(1024>>grid))&(0xffffffff<<(11-grid)));
		}

	*xplc = dax;
	*yplc = day;
	return(0);
}


int checkautoinsert(long dax, long day, short danumwalls)
{
	long i, x1, y1, x2, y2;

	if (danumwalls < 0)
		danumwalls = numwalls;
	for(i=0;i<danumwalls;i++)       /* Check if a point should be inserted */
	{
		x1 = wall[i].x;
		y1 = wall[i].y;
		x2 = wall[wall[i].point2].x;
		y2 = wall[wall[i].point2].y;

		if ((x1 != dax) || (y1 != day))
			if ((x2 != dax) || (y2 != day))
				if (((x1 <= dax) && (dax <= x2)) || ((x2 <= dax) && (dax <= x1)))
					if (((y1 <= day) && (day <= y2)) || ((y2 <= day) && (day <= y1)))
						if ((dax-x1)*(y2-y1) == (day-y1)*(x2-x1))
							return(1);          /*insertpoint((short)i,dax,day);*/
	}
	return(0);
}


void flipwalls(short numwalls, short newnumwalls)
{
	long i, j, nume, templong;

	nume = newnumwalls-numwalls;

	for(i=numwalls;i<numwalls+(nume>>1);i++)
	{
		j = numwalls+newnumwalls-i-1;
		templong = wall[i].x; wall[i].x = wall[j].x; wall[j].x = templong;
		templong = wall[i].y; wall[i].y = wall[j].y; wall[j].y = templong;
	}
}


int movewalls(long start, long offs)
{
	long i;

	if (offs < 0)  /* Delete */
	{
		for(i=start;i<numwalls+offs;i++)
			memcpy(&wall[i],&wall[i-offs],sizeof(walltype));
	}
	else if (offs > 0)  /* Insert */
	{
		for(i=numwalls+offs-1;i>=start+offs;i--)
			memcpy(&wall[i],&wall[i-offs],sizeof(walltype));
	}
	numwalls += offs;
	for(i=0;i<numwalls;i++)
	{
		if (wall[i].nextwall >= start) wall[i].nextwall += offs;
		if (wall[i].point2 >= start) wall[i].point2 += offs;
	}
	return(0);
}


void insertpoint(short linehighlight, long dax, long day)
{
	short sucksect;
	long i, j, k;

	j = linehighlight;
	sucksect = sectorofwall((short)j);

	sector[sucksect].wallnum++;
	for(i=sucksect+1;i<numsectors;i++)
		sector[i].wallptr++;

	movewalls((long)j+1,+1L);
	memcpy(&wall[j+1],&wall[j],sizeof(walltype));

	wall[j].point2 = j+1;
	wall[j+1].x = dax;
	wall[j+1].y = day;
	fixrepeats((short)j);
	fixrepeats((short)j+1);

	if (wall[j].nextwall >= 0)
	{
		k = wall[j].nextwall;

		sucksect = sectorofwall((short)k);

		sector[sucksect].wallnum++;
		for(i=sucksect+1;i<numsectors;i++)
			sector[i].wallptr++;

		movewalls((long)k+1,+1L);
		memcpy(&wall[k+1],&wall[k],sizeof(walltype));

		wall[k].point2 = k+1;
		wall[k+1].x = dax;
		wall[k+1].y = day;
		fixrepeats((short)k);
		fixrepeats((short)k+1);

		j = wall[k].nextwall;
		wall[j].nextwall = k+1;
		wall[j+1].nextwall = k;
		wall[k].nextwall = j+1;
		wall[k+1].nextwall = j;
	}
}


void deletepoint(short point)
{
	long i, j, k, sucksect;

	sucksect = sectorofwall(point);

	sector[sucksect].wallnum--;
	for(i=sucksect+1;i<numsectors;i++)
		sector[i].wallptr--;

	j = lastwall(point);
	k = wall[point].point2;
	wall[j].point2 = k;

	if (wall[j].nextwall >= 0)
	{
		wall[wall[j].nextwall].nextwall = -1;
		wall[wall[j].nextwall].nextsector = -1;
	}
	if (wall[point].nextwall >= 0)
	{
		wall[wall[point].nextwall].nextwall = -1;
		wall[wall[point].nextwall].nextsector = -1;
	}
	movewalls((long)point,-1L);

	checksectorpointer((short)j,(short)sucksect);
}


short deletesector(short sucksect)
{
	long i, j, k, nextk, startwall, endwall;

	while (headspritesect[sucksect] >= 0)
		deletesprite(headspritesect[sucksect]);
	updatenumsprites();

	startwall = sector[sucksect].wallptr;
	endwall = startwall + sector[sucksect].wallnum - 1;
	j = sector[sucksect].wallnum;

	for(i=sucksect;i<numsectors-1;i++)
	{
		k = headspritesect[i+1];
		while (k != -1)
		{
			nextk = nextspritesect[k];
			changespritesect((short)k,(short)i);
			k = nextk;
		}

		memcpy(&sector[i],&sector[i+1],sizeof(sectortype));
		sector[i].wallptr -= j;
	}
	numsectors--;

	j = endwall-startwall+1;
	for (i=startwall;i<=endwall;i++)
		if (wall[i].nextwall != -1)
		{
			wall[wall[i].nextwall].nextwall = -1;
			wall[wall[i].nextwall].nextsector = -1;
		}
	movewalls(startwall,-j);
	for(i=0;i<numwalls;i++)
		if (wall[i].nextwall >= startwall)
			wall[i].nextsector--;
	return(0);
}


void fixspritesectors(void)
{
	long i, j, dax, day, daz;

	for(i=numsectors-1;i>=0;i--)
		if ((sector[i].wallnum <= 0) || (sector[i].wallptr >= numwalls))
			deletesector((short)i);

	for(i=0;i<MAXSPRITES;i++)
		if (sprite[i].statnum < MAXSTATUS)
		{
			dax = sprite[i].x;
			day = sprite[i].y;
			if (inside(dax,day,sprite[i].sectnum) != 1)
			{
				daz = ((tilesizy[sprite[i].picnum]*sprite[i].yrepeat)<<2);

				for(j=0;j<numsectors;j++)
					if (inside(dax,day,(short)j) == 1)
						if (sprite[i].z >= getceilzofslope(j,dax,day))
							if (sprite[i].z-daz <= getflorzofslope(j,dax,day))
							{
								changespritesect((short)i,(short)j);
								break;
							}
			}
		}
}


void clearmidstatbar16(void)
{
	long opageoffset;

	opageoffset = pageoffset;    /* clear bottom part of status bar */
	pageoffset = 0;
	ydim16 = 144;
	fillscreen16((640L*25L)>>3,8L,640L*(143L-(25<<1)));
	drawline16(0,0,0,143,7);
	drawline16(639,0,639,143,7);
	pageoffset = opageoffset;
	ydim16 = 336;
}


short loopinside(long x, long y, short startwall)
{
	long x1, y1, x2, y2, templong;
	short i, cnt;

	cnt = clockdir(startwall);
	i = startwall;
	do
	{
		x1 = wall[i].x; x2 = wall[wall[i].point2].x;
		if ((x1 >= x) || (x2 >= x))
		{
			y1 = wall[i].y; y2 = wall[wall[i].point2].y;
			if (y1 > y2)
			{
				templong = x1, x1 = x2, x2 = templong;
				templong = y1, y1 = y2, y2 = templong;
			}
			if ((y1 <= y) && (y2 > y))
				if (x1*(y-y2)+x2*(y1-y) <= x*(y1-y2))
					cnt ^= 1;
		}
		i = wall[i].point2;
	}
	while (i != startwall);
	return(cnt);
}


long numloopsofsector(short sectnum)
{
	long i, numloops, startwall, endwall;

	numloops = 0;
	startwall = sector[sectnum].wallptr;
	endwall = startwall + sector[sectnum].wallnum;
	for(i=startwall;i<endwall;i++)
		if (wall[i].point2 < i) numloops++;
	return(numloops);
}


void overheadeditor(void)
{