[mirrors/Programs.git] / c / ninvaders-0.1.1 / aliens.c

/**
 * nInvaders - a space invaders clone for ncurses
 * Copyright (C) 2002-2003 Dettus
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 * homepage: http://ninvaders.sourceforge.net
 * mailto: ninvaders-devel@lists.sourceforge.net
 *
 */

 
#include "aliens.h"
#include "player.h"
#include "nInvaders.h"

/**
 * initialize aliens attributes
 */
void aliensReset()
{
	int i,j;
	
	// three different types of aliens [5], [10]
	int level[ALIENS_MAX_NUMBER_Y][ALIENS_MAX_NUMBER_X]={
		{1,1,1,1,1,1,1,1,1,1},
		{2,2,2,2,2,2,2,2,2,2},
		{2,2,2,2,2,2,2,2,2,2},
		{3,3,3,3,3,3,3,3,3,3},
		{3,3,3,3,3,3,3,3,3,3}
	};

	aliensClear(aliens.posX, aliens.posY, aliens.right, aliens.bottom);	// clear old position of aliens
	
	// reset alien position
	aliens.posX = 0;
	aliens.posY = 0;
	aliens.right = 0;
	aliens.bottom = 0;
	aliens.left = 0;
	aliens.speed = 1;
	
	// copy level-array to enemy-array 
	for (i=0;i<ALIENS_MAX_NUMBER_X;i++) {
		for (j=0;j<ALIENS_MAX_NUMBER_Y;j++) {
			alienBlock[j][i]=level[j][i];
		}
	}
	
	// reset missiles
	for (i = 0; i < ALIENS_MAX_MISSILES; i++) {
		if (alienshotx[i] != 0) {
			aliensMissileClear(alienshotx[i],alienshoty[i]);	// clear old position
		}
		alienshotx[i] = 0;  // start with zero values
		alienshoty[i] = 0;  // start with zero values
	}
	alienshotnum = 1;	    // one missile at the same time
	alienshotx[0] = 5;	    // x position of first alienshot
	alienshoty[0] = 1;	    // y position of first alienshot

}

/**
 * initialize bunkers attributes
 */
void bunkersReset()
{
	int a, b;

	// set position of bunker sprites. user graphical char bunkerd for better visual overview
	// and set according to this the bunker-array
	char bunkerd[BUNKERHEIGHT][BUNKERWIDTH+1] = {
		"        ###                 ###                 ###                 ###         ",
		"       #####               #####               #####               #####        ",
		"      #######             #######             #######             #######       ",
		"      ##   ##             ##   ##             ##   ##             ##   ##       "
	};
	//       12345678901234567890123456789012345678901234567890123456789012345678901234567890
	// 80 characters wide

	// copy graphical "bunkerd" to binary "bunker"
	for (a = 0; a < BUNKERWIDTH; a++) {
		for (b = 0; b < BUNKERHEIGHT; b++) {
			if (bunkerd[b][a] == '#')
				bunker[b][a] = 1;
			else
				bunker[b][a] = 0;
		}
	}
	
	// display bunkers sprite
	bunkersDisplay(&bunker[0][0]);	
}

/**
 * move aliens and test if they've reached the
 * bottom of the windows or the bunkers.
 */
int aliensMove()
{
	
	int cx,cy;
	int fReachedPlayer=0; 				// return value

	render();	
	aliensClear(aliens.posX, aliens.posY, aliens.right, aliens.bottom);	// clear old position of aliens

	aliens.posX = aliens.posX + aliens.speed;			// move aliens left/ right
	
	// when aliens reached left or right screen-border
	if (aliens.posX == (BUNKERWIDTH + BUNKERX - 5 - aliens.right) || aliens.posX == (BUNKERX + aliens.left)) {
		
		aliens.posY++;				// move aliens downwards
		
		// aliens reached player
		if (aliens.posY == SCREENHEIGHT - 2 - aliens.bottom) {
			fReachedPlayer = 1;		// set return value
		}
		
		// aliens reached bunkers //funzt nicht ganz: todo
		if (aliens.posY == BUNKERY - aliens.bottom) {
			// clear bunkers
			for(cx=0;cx<BUNKERWIDTH;cx++) {
				for(cy=0;cy<BUNKERHEIGHT;cy++) { 
					bunker[cy][cx]=0;	
				}
			}
			bunkersClear();	// clear bunkers sprites
		}
		
		aliens.speed = aliens.speed * (-1);		  // change direction of aliens' movements
	}

	aliensDisplay(aliens.posX, aliens.posY, aliens.right, aliens.bottom); // display aliens at new position
	
	return fReachedPlayer;				  // return if aliens reached player
}


