ZealOS/src/Demo/Games/Collision.CC

/*Uses $LK,"fixed-point",A="FI:::/Demo/Lectures/FixedPoint.CC"$ arithmetic
because it used to be faster than floating
point.	See $LK,"::/Demo/Lectures/FixedPoint.CC"$.

The decimal place is between
bits 31 and 32.
*/

#define BALLS_NUM		64
#define BALL_RADIUS		5

I64 ball_x[BALLS_NUM], ball_y[BALLS_NUM], ball_velocity_x[BALLS_NUM], ball_velocity_y[BALLS_NUM];

U0 DrawIt(CTask *, CDC *dc)
{
	I64 i;

	dc->color = RED;
	for (i = 0; i < BALLS_NUM; i++)
		GrCircle(dc, ball_x[i].i32[1], ball_y[i].i32[1], BALL_RADIUS);
}

/****


$SP,"",BI=1$




Initial and final velocity vects
with normal and tangential components.
All masses are ident, so they
have been dropped from the equations.

Conservation of Momentum:

V1$SY,3$it$SY,0$+V2$SY,3$it$SY,0$=V1$SY,3$ft$SY,0$+V2$SY,3$ft$SY,0$

V1$SY,3$in$SY,0$+V2$SY,3$in$SY,0$=V1$SY,3$fn$SY,0$+V2$SY,3$fn$SY,0$

Conservation of Energy:

|V1$SY,3$i$SY,0$|$SY,-3$2$SY,0$+|V2$SY,3$i$SY,0$|$SY,-3$2$SY,0$=|V1$SY,3$f$SY,0$|$SY,-3$2$SY,0$+|V2$SY,3$f$SY,0$|$SY,-3$2$SY,0$
****/

U0 AnimateTask(I64)
{
	CTask  *task = Fs->parent_task;
	I64		i, j, h, v, distdist, 
			dia = (2 * BALL_RADIUS) << 32, 
			diadia = SqrI64(2 *BALL_RADIUS) << 32, 
			delta_x, delta_y, v_t1, v_n1, v_t2, v_n2;
	F64		dist;

	while (TRUE)
	{
		h = task->pix_width;
		v = task->pix_height;
		for (i = 0; i < BALLS_NUM; i++)
		{
			ball_x[i] += ball_velocity_x[i];
			ball_y[i] += ball_velocity_y[i];
			if (ball_x[i] < BALL_RADIUS << 32)
			{
				ball_velocity_x[i] *= -1;
				ball_x[i] = BALL_RADIUS << 32;
			}
			if (ball_x[i] >= (h - BALL_RADIUS) << 32)
			{
				ball_velocity_x[i] *= -1;
				ball_x[i] = (h - BALL_RADIUS) << 32;
			}
			if (ball_y[i] < BALL_RADIUS << 32)
			{
				ball_velocity_y[i] *= -1;
				ball_y[i] = BALL_RADIUS << 32;
			}
			if (ball_y[i] >= (v - BALL_RADIUS) << 32)
			{
				ball_velocity_y[i] *= -1;
				ball_y[i] = (v - BALL_RADIUS) << 32;
			}
		}
		for (i = 0; i < BALLS_NUM; i++)
		{
			for (j = i + 1; j < BALLS_NUM; j++)
			{
				delta_x = ball_x[i] - ball_x[j];
				delta_y = ball_y[i] - ball_y[j];

				//We shift 16 because multiplying
				//two 32 shifted would yield 64 shifted
				//and we want a 32 shifted res.
				distdist = SqrI64(delta_x >> 16) + SqrI64(delta_y >> 16);

				//We work with square instead of sqrt
				//to avoid unnecessarily calculating
				//square heads (They are slow.)
				if (distdist && distdist <= diadia)
				{
					dist = Sqrt(distdist); //shifted 16 bits
					delta_x /= dist; //shifted 16
					delta_y /= dist;

					v_t1 = (ball_velocity_x[i] >> 16 * delta_y - ball_velocity_y[i] >> 16 * delta_x) >> 16;
					v_n1 = (ball_velocity_x[i] >> 16 * delta_x + ball_velocity_y[i] >> 16 * delta_y) >> 16;
					v_t2 = (ball_velocity_x[j] >> 16 * delta_y - ball_velocity_y[j] >> 16 * delta_x) >> 16;
					v_n2 = (ball_velocity_x[j] >> 16 * delta_x + ball_velocity_y[j] >> 16 * delta_y) >> 16;

					if (ball_velocity_x[i] >> 16 * ball_velocity_x[j] >> 16 +
						ball_velocity_y[i] >> 16 * ball_velocity_y[j] >> 16 <= 0)
					{
						ball_velocity_x[i] =  v_t1 * delta_y - v_n1 * delta_x;
						ball_velocity_y[i] = -v_t1 * delta_x - v_n1 * delta_y;
						ball_velocity_x[j] =  v_t2 * delta_y - v_n2 * delta_x;
						ball_velocity_y[j] = -v_t2 * delta_x - v_n2 * delta_y;
					}
					else
					{
						ball_velocity_x[i] =  v_t1 * delta_y + v_n2 * delta_x;
						ball_velocity_y[i] = -v_t1 * delta_x + v_n2 * delta_y;
						ball_velocity_x[j] =  v_t2 * delta_y + v_n1 * delta_x;
						ball_velocity_y[j] = -v_t2 * delta_x + v_n1 * delta_y;
					}

					//Correct for overlap
					dist = 0x10000 + (dia / 0x10000 - dist) / 2;
					ball_x[i] += dist * delta_x;
					ball_y[i] += dist * delta_y;
					ball_x[j] -= dist * delta_x;
					ball_y[j] -= dist * delta_y;
				}
			}
		}
		Sleep(1);
	}
}

U0 Init()
{
	I64 i;

	for (i = 0; i < BALLS_NUM; i++)
	{
		ball_x[i] = (RandU16 % (Fs->pix_width  - BALL_RADIUS * 2) + BALL_RADIUS) << 32;
		ball_y[i] = (RandU16 % (Fs->pix_height - BALL_RADIUS * 2) + BALL_RADIUS) << 32;
		ball_velocity_x[i] = RandI32 / 4;
		ball_velocity_y[i] = RandI32 / 4;
	}
}

U0 Collision()
{
	SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
	Init;
	Fs->animate_task = Spawn(&AnimateTask, NULL, "Animate",, Fs);
	DocCursor;
	DocClear;
	Fs->draw_it = &DrawIt;
	CharGet;
	SettingsPop;
}

Collision;

W
d<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD> <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>v_t<EFBFBD>v_n