[newkind] / stars.c

/*
 * Elite - The New Kind.
 *
 * Reverse engineered from the BBC disk version of Elite.
 * Additional material by C.J.Pinder.
 *
 * The original Elite code is (C) I.Bell & D.Braben 1984.
 * This version re-engineered in C by C.J.Pinder 1999-2001.
 *
 * email: <christian@newkind.co.uk>
 *
 *
 */

#include <stdlib.h>
#include <math.h>

#include "config.h"
#include "elite.h" 
#include "gfx.h"
#include "vector.h"
#include "stars.h"
#include "random.h"

int warp_stars;

struct star
{
	double x;
	double y;
	double z;
};

struct star stars[20];


void create_new_stars (void)
{
	int i;
	int nstars;
	
	nstars = witchspace ? 3 : 12;

	for (i = 0; i < nstars; i++)
	{
		stars[i].x = (rand255() - 128) | 8;
		stars[i].y = (rand255() - 128) | 4;
		stars[i].z = rand255() | 0x90;
	}

	warp_stars = 0;
}


void front_starfield (void)
{
	int i;
	double Q;
	double delta;
	double alpha = 0;
	double beta = 0;
	double xx,yy,zz;
	int sx;
	int sy;
	int nstars;
	
	nstars = witchspace ? 3 : 12;

	delta = warp_stars ? 50 : flight_speed;	
	alpha = (double)flight_roll;
	beta = (double)flight_climb;

	alpha /= 256.0;
	delta /= 2.0;
	
	for (i = 0; i < nstars; i++)
	{
		/* Plot the stars in their current locations... */

		sy = stars[i].y;
		sx = stars[i].x;
		zz = stars[i].z;

		sx += 128;
		sy += 96;

		sx *= GFX_SCALE;
		sy *= GFX_SCALE;

		if ((!warp_stars) &&
			(sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
			(sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY))
		{
			gfx_plot_pixel (sx, sy, GFX_COL_WHITE);

			if (zz < 0xC0)
				gfx_plot_pixel (sx+1, sy, GFX_COL_WHITE);

			if (zz < 0x90)
			{
				gfx_plot_pixel (sx, sy+1, GFX_COL_WHITE);
				gfx_plot_pixel (sx+1, sy+1, GFX_COL_WHITE);
			}
		}


		/* Move the stars to their new locations...*/

		Q = delta / stars[i].z;

		stars[i].z -= delta;
		yy = stars[i].y + (stars[i].y * Q);
		xx = stars[i].x + (stars[i].x * Q);
		zz = stars[i].z;

		yy = yy + (xx * alpha);
		xx = xx - (yy * alpha);

/*
		tx = yy * beta;
		xx = xx + (tx * tx * 2);
*/
		yy = yy + beta;

		stars[i].y = yy;
		stars[i].x = xx;

		
		if (warp_stars)
			gfx_draw_line (sx, sy, (xx + 128) * GFX_SCALE, (yy + 96) * GFX_SCALE);
		
		sx = xx;
		sy = yy;

		if ((sx > 120) || (sx < -120) ||
			(sy > 120) || (sy < -120) || (zz < 16))
		{
			stars[i].x = (rand255() - 128) | 8;
			stars[i].y = (rand255() - 128) | 4;
			stars[i].z = rand255() | 0x90;
			continue;
		}

	}

	warp_stars = 0;
}


void rear_starfield (void)
{
	int i;
	double Q;
	double delta;
	double alpha = 0;
	double beta = 0;
	double xx,yy,zz;
	int sx,sy;
	int ex,ey;
	int nstars;
	
	nstars = witchspace ? 3 : 12;

	delta = warp_stars ? 50 : flight_speed;	
	alpha = -flight_roll;
	beta = -flight_climb;

	alpha /= 256.0;
	delta /= 2.0;
	
	for (i = 0; i < nstars; i++)
	{
		/* Plot the stars in their current locations... */

		sy = stars[i].y;
		sx = stars[i].x;
		zz = stars[i].z;

		sx += 128;
		sy += 96;

		sx *= GFX_SCALE;
		sy *= GFX_SCALE;

		if ((!warp_stars) &&
			(sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
			(sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY))
		{
			gfx_plot_pixel (sx, sy, GFX_COL_WHITE);

			if (zz < 0xC0)
				gfx_plot_pixel (sx+1, sy, GFX_COL_WHITE);

			if (zz < 0x90)
			{
				gfx_plot_pixel (sx, sy+1, GFX_COL_WHITE);
				gfx_plot_pixel (sx+1, sy+1, GFX_COL_WHITE);
			}
		}


		/* Move the stars to their new locations...*/

		Q = delta / stars[i].z;

		stars[i].z += delta;
		yy = stars[i].y - (stars[i].y * Q);
		xx = stars[i].x - (stars[i].x * Q);
		zz = stars[i].z;

		yy = yy + (xx * alpha);
		xx = xx - (yy * alpha);

/*
		tx = yy * beta;
		xx = xx + (tx * tx * 2);
*/
		yy = yy + beta;
		
		if (warp_stars)
		{
			ey = yy;
			ex = xx;
			ex = (ex + 128) * GFX_SCALE;
			ey = (ey + 96) * GFX_SCALE;

			if ((sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
			   (sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY) &&
			   (ex >= GFX_VIEW_TX) && (ex <= GFX_VIEW_BX) &&
			   (ey >= GFX_VIEW_TY) && (ey <= GFX_VIEW_BY))
				gfx_draw_line (sx, sy, (xx + 128) * GFX_SCALE, (yy + 96) * GFX_SCALE);
		}
		
		stars[i].y = yy;
		stars[i].x = xx;

		if ((zz >= 300) || (abs(yy) >= 110))
		{
			stars[i].z = (rand255() & 127) + 51;
			
			if (rand255() & 1)
			{
				stars[i].x = rand255() - 128;
				stars[i].y = (rand255() & 1) ? -115 : 115;
			}
			else
			{
				stars[i].x = (rand255() & 1) ? -126 : 126;
				stars[i].y = rand255() - 128; 
			}
		}

	}

	warp_stars = 0;
}


void side_starfield (void)
{
	int i;
	double delta;
	double alpha;
	double beta;
	double xx,yy,zz;
	int sx;
	int sy;
	double delt8;
	int nstars;
	
	nstars = witchspace ? 3 : 12;
	
	delta = warp_stars ? 50 : flight_speed;	
	alpha = flight_roll;
	beta = flight_climb;

	if (current_screen == SCR_LEFT_VIEW)
	{
		delta = -delta;
		alpha = -alpha;
		beta = -beta;
	} 
	
	for (i = 0; i < nstars; i++)
	{
		sy = stars[i].y;
		sx = stars[i].x;
		zz = stars[i].z;

		sx += 128;
		sy += 96;

		sx *= GFX_SCALE;
		sy *= GFX_SCALE;

		if ((!warp_stars) &&
			(sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
			(sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY))
		{
			gfx_plot_pixel (sx, sy, GFX_COL_WHITE);

			if (zz < 0xC0)
				gfx_plot_pixel (sx+1, sy, GFX_COL_WHITE);

			if (zz < 0x90)
			{
				gfx_plot_pixel (sx, sy+1, GFX_COL_WHITE);
				gfx_plot_pixel (sx+1, sy+1, GFX_COL_WHITE);
			}
		}

		yy = stars[i].y;
		xx = stars[i].x;
		zz = stars[i].z;
		
		delt8 = delta / (zz / 32);
		xx = xx + delt8;

		xx += (yy * (beta / 256));		
		yy -= (xx * (beta / 256));

		xx += ((yy / 256) * (alpha / 256)) * (-xx);
		yy += ((yy / 256) * (alpha / 256)) * (yy);

		yy += alpha; 

		stars[i].y = yy;
		stars[i].x = xx;

		if (warp_stars)
			gfx_draw_line (sx, sy, (xx + 128) * GFX_SCALE, (yy + 96) * GFX_SCALE);

		
		if (abs(stars[i].x) >= 116)
		{
			stars[i].y = rand255() - 128;
			stars[i].x = (current_screen == SCR_LEFT_VIEW) ? 115 : -115;
			stars[i].z = rand255() | 8;
		}
		else if (abs(stars[i].y) >= 116)
		{
			stars[i].x = rand255() - 128;
			stars[i].y = (alpha > 0) ? -110 : 110;
			stars[i].z = rand255() | 8;
		} 
		
	}

	warp_stars = 0;
}


/*
 * When we change view, flip the stars over so they look like other stars.
 */

void flip_stars (void)
{
	int i;
	int nstars;
	int sx;
	int sy;
	
	nstars = witchspace ? 3 : 12;
	for (i = 0; i < nstars; i++)
	{
		sy = stars[i].y;
		sx = stars[i].x;
		stars[i].x = sy;
		stars[i].y = sx;
	}
}


void update_starfield (void)
{
	switch (current_screen)
	{
		case SCR_FRONT_VIEW:
		case SCR_INTRO_ONE:
		case SCR_INTRO_TWO:
		case SCR_ESCAPE_POD:
			front_starfield();
			break;
		
		case SCR_REAR_VIEW:
		case SCR_GAME_OVER:
			rear_starfield();
			break;
		
		case SCR_LEFT_VIEW:
		case SCR_RIGHT_VIEW:
			side_starfield();
			break;
	}
}
Commit	Line	Data
84bbd123	1	/*
	2	* Elite - The New Kind.
	3	*
	4	* Reverse engineered from the BBC disk version of Elite.
	5	* Additional material by C.J.Pinder.
	6	*
	7	* The original Elite code is (C) I.Bell & D.Braben 1984.
	8	* This version re-engineered in C by C.J.Pinder 1999-2001.
	9	*
	10	* email: <christian@newkind.co.uk>
	11	*
	12	*
	13	*/
	14
	15	#include <stdlib.h>
	16	#include <math.h>
	17
	18	#include "config.h"
	19	#include "elite.h"
	20	#include "gfx.h"
	21	#include "vector.h"
	22	#include "stars.h"
	23	#include "random.h"
	24
	25	int warp_stars;
	26
	27	struct star
	28	{
	29	double x;
	30	double y;
	31	double z;
	32	};
	33
	34	struct star stars[20];
	35
	36
	37	void create_new_stars (void)
	38	{
	39	int i;
	40	int nstars;
	41
	42	nstars = witchspace ? 3 : 12;
	43
	44	for (i = 0; i < nstars; i++)
	45	{
	46	stars[i].x = (rand255() - 128) \| 8;
	47	stars[i].y = (rand255() - 128) \| 4;
	48	stars[i].z = rand255() \| 0x90;
	49	}
	50
	51	warp_stars = 0;
	52	}
	53
	54
	55	void front_starfield (void)
	56	{
	57	int i;
	58	double Q;
	59	double delta;
	60	double alpha = 0;
	61	double beta = 0;
	62	double xx,yy,zz;
	63	int sx;
	64	int sy;
65	int nstars;
66
67	nstars = witchspace ? 3 : 12;
68
69	delta = warp_stars ? 50 : flight_speed;
70	alpha = (double)flight_roll;
71	beta = (double)flight_climb;
72
73	alpha /= 256.0;
74	delta /= 2.0;
75
76	for (i = 0; i < nstars; i++)
77	{
78	/* Plot the stars in their current locations... */
79
80	sy = stars[i].y;
81	sx = stars[i].x;
82	zz = stars[i].z;
83
84	sx += 128;
85	sy += 96;
86
87	sx *= GFX_SCALE;
88	sy *= GFX_SCALE;
89
90	if ((!warp_stars) &&
91	(sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
92	(sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY))
93	{
94	gfx_plot_pixel (sx, sy, GFX_COL_WHITE);
95
96	if (zz < 0xC0)
97	gfx_plot_pixel (sx+1, sy, GFX_COL_WHITE);
98
99	if (zz < 0x90)
100	{
101	gfx_plot_pixel (sx, sy+1, GFX_COL_WHITE);
102	gfx_plot_pixel (sx+1, sy+1, GFX_COL_WHITE);
103	}
104	}
105
106
107	/* Move the stars to their new locations...*/
108
109	Q = delta / stars[i].z;
110
111	stars[i].z -= delta;
112	yy = stars[i].y + (stars[i].y * Q);
113	xx = stars[i].x + (stars[i].x * Q);
114	zz = stars[i].z;
115
116	yy = yy + (xx * alpha);
117	xx = xx - (yy * alpha);
118
119	/*
120	tx = yy * beta;
121	xx = xx + (tx * tx * 2);
122	*/
123	yy = yy + beta;
124
125	stars[i].y = yy;
126	stars[i].x = xx;
127
128
129	if (warp_stars)
130	gfx_draw_line (sx, sy, (xx + 128) * GFX_SCALE, (yy + 96) * GFX_SCALE);
131
132	sx = xx;
133	sy = yy;
134
135	if ((sx > 120) \|\| (sx < -120) \|\|
136	(sy > 120) \|\| (sy < -120) \|\| (zz < 16))
137	{
138	stars[i].x = (rand255() - 128) \| 8;
139	stars[i].y = (rand255() - 128) \| 4;
140	stars[i].z = rand255() \| 0x90;
141	continue;
142	}
143
144	}
145
146	warp_stars = 0;
147	}
148
149
150
151	void rear_starfield (void)
152	{
153	int i;
154	double Q;
155	double delta;
156	double alpha = 0;
157	double beta = 0;
158	double xx,yy,zz;
159	int sx,sy;
160	int ex,ey;
161	int nstars;
162
163	nstars = witchspace ? 3 : 12;
164
165	delta = warp_stars ? 50 : flight_speed;
166	alpha = -flight_roll;
167	beta = -flight_climb;
168
169	alpha /= 256.0;
170	delta /= 2.0;
171
172	for (i = 0; i < nstars; i++)
173	{
174	/* Plot the stars in their current locations... */
175
176	sy = stars[i].y;
177	sx = stars[i].x;
178	zz = stars[i].z;
179
180	sx += 128;
181	sy += 96;
182
183	sx *= GFX_SCALE;
184	sy *= GFX_SCALE;
185
186	if ((!warp_stars) &&
187	(sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
188	(sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY))
189	{
190	gfx_plot_pixel (sx, sy, GFX_COL_WHITE);
191
192	if (zz < 0xC0)
193	gfx_plot_pixel (sx+1, sy, GFX_COL_WHITE);
194
195	if (zz < 0x90)
196	{
197	gfx_plot_pixel (sx, sy+1, GFX_COL_WHITE);
198	gfx_plot_pixel (sx+1, sy+1, GFX_COL_WHITE);
199	}
200	}
201
202
203	/* Move the stars to their new locations...*/
204
205	Q = delta / stars[i].z;
206
207	stars[i].z += delta;
208	yy = stars[i].y - (stars[i].y * Q);
209	xx = stars[i].x - (stars[i].x * Q);
210	zz = stars[i].z;
211
212	yy = yy + (xx * alpha);
213	xx = xx - (yy * alpha);
214
215	/*
216	tx = yy * beta;
217	xx = xx + (tx * tx * 2);
218	*/
219	yy = yy + beta;
220
221	if (warp_stars)
222	{
223	ey = yy;
224	ex = xx;
225	ex = (ex + 128) * GFX_SCALE;
226	ey = (ey + 96) * GFX_SCALE;
227
228	if ((sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
229	(sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY) &&
230	(ex >= GFX_VIEW_TX) && (ex <= GFX_VIEW_BX) &&
231	(ey >= GFX_VIEW_TY) && (ey <= GFX_VIEW_BY))
232	gfx_draw_line (sx, sy, (xx + 128) * GFX_SCALE, (yy + 96) * GFX_SCALE);
233	}
234
235	stars[i].y = yy;
236	stars[i].x = xx;
237
238	if ((zz >= 300) \|\| (abs(yy) >= 110))
239	{
240	stars[i].z = (rand255() & 127) + 51;
241
242	if (rand255() & 1)
243	{
244	stars[i].x = rand255() - 128;
245	stars[i].y = (rand255() & 1) ? -115 : 115;
246	}
247	else
248	{
249	stars[i].x = (rand255() & 1) ? -126 : 126;
250	stars[i].y = rand255() - 128;
251	}
252	}
253
254	}
255
256	warp_stars = 0;
257	}
258
259
260	void side_starfield (void)
261	{
262	int i;
263	double delta;
264	double alpha;
265	double beta;
266	double xx,yy,zz;
267	int sx;
268	int sy;
269	double delt8;
270	int nstars;
271
272	nstars = witchspace ? 3 : 12;
273
274	delta = warp_stars ? 50 : flight_speed;
275	alpha = flight_roll;
276	beta = flight_climb;
277
278	if (current_screen == SCR_LEFT_VIEW)
279	{
280	delta = -delta;
281	alpha = -alpha;
282	beta = -beta;
283	}
284
285	for (i = 0; i < nstars; i++)
286	{
287	sy = stars[i].y;
288	sx = stars[i].x;
289	zz = stars[i].z;
290
291	sx += 128;
292	sy += 96;
293
294	sx *= GFX_SCALE;
295	sy *= GFX_SCALE;
296
297	if ((!warp_stars) &&
298	(sx >= GFX_VIEW_TX) && (sx <= GFX_VIEW_BX) &&
299	(sy >= GFX_VIEW_TY) && (sy <= GFX_VIEW_BY))
300	{
301	gfx_plot_pixel (sx, sy, GFX_COL_WHITE);
302
303	if (zz < 0xC0)
304	gfx_plot_pixel (sx+1, sy, GFX_COL_WHITE);
305
306	if (zz < 0x90)
307	{
308	gfx_plot_pixel (sx, sy+1, GFX_COL_WHITE);
309	gfx_plot_pixel (sx+1, sy+1, GFX_COL_WHITE);
310	}
311	}
312
313	yy = stars[i].y;
314	xx = stars[i].x;
315	zz = stars[i].z;
316
317	delt8 = delta / (zz / 32);
318	xx = xx + delt8;
319
320	xx += (yy * (beta / 256));
321	yy -= (xx * (beta / 256));
322
323	xx += ((yy / 256) * (alpha / 256)) * (-xx);
324	yy += ((yy / 256) * (alpha / 256)) * (yy);
325
326	yy += alpha;
327
328	stars[i].y = yy;
329	stars[i].x = xx;
330
331	if (warp_stars)
332	gfx_draw_line (sx, sy, (xx + 128) * GFX_SCALE, (yy + 96) * GFX_SCALE);
333
334
335	if (abs(stars[i].x) >= 116)
336	{
337	stars[i].y = rand255() - 128;
338	stars[i].x = (current_screen == SCR_LEFT_VIEW) ? 115 : -115;
339	stars[i].z = rand255() \| 8;
340	}
341	else if (abs(stars[i].y) >= 116)
342	{
343	stars[i].x = rand255() - 128;
344	stars[i].y = (alpha > 0) ? -110 : 110;
345	stars[i].z = rand255() \| 8;
346	}
347
348	}
349
350	warp_stars = 0;
351	}
352
353
354	/*
355	* When we change view, flip the stars over so they look like other stars.
356	*/
357
358	void flip_stars (void)
359	{
360	int i;
361	int nstars;
362	int sx;
363	int sy;
364
365	nstars = witchspace ? 3 : 12;
366	for (i = 0; i < nstars; i++)
367	{
368	sy = stars[i].y;
369	sx = stars[i].x;
370	stars[i].x = sy;
371	stars[i].y = sx;
372	}
373	}
374
375
376	void update_starfield (void)
377	{
378	switch (current_screen)
379	{
380	case SCR_FRONT_VIEW:
381	case SCR_INTRO_ONE:
382	case SCR_INTRO_TWO:
383	case SCR_ESCAPE_POD:
384	front_starfield();
385	break;
386
387	case SCR_REAR_VIEW:
388	case SCR_GAME_OVER:
389	rear_starfield();
390	break;
391
392	case SCR_LEFT_VIEW:
393	case SCR_RIGHT_VIEW:
394	side_starfield();
395	break;
396	}
397	}