/**
 * display alien animation, display remaining parts of aliens and bunker 
 */
void render()
{
	int k,row;
	int c=0;

	// calculate left, right, bottom, lowest_ship	
	aliens.left=1;
	aliens.right=-1;
	aliens.bottom=-1;
	shipnum=0;
	for (k=0;k<11;k++) {
		lowest_ship[k]=-1;
	}
	
	for (row=0;row<ALIENS_MAX_NUMBER_Y*2;row++) {
		if ((row%2)==0){
			for (k=0;k<ALIENS_MAX_NUMBER_X;k++) {
				if (alienBlock[c][k] != 0) {
					lowest_ship[k]=row;
					shipnum++;
					if (aliens.left==1 || -k>aliens.left) {aliens.left=-k;}
					if (aliens.right==-1 || k>aliens.right) {aliens.right=k;}
					if (aliens.bottom==-1 || c>aliens.bottom) {aliens.bottom=c;}
				} 
			}
		} else {
			c++;
		}
	}
	aliens.bottom=aliens.bottom*2;	// every 2nd row is an empty row
	aliens.left=aliens.left*3; // alien sprite is 3 chars wide
	aliens.right=aliens.right*3; // alien sprite is 3 chars wide
	
	// display remaining aliens with animation
	aliensRefresh(level, &alienBlock[0][0]);

}


/**
 * move aliens' missiles and do player/bunker hit testing
 * a zero value in alienshotx indicates that the appropriate missile is loaded, but not fired
 */
int aliensMissileMove()
{
	int i, tmp;
	int fPlayerWasHit = 0;
	int shootThreshold;
	static int alienshot_counter = 0;

	
	// calculate threshold when next missile should be fired
	// it is done here to save calculation time in for-instruction 
	shootThreshold = (skill_level * 8) * (shipnum + 2);
	alienshot_counter = alienshot_counter + 10 ;
	
	// loop all possible missiles
	for (i = 0; i < ALIENS_MAX_MISSILES; i++) {
		
		// if the current missile is flying we should do movements
		if (alienshotx[i] != 0) {
			
			aliensMissileClear(alienshotx[i],alienshoty[i]);	// clear old position
				
			// if missile hit the bunkers	
			if (bunkersHitCheck(alienshotx[i], alienshoty[i]) == 1) {
				alienshotx[i] = 0;		// value of zero reloads missile
			}
			
			alienshoty[i]++;			// move missile downwards
			
			// check if player was hit by an alien missile
			if (playerHitCheck(alienshotx[i], alienshoty[i]) == 1) {
				alienshotx[i] = 0;		// value of zero reloads missile
				fPlayerWasHit = 1;
			}
			
			
		} else {					// missile not launched yet
			
			// start new missile if counter says so
			if (alienshot_counter > shootThreshold && shipnum > 0) {// only shot if there's an alien left
				alienshot_counter = 0;				// reset counter				
				tmp = random() % ALIENS_MAX_NUMBER_X;  		// randomly select one of the ...
				while (lowest_ship[tmp] == -1) {		// ...aliens at the bottom of ...
					tmp = random() % ALIENS_MAX_NUMBER_X;	// ...a column to launch missile
				}
				alienshoty[i]=aliens.posY+lowest_ship[tmp];		// set y position of missile
				alienshotx[i]=aliens.posX+tmp*3;			// set x position of missile
			}
		} // if 
		
		// display missiles if still running or just launched; could have been modified in the above code
		if (alienshotx[i] != 0) {
			// if missile is out of battlefield 
			if (alienshoty[i] == SCREENHEIGHT - 1) {
				alienshotx[i] = 0;	// reload missile	
			} else {
				aliensMissileDisplay(alienshotx[i], alienshoty[i]); // display Missile at new position
			}
		}		
		
	} // for


	return fPlayerWasHit;
}


/**
 * check if missile hit an alien
 */
int aliensHitCheck(int shotx, int shoty)
{
	int alienType = 0;
	int shipx, shipy;
	// if missile is within alien-rectangle 
	if (shotx >= aliens.posX && shotx <= aliens.posX + ALIENS_MAX_NUMBER_X * 3 - 1
	    && shoty >= aliens.posY && shoty <= aliens.posY + (ALIENS_MAX_NUMBER_Y - 1) * 2) {
		// calculate the ship that was hit
		shipx = (shotx - aliens.posX) / 3;
		shipy = (shoty - aliens.posY) / 2;
		// if there is still a ship at this position
		alienType = alienBlock[shipy][shipx];
		if (alienType != 0) {
			alienBlock[shipy][shipx] = 0;	// delete alien ship
		}
	}
	return alienType; 	// returns 0 if no alien was hit, else returns type-code of alien
}

/**
 * check if missile hit an element of bunker
 */
int bunkersHitCheck(int shotx, int shoty)
{
	int adjx, adjy;
	int fBunkerWasHit = 0;
	// if missile is within bunker-rectangle
	if (shotx >= BUNKERX && shotx < BUNKERX + BUNKERWIDTH
	    && shoty >= BUNKERY && shoty < BUNKERY + BUNKERHEIGHT) {
		// calculate the element of the bunker that was hit
		adjy = shoty - BUNKERY; 
		adjx = shotx - BUNKERX;
		// if there is still an element
		if(bunker[adjy][adjx] == 1){
			bunker[adjy][adjx] = 0;	// delete element
			fBunkerWasHit = 1; 		// bunker was hit!
		}
	}
	return fBunkerWasHit;
}
Commit	Line	Data
	1	/**
	2	* nInvaders - a space invaders clone for ncurses
	3	* Copyright (C) 2002-2003 Dettus
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*
	19	* homepage: http://ninvaders.sourceforge.net
	20	* mailto: ninvaders-devel@lists.sourceforge.net
	21	*
	22	*/
	23
	24
	25	#include "aliens.h"
	26	#include "player.h"
	27	#include "nInvaders.h"
	28
	29	/**
	30	* initialize aliens attributes
	31	*/
	32	void aliensReset()
	33	{
	34	int i,j;
	35
	36	// three different types of aliens [5], [10]
	37	int level[ALIENS_MAX_NUMBER_Y][ALIENS_MAX_NUMBER_X]={
	38	{1,1,1,1,1,1,1,1,1,1},
	39	{2,2,2,2,2,2,2,2,2,2},
	40	{2,2,2,2,2,2,2,2,2,2},
	41	{3,3,3,3,3,3,3,3,3,3},
	42	{3,3,3,3,3,3,3,3,3,3}
	43	};
	44
	45	aliensClear(aliens.posX, aliens.posY, aliens.right, aliens.bottom); // clear old position of aliens
	46
	47	// reset alien position
	48	aliens.posX = 0;
	49	aliens.posY = 0;
	50	aliens.right = 0;
	51	aliens.bottom = 0;
	52	aliens.left = 0;
	53	aliens.speed = 1;
	54
	55	// copy level-array to enemy-array
	56	for (i=0;i<ALIENS_MAX_NUMBER_X;i++) {
	57	for (j=0;j<ALIENS_MAX_NUMBER_Y;j++) {
	58	alienBlock[j][i]=level[j][i];
	59	}
	60	}
	61
	62	// reset missiles
	63	for (i = 0; i < ALIENS_MAX_MISSILES; i++) {
	64	if (alienshotx[i] != 0) {
	65	aliensMissileClear(alienshotx[i],alienshoty[i]); // clear old position
	66	}
	67	alienshotx[i] = 0; // start with zero values
	68	alienshoty[i] = 0; // start with zero values
	69	}
	70	alienshotnum = 1; // one missile at the same time
	71	alienshotx[0] = 5; // x position of first alienshot
	72	alienshoty[0] = 1; // y position of first alienshot
	73
	74	}
	75
	76	/**
	77	* initialize bunkers attributes
	78	*/
	79	void bunkersReset()
	80	{
	81	int a, b;
	82
	83	// set position of bunker sprites. user graphical char bunkerd for better visual overview
	84	// and set according to this the bunker-array
	85	char bunkerd[BUNKERHEIGHT][BUNKERWIDTH+1] = {
	86	" ### ### ### ### ",
	87	" ##### ##### ##### ##### ",
	88	" ####### ####### ####### ####### ",
	89	" ## ## ## ## ## ## ## ## "
	90	};
	91	// 12345678901234567890123456789012345678901234567890123456789012345678901234567890
	92	// 80 characters wide
	93
	94	// copy graphical "bunkerd" to binary "bunker"
	95	for (a = 0; a < BUNKERWIDTH; a++) {
	96	for (b = 0; b < BUNKERHEIGHT; b++) {
	97	if (bunkerd[b][a] == '#')
	98	bunker[b][a] = 1;
	99	else
	100	bunker[b][a] = 0;
	101	}
	102	}
	103
	104	// display bunkers sprite
	105	bunkersDisplay(&bunker[0][0]);
	106	}
	107
	108	/**
	109	* move aliens and test if they've reached the
	110	* bottom of the windows or the bunkers.
	111	*/
	112	int aliensMove()
	113	{
	114
	115	int cx,cy;
	116	int fReachedPlayer=0; // return value
	117
	118	render();
	119	aliensClear(aliens.posX, aliens.posY, aliens.right, aliens.bottom); // clear old position of aliens
	120
	121	aliens.posX = aliens.posX + aliens.speed; // move aliens left/ right
	122
	123	// when aliens reached left or right screen-border
	124	if (aliens.posX == (BUNKERWIDTH + BUNKERX - 5 - aliens.right) \|\| aliens.posX == (BUNKERX + aliens.left)) {
	125
	126	aliens.posY++; // move aliens downwards
	127
	128	// aliens reached player
	129	if (aliens.posY == SCREENHEIGHT - 2 - aliens.bottom) {
	130	fReachedPlayer = 1; // set return value
	131	}
	132
	133	// aliens reached bunkers //funzt nicht ganz: todo
	134	if (aliens.posY == BUNKERY - aliens.bottom) {
	135	// clear bunkers
	136	for(cx=0;cx<BUNKERWIDTH;cx++) {
	137	for(cy=0;cy<BUNKERHEIGHT;cy++) {
	138	bunker[cy][cx]=0;
	139	}
	140	}
	141	bunkersClear(); // clear bunkers sprites
	142	}
	143
	144	aliens.speed = aliens.speed * (-1); // change direction of aliens' movements
	145	}
	146
	147	aliensDisplay(aliens.posX, aliens.posY, aliens.right, aliens.bottom); // display aliens at new position
	148
	149	return fReachedPlayer; // return if aliens reached player
	150	}
	151
	152
	153	/**
	154	* display alien animation, display remaining parts of aliens and bunker
	155	*/
	156	void render()
	157	{
	158	int k,row;
	159	int c=0;
	160
	161	// calculate left, right, bottom, lowest_ship
	162	aliens.left=1;
	163	aliens.right=-1;
	164	aliens.bottom=-1;
	165	shipnum=0;
	166	for (k=0;k<11;k++) {
	167	lowest_ship[k]=-1;
	168	}
	169
	170	for (row=0;row<ALIENS_MAX_NUMBER_Y*2;row++) {
	171	if ((row%2)==0){
	172	for (k=0;k<ALIENS_MAX_NUMBER_X;k++) {
	173	if (alienBlock[c][k] != 0) {
	174	lowest_ship[k]=row;
	175	shipnum++;
	176	if (aliens.left==1 \|\| -k>aliens.left) {aliens.left=-k;}
	177	if (aliens.right==-1 \|\| k>aliens.right) {aliens.right=k;}
	178	if (aliens.bottom==-1 \|\| c>aliens.bottom) {aliens.bottom=c;}
	179	}
	180	}
	181	} else {
	182	c++;
	183	}
	184	}
	185	aliens.bottom=aliens.bottom*2; // every 2nd row is an empty row
	186	aliens.left=aliens.left*3; // alien sprite is 3 chars wide
	187	aliens.right=aliens.right*3; // alien sprite is 3 chars wide
	188
	189	// display remaining aliens with animation
	190	aliensRefresh(level, &alienBlock[0][0]);
	191
	192	}
	193
	194
	195	/**
	196	* move aliens' missiles and do player/bunker hit testing
	197	* a zero value in alienshotx indicates that the appropriate missile is loaded, but not fired
	198	*/
	199	int aliensMissileMove()
	200	{
	201	int i, tmp;
	202	int fPlayerWasHit = 0;
	203	int shootThreshold;
	204	static int alienshot_counter = 0;
	205
	206
	207	// calculate threshold when next missile should be fired
	208	// it is done here to save calculation time in for-instruction
	209	shootThreshold = (skill_level * 8) * (shipnum + 2);
	210	alienshot_counter = alienshot_counter + 10 ;
	211
	212	// loop all possible missiles
	213	for (i = 0; i < ALIENS_MAX_MISSILES; i++) {
	214
	215	// if the current missile is flying we should do movements
	216	if (alienshotx[i] != 0) {
	217
	218	aliensMissileClear(alienshotx[i],alienshoty[i]); // clear old position
	219
	220	// if missile hit the bunkers
	221	if (bunkersHitCheck(alienshotx[i], alienshoty[i]) == 1) {
	222	alienshotx[i] = 0; // value of zero reloads missile
	223	}
	224
	225	alienshoty[i]++; // move missile downwards
	226
	227	// check if player was hit by an alien missile
	228	if (playerHitCheck(alienshotx[i], alienshoty[i]) == 1) {
	229	alienshotx[i] = 0; // value of zero reloads missile
	230	fPlayerWasHit = 1;
	231	}
	232
	233
	234	} else { // missile not launched yet
	235
	236	// start new missile if counter says so
	237	if (alienshot_counter > shootThreshold && shipnum > 0) {// only shot if there's an alien left
	238	alienshot_counter = 0; // reset counter
	239	tmp = random() % ALIENS_MAX_NUMBER_X; // randomly select one of the ...
	240	while (lowest_ship[tmp] == -1) { // ...aliens at the bottom of ...
	241	tmp = random() % ALIENS_MAX_NUMBER_X; // ...a column to launch missile
	242	}
	243	alienshoty[i]=aliens.posY+lowest_ship[tmp]; // set y position of missile
	244	alienshotx[i]=aliens.posX+tmp*3; // set x position of missile
	245	}
	246	} // if
	247
	248	// display missiles if still running or just launched; could have been modified in the above code
	249	if (alienshotx[i] != 0) {
	250	// if missile is out of battlefield
	251	if (alienshoty[i] == SCREENHEIGHT - 1) {
	252	alienshotx[i] = 0; // reload missile
	253	} else {
	254	aliensMissileDisplay(alienshotx[i], alienshoty[i]); // display Missile at new position
	255	}
	256	}
	257
	258	} // for
	259
	260
	261	return fPlayerWasHit;
	262	}
	263
	264
	265
	266	/**
	267	* check if missile hit an alien
	268	*/
	269	int aliensHitCheck(int shotx, int shoty)
	270	{
	271	int alienType = 0;
	272	int shipx, shipy;
	273	// if missile is within alien-rectangle
	274	if (shotx >= aliens.posX && shotx <= aliens.posX + ALIENS_MAX_NUMBER_X * 3 - 1
	275	&& shoty >= aliens.posY && shoty <= aliens.posY + (ALIENS_MAX_NUMBER_Y - 1) * 2) {
	276	// calculate the ship that was hit
	277	shipx = (shotx - aliens.posX) / 3;
	278	shipy = (shoty - aliens.posY) / 2;
	279	// if there is still a ship at this position
	280	alienType = alienBlock[shipy][shipx];
	281	if (alienType != 0) {
	282	alienBlock[shipy][shipx] = 0; // delete alien ship
	283	}
	284	}
	285	return alienType; // returns 0 if no alien was hit, else returns type-code of alien
	286	}
	287
	288	/**
	289	* check if missile hit an element of bunker
	290	*/
	291	int bunkersHitCheck(int shotx, int shoty)
	292	{
	293	int adjx, adjy;
	294	int fBunkerWasHit = 0;
	295	// if missile is within bunker-rectangle
	296	if (shotx >= BUNKERX && shotx < BUNKERX + BUNKERWIDTH
	297	&& shoty >= BUNKERY && shoty < BUNKERY + BUNKERHEIGHT) {
	298	// calculate the element of the bunker that was hit
	299	adjy = shoty - BUNKERY;
	300	adjx = shotx - BUNKERX;
	301	// if there is still an element
	302	if(bunker[adjy][adjx] == 1){
	303	bunker[adjy][adjx] = 0; // delete element
	304	fBunkerWasHit = 1; // bunker was hit!
	305	}
	306	}
	307	return fBunkerWasHit;
	308	}