Ejemplo n.º 1
0
Archivo: ship.c Proyecto: kiddos/meteor
void ship_destroy(ship *s) {
  if (s != NULL) {
    if (s->bitmap) {
      al_destroy_bitmap(s->bitmap);
    }
    if (s->bullets) {
      bullet_destroy(s->bullets);
    }

    regular_message("destroy ship object");
    free(s);
  }
}
Ejemplo n.º 2
0
Archivo: ship.c Proyecto: kiddos/meteor
void ship_reset(ship *s, const size window_size) {
  if (s != NULL) {
    ALLEGRO_CONFIG *config = al_load_config_file(CONFIG_FILE_PATH);
    if (config != NULL) {
      // reset ship attributes
      s->attr.lives = SHIP_STARTING_LIVES;
      s->attr.mana = SHIP_MAX_MANA;
      s->attr.level = atoi(al_get_config_value(config,
                                                CONFIG_SHIP_SECTION,
                                                CONFIG_SHIP_LEVEL_KEY));
      s->attr.damage = SHIP_STARTING_DAMAGE;
      s->attr.is_buffed = false;
      s->attr.is_immune = false;
      s->attr.time_stamp = 0;
      al_destroy_config(config);
    }

    s->center.x = window_size.w / 2;
    s->center.y = window_size.h / 2;
    s->v.dx = 0;
    s->v.dy = 0;
    s->direction = velocity_compute_direction(s->v);
    s->speed = velocity_compute_speed(s->v);

    // destroy bullets
    bullet_destroy(s->bullets);
    s->bullets = NULL;
    s->bullet_count = 0;

    // reset movement
    s->m.movement[UP] = false;
    s->m.movement[DOWN] = false;
    s->m.movement[LEFT] = false;
    s->m.movement[RIGHT] = false;
  } else {
    error_message("ship object null pointer");
  }
}
Ejemplo n.º 3
0
void Game::gra()
{
	srand(time(0));
	
	
	///////////////////////////////
	Texture tekstura_cel;			//wczytanie tekstur i dzwiêków i tekstów
	tekstura_cel.loadFromFile("data/cel.png");
	Texture tekstura_z;
	tekstura_z.loadFromFile("data/zombie_after_attack_rect.png");
	Texture tekstura;
	tekstura.loadFromFile("data/ground.png");
	Texture tekstura_bl;
	tekstura_bl.loadFromFile("data/blood.png");
	Texture tekstura_zombie_bl;
	tekstura_zombie_bl.loadFromFile("data/zombie_after_attack_rect.png");
	Texture tekstura_zombie_aa;
	tekstura_zombie_aa.loadFromFile("data/zombie_after_attack_rect.png");
	Texture tekstura_zombie_full;
	tekstura_zombie_full.loadFromFile("data/zombie_after_attack_rect.png");
	Texture tekstura_gun;
	tekstura_gun.loadFromFile("data/gun.png");
	Texture tekstura_bullet;
	Texture tekstura_floor;
	tekstura_floor.loadFromFile("data/floor.png");
	Texture tekstura_ak_47;
	tekstura_ak_47.loadFromFile("data/ak_47.png");
	tekstura_bullet.loadFromFile("data/bullet.png");
	Texture tekstura_corps;
	tekstura_corps.loadFromFile("data/corps.png");
	Texture tekstura_ammo;
	tekstura_ammo.loadFromFile("data/ammo_pickup.png");
	Texture tekstura_hp;
	tekstura_hp.loadFromFile("data/hp_pickup.png");
	Texture tekstura_wall;
	tekstura_wall.loadFromFile("data/wall.jpg");
	tekstura_wall.setRepeated(true);
	SoundBuffer buffer, buffer_z;
	buffer_z.loadFromFile("data/hit.wav");
	buffer.loadFromFile("data/shot.wav");
	Sound sound, sound_hit;
	sound.setBuffer(buffer);
	sound_hit.setBuffer(buffer_z);
	SoundBuffer zombie_bite;
	zombie_bite.loadFromFile("data/zombie_bite.wav");
	Sound sound_bite;
	sound_bite.setBuffer(zombie_bite);
	SoundBuffer reload_wav, ammo_out;
	reload_wav.loadFromFile("data/long_reload.wav");
	ammo_out.loadFromFile("data/out_of_ammo.wav");
	SoundBuffer health_wav, ammo_wav;
	health_wav.loadFromFile("data/health.wav");
	ammo_wav.loadFromFile("data/ammo.wav");
	Sound health_collect, ammo_collect;
	health_collect.setBuffer(health_wav);
	ammo_collect.setBuffer(ammo_wav);
	SoundBuffer ak_shot;
	ak_shot.loadFromFile("data/AK_47_shot.wav");
	Sound ak;
	ak.setBuffer(ak_shot);
	Sound sound_reload, sound_ammo_out;
	sound_reload.setBuffer(reload_wav);
	sound_ammo_out.setBuffer(ammo_out);
	Music muzyka;
	muzyka.openFromFile("data/COD4_theme.wav");
	muzyka.setLoop(true);
	muzyka.play();
	
	Font font;
	font.loadFromFile("data/font_UI.ttf");
	Text hp;
	hp.setFont(font);
	hp.setCharacterSize(25);
	hp.setColor(Color(138, 7, 7));
	Text round;
	round.setCharacterSize(25);
	round.setFont(font);
	round.setColor(Color(138, 7, 7));
	Text gun_name;
	gun_name.setCharacterSize(25);
	gun_name.setFont(font);
	gun_name.setColor(Color(138, 7, 7));
	Text bullets_Left;
	bullets_Left.setFont(font);
	bullets_Left.setCharacterSize(25);
	bullets_Left.setColor(Color(138, 7, 7));
	Text licznik_zombie;
	licznik_zombie.setFont(font);
	licznik_zombie.setCharacterSize(25);
	licznik_zombie.setColor(Color(138, 7, 7));
	////////////////////////////////
	
	Sprite celownik;
	celownik.setScale(0.045, 0.045);
	celownik.setTexture(tekstura_cel);
	celownik.setOrigin(celownik.getLocalBounds().width/2.0f, celownik.getLocalBounds().height/ 2.0f);

	RectangleShape sprint_ui;
	sprint_ui.setSize(Vector2f(15 * 5, 15));
	sprint_ui.setFillColor(Color(138, 7, 7));


	/////////////////////////// tablice obiektów
	vector<Blood> tab_bl;
	vector < Bullet > tab; //tablica przechowuj¹ca pociski
	vector <Zombie> tab_z; //zombie
	deque <Vector2f> tab_p;//pozycje gracza z ostatnich 100 klatek
	vector <Corps> tab_corps;
	vector <Ammo_Pickup> tab_am;
	vector <Hp_Pickup> tab_hp;
	

	Sprite map(tekstura);
	tekstura.setRepeated(true);
	map.setTextureRect(IntRect(0, 0, 10000, 10000));
	map.setOrigin(5000,5000);
	map.setPosition(0, 0);
	
	Sprite floor;
	floor.setPosition(-500, -480);
	floor.setTexture(tekstura_floor);
	tekstura_floor.setRepeated(true);
	floor.setTextureRect(IntRect(0, 0, 1000, 980));
	
	vector<RectangleShape> tab_wall;
	for (int i = 0; i < 12; i++)
	{
		RectangleShape wall;
		wall.setFillColor(Color(7, 138, 7, 100));
		
		
		if (i == 0)
		{
			wall.setPosition(-1000, -1000);
			//wall.setFillColor(Color::White);
		}
		else if (i == 1) {
			wall.setPosition(-1000, 1000);
			//wall.setFillColor(Color::Red);
		}
		else if (i == 2) {
			wall.setPosition(-1100, -1000);
			//wall.setFillColor(Color::Cyan);
		}
		else if (i == 3) {
			//wall.setOrigin(100, 0);
			wall.setPosition(1000, -1000);
			//wall.setFillColor(Color::Blue);
		}
		if (i == 0 || i == 1)wall.setSize(Vector2f(2000, 100));
		else if (i == 2 || i == 3)wall.setSize(Vector2f(100, 2100));
		if (i == 4)
		{
			wall.setPosition(-500,-500);

		}
		else if (i == 5)
		{
			wall.setPosition(-520,500);

		}
		else if (i == 6)
		{
			wall.setPosition(-520, -500);

		}
		else if (i == 7)
		{
			wall.setPosition(500, -500);

		}
		if (i == 4 || i == 5)wall.setSize(Vector2f(1020, 20));
		else if (i == 6 || i == 7)wall.setSize(Vector2f(20, 1020));
		
		if (i == 8)
		{
			wall.setPosition(-100, -489);
			wall.setFillColor(Color(138, 7, 7, 150));
		}
		else if (i == 9)
		{
			wall.setPosition(-100, 510);
			wall.setFillColor(Color(138, 7, 7, 150));
		}
		else if (i == 10)
		{
			wall.setPosition(-509, -100);
			wall.setFillColor(Color(138, 7, 7, 150));
		}
		else if (i == 11)
		{
			wall.setPosition(510, -100);
			wall.setFillColor(Color(138, 7, 7,150));
		}
		if (i == 8 || i == 9)wall.setSize(Vector2f(100, 6));
		else if (i == 10 || i == 11)wall.setSize(Vector2f(6, 100));
		if (i == 8 || i == 9 || i == 10 || i == 11)wall.setOrigin(wall.getLocalBounds().width / 2.0f, wall.getLocalBounds().height / 2.0f);

		tab_wall.push_back(wall);

	}
	
	
	Player gracz;
	gracz.body.setPosition(0,0);


	int runda = 1;

	float vx = 0, vy = 0; //prêdkoœæ gracza
	float angle;
	float sprint = 1;

	Clock zombie_player_collisionTimer;
	Clock reload_time;
	Clock zombie_generator_timer;
	Clock zegar;
	Time czas;
	Event event;
	float x, y; //x,y myszy
	okno.setMouseCursorVisible(false);
	int max_zombie_per_round;
	int generated_zombie=0;
	bool generate = true;
	bool menu = false;
	bool canReload = false;
	bool canShoot = true;
	bool Rpressed = false;
	bool isSprint = false;
	bool canSprint = true;
	int zombies_killed_in_round = 0;
	zombie_generator_timer.restart();

	Gun *wsk_gun;
	

	Gun pistol("colt .45", 80.0f,16.0f,2000.0f,2.0f,tekstura_bullet, tekstura_gun,Vector2f(2,2), Vector2f (1,1),gracz.body.getPosition(),0.1);
	Gun ak_47("ak 47", 120.0f, 30.0f, 2800.0f, 2.0f, tekstura_bullet, tekstura_ak_47, Vector2f(2, 2), Vector2f(1, 1), gracz.body.getPosition(),0.08f);
	//view.zoom(1.0f/1.2f);
	//view.zoom(1.0f / 1.2f);
	wsk_gun = &pistol;
	while (!menu)
	{
		//cout << tab_z.size() << " | "<< wsk_gun->bullets_fired.size() <<endl;
		
		gracz.canMoveDown = true;
		gracz.canMoveUP= true;
		gracz.canMoveRight = true;
		gracz.canMoveLeft = true;
		max_zombie_per_round = runda * 4 * 7 ;
		
		if (generated_zombie >= max_zombie_per_round)
		{
			generate = false;
			
		}
		if (!generate&&tab_z.empty())
		{
			zombies_killed_in_round = 0;
			generated_zombie = 0;
			generate = true;
			runda++;

		}
			if (generate && (zombie_generator_timer.getElapsedTime().asSeconds() >= 1.0f)) {
				zombie_generator_timer.restart();
					
						
						if (tab_z.size() <=20)
						{
							generated_zombie += 4;
						zombie_generator(tab_z, Vector2f((tab_wall[0].getPosition().x + rand() % ((int)tab_wall[0].getGlobalBounds().width + 1)), (tab_wall[0].getPosition().y + tab_wall[0].getGlobalBounds().height)), tekstura_z, runda, tab_wall[8].getPosition());
						zombie_generator(tab_z, Vector2f((tab_wall[1].getPosition().x + rand() % ((int)tab_wall[1].getGlobalBounds().width + 1)), (tab_wall[1].getPosition().y + tab_wall[1].getGlobalBounds().height)), tekstura_z, runda, tab_wall[9].getPosition());
						zombie_generator(tab_z, Vector2f((tab_wall[2].getPosition().x + tab_wall[2].getGlobalBounds().width), (tab_wall[2].getPosition().y + rand() % ((int)tab_wall[2].getGlobalBounds().height + 1))), tekstura_z, runda, tab_wall[10].getPosition());
						zombie_generator(tab_z, Vector2f((tab_wall[3].getPosition().x + tab_wall[3].getGlobalBounds().width), (tab_wall[3].getPosition().y + rand() % ((int)tab_wall[3].getGlobalBounds().height + 1))), tekstura_z, runda, tab_wall[11].getPosition());
						
						/*zombie_generator(tab_z, Vector2f((tab_wall[0].getPosition().x + rand() % ((int)tab_wall[0].getGlobalBounds().width + 1)), (tab_wall[0].getPosition().y + tab_wall[0].getGlobalBounds().height)), tekstura_z, runda, Vector2f(0,0));
						zombie_generator(tab_z, Vector2f((tab_wall[1].getPosition().x + rand() % ((int)tab_wall[1].getGlobalBounds().width + 1)), (tab_wall[1].getPosition().y + tab_wall[1].getGlobalBounds().height)), tekstura_z, runda, Vector2f(0,0));
						zombie_generator(tab_z, Vector2f((tab_wall[2].getPosition().x + tab_wall[2].getGlobalBounds().width), (tab_wall[2].getPosition().y + rand() % ((int)tab_wall[2].getGlobalBounds().height + 1))), tekstura_z, runda, Vector2f(0,0));
						zombie_generator(tab_z, Vector2f((tab_wall[3].getPosition().x + tab_wall[3].getGlobalBounds().width), (tab_wall[3].getPosition().y + rand() % ((int)tab_wall[3].getGlobalBounds().height + 1))), tekstura_z, runda, Vector2f(0,0));
*/
						}
						/*else
						{
							generated_zombie += 4;
							zombie_generator(tab_z, Vector2f((tab_wall[4].getPosition().x + rand() % ((int)tab_wall[4].getGlobalBounds().width + 1)), (tab_wall[4].getPosition().y + tab_wall[4].getGlobalBounds().height)), tekstura_z, runda);
							zombie_generator(tab_z, Vector2f((tab_wall[5].getPosition().x + rand() % ((int)tab_wall[5].getGlobalBounds().width + 1)), (tab_wall[5].getPosition().y + tab_wall[5].getGlobalBounds().height)), tekstura_z, runda);
							zombie_generator(tab_z, Vector2f((tab_wall[6].getPosition().x + tab_wall[6].getGlobalBounds().width), (tab_wall[6].getPosition().y + rand() % ((int)tab_wall[6].getGlobalBounds().height + 1))), tekstura_z, runda);
							zombie_generator(tab_z, Vector2f((tab_wall[7].getPosition().x + tab_wall[7].getGlobalBounds().width), (tab_wall[7].getPosition().y + rand() % ((int)tab_wall[7].getGlobalBounds().height + 1))), tekstura_z, runda);
						}*/
					
					
			}
		
			
			
		
		

		view.setCenter(gracz.body.getPosition()); //gracz ca³y czas w centrum widoku
		

		x = (float)Mouse::getPosition(okno).x+view.getCenter().x-1280/2, y = (float)Mouse::getPosition(okno).y+view.getCenter().y-720/2; //zapisanie pozycji myszy wzglêdem lewgo górnego rogu widoku
		
		celownik.setPosition(x, y); //przypisanie pozycji celownika 

		angle = (float)atan2((float)(y - gracz.body.getPosition().y), (float)(x - gracz.body.getPosition().x)) * 180.0f / (float)M_PI - 90.0f; //zapisanie k¹t miêdzy œrodkiem ekranu a pozycj¹ myszy
		gracz.body.setRotation(angle);		//obrócenie gracza w kierunku myszy
		
		cout <<x << " | "<< y << endl;
		
		/////////////////////////////
		if (tab_p.size() != 30)				//wype³nienie tablicy pozycjami gracza z ostatnich stu klatek (czyli 1 sekundy)
		tab_p.push_back(gracz.body.getPosition());

		if (tab_p.size() == 30)
		{	
			tab_p.pop_front();
			tab_p.push_back(gracz.body.getPosition());
		}
		///////////////////////////////
		
		while (okno.pollEvent(event))
		{

			if (event.type == Event::Closed || event.type == Event::KeyPressed &&
				event.key.code == Keyboard::Escape)
				menu = true;
			
			//if (event.type == Event::MouseButtonPressed && Mouse::isButtonPressed(Mouse::Right))//stworzenie zombie i dodanie go do tablicy
			//{

			//	Zombie zombie(x, y, tekstura_z,rand()%51+50, 1+runda);
			//	tab_z.push_back(zombie);

			//}
			if (wsk_gun==&pistol) {
				if (event.type == Event::MouseButtonPressed && Mouse::isButtonPressed(Mouse::Left))//stworzenie pocisku i dodanie go do tablicy
				{
					if (wsk_gun->magazynek == 0)
					{
						sound_ammo_out.play();
						if (wsk_gun->bulletsLeft != 0 && !wsk_gun->reload_demand&& !wsk_gun->reloading)
						{
							sound_reload.play();
							wsk_gun->reload_demand = true;
						}
					}
					else if (!wsk_gun->reloading)
					{
						sound.play();
						wsk_gun->shoot(gracz.body.getPosition());


						wsk_gun->magazynek--;

					}
					else {
						sound_ammo_out.play();
					}
				}
			}
			
		
				if (event.type == Event::MouseButtonPressed && Mouse::isButtonPressed(Mouse::Left) && (wsk_gun->magazynek == 0 || wsk_gun->reloading || wsk_gun->reload_demand))
					sound_ammo_out.play();
			

			
				if (event.type == Event::KeyPressed && event.key.code == Keyboard::R && wsk_gun->bulletsLeft != 0 && wsk_gun->magazynek != wsk_gun->magazynekSize &&!wsk_gun->reloading&& !wsk_gun->reload_demand)
				{
					wsk_gun->reload_demand = true;
					sound_reload.play();
				}

				if (event.type == Event::KeyPressed && event.key.code == Keyboard::Num1)
				{ 
					wsk_gun = &pistol;
					//buffer = wsk_gun->shot;
				}
				if (event.type == Event::KeyPressed && event.key.code == Keyboard::Num2) 
				{
					wsk_gun = &ak_47;
					//buffer = wsk_gun->shot;
				}
			if (event.type == Event::KeyPressed && event.key.code == Keyboard::Up)view.zoom(1.2f);
			if (event.type == Event::KeyPressed && event.key.code == Keyboard::Down)view.zoom(1.0f/1.2f);
			
		}
		/////// strza³ pistoletem
		

		if (wsk_gun != &pistol) {
			if (wsk_gun->fire_timer.getElapsedTime().asSeconds() >= wsk_gun->fireRate) {
				if (Mouse::isButtonPressed(Mouse::Left))//stworzenie pocisku i dodanie go do tablicy
				{
					if (wsk_gun->magazynek == 0)
					{

						if (wsk_gun->bulletsLeft != 0 && !wsk_gun->reload_demand&& !wsk_gun->reloading)
						{
							sound_reload.play();
							wsk_gun->reload_demand = true;
						}
					}
					else if (!wsk_gun->reloading)
					{
					sound.play();
						wsk_gun->shoot(gracz.body.getPosition());


						wsk_gun->magazynek--;


					}
					/*else {
						sound_ammo_out.play();
					}*/
				}
				wsk_gun->fire_timer.restart();
			}
			
		}
		wsk_gun->update(angle, czas, gracz.body.getPosition());

		if(!tab_z.empty())//zombie update
		{
			for (int i = 0; i < tab_z.size(); i++)
				tab_z[i].update(gracz.body.getPosition(), czas,tab_p[0]);
		}
		//if (!tab.empty())//obrócenie zombie w kierunku pozycji gracz z przed sekundy
		//{
		//	for (int i = 0; i < tab.size(); i++)
		//		tab[i].rotate();
		//}
	
		
		
		//////////////////////////////////////kolizja
		
		// kolizja zombie-gracz	
			for (int i = 0; i < tab_z.size(); i++)
			{
				//if(gracz.body.getGlobalBounds().intersects(tab_z[i].body.getGlobalBounds()))
				if (Collision::PixelPerfectTest(gracz.body, tab_z[i].body))
				{
					tab_z[i].collidesWithPlayer = true;
					if ((tab_z[i].body.getPosition().y > gracz.body.getPosition().y >0) || (gracz.body.getPosition().y <tab_z[i].body.getPosition().y <0))
					{
						gracz.canMoveDown = false;
						//gracz.body.move(0, -1);
					}

					if ((gracz.body.getPosition().y >tab_z[i].body.getPosition().y >0) || (tab_z[i].body.getPosition().y < gracz.body.getPosition().y <0))
					{
					
						gracz.canMoveUP = false;
						//gracz.body.move(0, 1);
					}
					
					 if ((tab_z[i].body.getPosition().x > gracz.body.getPosition().x >0)||(gracz.body.getPosition().x <tab_z[i].body.getPosition().x <0))
					{
						gracz.canMoveRight = false;
						//gracz.body.move(-1, 0);
						
					}
					
					 if ((gracz.body.getPosition().x >tab_z[i].body.getPosition().x >0)||(tab_z[i].body.getPosition().x < gracz.body.getPosition().x <0))
					{
						gracz.canMoveLeft = false;
						//gracz.body.move(1, 0);
					}
					
					
					if (zombie_player_collisionTimer.getElapsedTime().asSeconds() >= 0.5) {
						zombie_player_collisionTimer.restart();
					
						sound_bite.play();
						//cout << gracz.healthPoints << endl;
						if (tab_z[i].healthPoints < 3)tab_z[i].body.setTexture(tekstura_zombie_full);
						else tab_z[i].body.setTexture(tekstura_zombie_aa);
						tab_z[i].haveAttacked = true;
						gracz.healthPoints--;
						if (gracz.healthPoints == 0)
						{
							menu = true;
						}
						break;
					}
				}
				else tab_z[i].collidesWithPlayer = false;
			}
		
			// kolizja zombie-zombie
		if (!tab_z.empty())
		{
			for (int i = 0; i < tab_z.size(); i++)
			{
				for (int j = 0; j < tab_z.size(); j++)
				{
					if (i != j)
					{	
						//if (tab_z[j].body.getGlobalBounds().intersects( tab_z[i].body.getGlobalBounds()))
						if (Collision::PixelPerfectTest(tab_z[j].body, tab_z[i].body))
						{
							if (fabs(tab_z[i].body.getPosition().x - gracz.body.getPosition().x) + fabs(tab_z[i].body.getPosition().y - gracz.body.getPosition().y)
				>fabs(tab_z[j].body.getPosition().x - gracz.body.getPosition().x) + fabs(tab_z[j].body.getPosition().y - gracz.body.getPosition().y))
							{
								tab_z[i].collide_parameter = 0;
								tab_z[j].collide_parameter = 1.2;

							}
							else
							{
								tab_z[j].collide_parameter = 0;
								tab_z[i].collide_parameter = 1.2;
							}
							tab_z[i].col_in = true;
							tab_z[j].col_in = true;
							break;
						}


					}

				}
			}


		}
		// kolizja gracz-œciana
		if (tab_wall[4].getGlobalBounds().intersects(gracz.body.getGlobalBounds()))
		{
			gracz.canMoveUP = false;

			sprint = 1;
			//vx = 0;
			//gracz.body.move(0, 1);
			//gracz.canMoveUP = true;
		}
	
		if (tab_wall[5].getGlobalBounds().intersects(gracz.body.getGlobalBounds()))
		{
			sprint = 1;
			gracz.canMoveDown = false;
			//vx = 0;
			//gracz.body.move(0, -1); 
			//gracz.canMoveDown = true;
		}
	 
		if (tab_wall[6].getGlobalBounds().intersects(gracz.body.getGlobalBounds()))
		{
			sprint = 1;
			gracz.canMoveLeft = false;
			//vy = 0;
			//gracz.body.move(1, 0);
			//gracz.canMoveRight = true;
		}
		  
		if (tab_wall[7].getGlobalBounds().intersects(gracz.body.getGlobalBounds()))
		{
			sprint = 1;
			gracz.canMoveRight= false;
			//vy = 0;
			//gracz.body.move(-1, 0);
			//gracz.canMoveLeft = true;
		}
		 

		
		///////////kolizja zombie pocisk
		
			if (!tab_z.empty() && !wsk_gun->bullets_fired.empty())				//zniszczenie pocisku i zombie w przypadku kolizji
			{
				for (int i = 0; i < wsk_gun->bullets_fired.size(); i++)
				{
					for (int j = 0; j < tab_z.size(); j++)
					{
						if (wsk_gun->bullets_fired[i].body.getGlobalBounds().intersects(tab_z[j].body.getGlobalBounds()))
						{
							sound_hit.play();

							bullet_destroy(wsk_gun->bullets_fired, i);

							Blood krew(tekstura_bl, tab_z[j].body.getPosition());
							krew.body.setRotation((rand() % 360) + 1);
							tab_bl.push_back(krew);

							tab_z[j].healthPoints--;
							if (tab_z[j].healthPoints == 1)
							{
								tab_z[j].setSpeed(80.0f);
								if (tab_z[j].haveAttacked == true)tab_z[j].body.setTexture(tekstura_zombie_full);
								else tab_z[j].body.setTexture(tekstura_zombie_bl);
							}
							if (tab_z[j].healthPoints == 0)
							{	//œmieræ zombie
								Corps corpses(tekstura_corps, tab_z[j].body.getPosition(), tab_z[j].rotate_angle);
								tab_corps.push_back(corpses);
								if (tab_z[j].isInside)
								{
									Ammo_Pickup am(tekstura_ammo, tab_z[j].body.getPosition());
									Hp_Pickup hp(tekstura_hp, tab_z[j].body.getPosition());
									switch (rand() % 10)
									{
									case 0:
										tab_am.push_back(am);
										break;
									case 1:
										tab_am.push_back(am);
										break;
							


									case 5:
										if (gracz.healthPoints < 5)tab_hp.push_back(hp);
										break;

									}
								}
								tab_z[j] = tab_z[tab_z.size() - 1];
								tab_z.pop_back();
								zombies_killed_in_round++;

							}

							break;
						}


					}
				}
			}
		
		//kolizja gracz-ammo_pickup
		for (int i = 0; i < tab_am.size(); i++)
		{
			if (gracz.body.getGlobalBounds().intersects(tab_am[i].body.getGlobalBounds()))
			{	
				ammo_collect.play();
				
					wsk_gun->bulletsLeft += tab_am[i].add_ammo;
				
				ammo_destroy(tab_am, i);
			}
		}

		//kolizja gracz-hp_pickup
		for (int i = 0; i < tab_hp.size(); i++)
		{
			if (gracz.body.getGlobalBounds().intersects(tab_hp[i].body.getGlobalBounds()))
			{
				
				if (gracz.healthPoints + tab_hp[i].add_hp <= 5)
				{
					health_collect.play();
					gracz.healthPoints += tab_hp[i].add_hp;
					hp_destroy(tab_hp, i);
				}
			}
		}
		////////////////////////////////////////
		for (int j = 4; j < tab_wall.size()-4;j++)
		for (int i = 0; i < wsk_gun->bullets_fired.size(); i++)
		{

			if (wsk_gun->bullets_fired[i].body.getGlobalBounds().intersects(tab_wall[j].getGlobalBounds()))
				bullet_destroy(wsk_gun->bullets_fired, i);
		}
		for (int j = 8; j < tab_wall.size(); j++)
			for (int i = 0; i < tab_z.size(); i++)
				if (tab_z[i].body.getGlobalBounds().intersects(tab_wall[j].getGlobalBounds()))tab_z[i].isInside = true;

			for (int i = 0; i < wsk_gun->bullets_fired.size(); i++)
			{
				if (wsk_gun->bullets_fired[i].onCreate_clock.getElapsedTime().asSeconds() >= wsk_gun->bullets_fired[i].lifeTime)
				{
					bullet_destroy(wsk_gun->bullets_fired, i);
				}
			}
		
		for (int i = 0; i < tab_bl.size(); i++)
		{
			if (tab_bl[i].onCreate_clock.getElapsedTime().asSeconds() >= tab_bl[i].lifeTime)
			{
				blood_destroy(tab_bl, i);
			}
		}
		for (int i = 0; i < tab_corps.size(); i++)
		{
			if (tab_corps[i].onCreate_clock.getElapsedTime().asSeconds() >= tab_corps[i].lifeTime)
			{
				corps_destroy(tab_corps, i);
			}
		}
		
		for(int i = 0; i < tab_am.size(); i++)
		{
			if (tab_am[i].onCreate_clock.getElapsedTime().asSeconds() >= tab_am[i].lifeTime)
			{
				ammo_destroy(tab_am, i);
			}
		}
		
		for (int i = 0; i < tab_hp.size(); i++)
		{
			if (tab_hp[i].onCreate_clock.getElapsedTime().asSeconds() >= tab_hp[i].lifeTime)
			{
				hp_destroy(tab_hp, i);
			}
		}
		
		///////////////////////////////////////////
		 
			interfejs(gracz.healthPoints, wsk_gun->bulletsLeft, hp, bullets_Left, view.getCenter(), wsk_gun->magazynek, runda, round, max_zombie_per_round - zombies_killed_in_round, licznik_zombie, 
				gun_name, wsk_gun->name, sprint_ui, isSprint&&(tab_p[0]!=gracz.body.getPosition()), czas);
		
		okno.setView(view);
		okno.clear();
		//cout << "Up: " << gracz.canMoveUP << " | Down: " << gracz.canMoveDown << " | Left: " << gracz.canMoveLeft << " | Right: " << gracz.canMoveRight << endl;
		/////////////////////////////////////////////////////
		gracz.input(vx, vy);
		if (Keyboard::isKeyPressed(Keyboard::LShift) && canSprint)
		{
			if (sprint_ui.getSize().x < 1) {
				canSprint = false;
			}
			sprint = 1.5;
			isSprint = true;
		}
		else
		{
			if (sprint_ui.getSize().x >15) {
				canSprint = true;
			}
			sprint = 1;
			isSprint = false;
		}
		//////////////////////////////////////
		//	ruch //

		
		gracz.ruch(czas, vx, vy, sprint);
	

		/*if (!tab_z.empty())
		{

			for (int i = 0; i < tab_z.size(); i++)
			{

				tab_z[i].ruch(tab_p[0], czas);
			}
		}*/

		
		////////////////////////////////
		okno.draw(map);		
		//rysowanie
	
		okno.draw(floor);
			if (!wsk_gun->bullets_fired.empty())
			{
				for (int i = 0; i <wsk_gun->bullets_fired.size(); i++)
					if (!gracz.body.getGlobalBounds().intersects(wsk_gun->bullets_fired[i].body.getGlobalBounds()))
					okno.draw(wsk_gun->bullets_fired[i].body);
			}
		
		if (!tab_bl.empty())
		{
			for (int i = 0; i < tab_bl.size(); i++)
			{
				
				okno.draw(tab_bl[i].body);
				//okno.draw(tab_bl[i].rect);
			}
		}
		if (!tab_corps.empty())
		{
			for (int i = 0; i < tab_corps.size(); i++)
				okno.draw(tab_corps[i].body);
		}
		if (!tab_am.empty())
		{

			for (int i = 0; i < tab_am.size(); i++)
			{
				if(tab_am[i].onCreate_clock.getElapsedTime().asSeconds() < tab_am[i].lifeTime-8.0f)
				okno.draw(tab_am[i].body);
				if (tab_am[i].onCreate_clock.getElapsedTime().asSeconds() >= tab_am[i].lifeTime - 8.0f)
				{
					if (tab_am[i].onCreate_clock.getElapsedTime().asMilliseconds() % 500 >= 0 && tab_am[i].onCreate_clock.getElapsedTime().asMilliseconds() % 500 <= 125) {
						//nie rysij
					}
					else okno.draw(tab_am[i].body);

				}
			}
		}
		if (!tab_hp.empty())
		{

			for (int i = 0; i < tab_hp.size(); i++)
			{
				if (tab_hp[i].onCreate_clock.getElapsedTime().asSeconds() < tab_hp[i].lifeTime - 8.0f)
					okno.draw(tab_hp[i].body);
				if (tab_hp[i].onCreate_clock.getElapsedTime().asSeconds() >= tab_hp[i].lifeTime - 8.0f)
				{
					if (tab_hp[i].onCreate_clock.getElapsedTime().asMilliseconds() % 500 >= 0 && tab_hp[i].onCreate_clock.getElapsedTime().asMilliseconds() % 500 <= 125) {
						//nie rysij
					}
					else okno.draw(tab_hp[i].body);

				}
			}
		}
		if (!tab_z.empty())
		{
			for (int i = 0; i < tab_z.size(); i++)
				okno.draw(tab_z[i].body);
		}
		for (int i = 4; i < tab_wall.size(); i++)
		{
			okno.draw(tab_wall[i]);
		}
		okno.draw(celownik);
		okno.draw(gracz.body);
		//okno.draw(gracz.point);
		okno.draw(wsk_gun->body);

		okno.draw(hp);
		okno.draw(bullets_Left);
		okno.draw(round);
		okno.draw(licznik_zombie);
		okno.draw(gun_name);
		okno.draw(sprint_ui);
		//////////////////////////////////

		View view = okno.getDefaultView();
		okno.display();
		
		czas = zegar.getElapsedTime();
		zegar.restart();

	}
	


}
Ejemplo n.º 4
0
void checkCollisions()
{
  // Check for enemies being shot down
  int x, y, i, j;
  for (y = 0; y < 5; y++)
  {
    for (x = 0; x < 11; x++)
    {
      for (i = 0; i < 10; i++)
      {
        if (bullets[i].active && bullets[i].friendly && enemy[x][y].alive)
        {
          if (checkRectCollision(&bullets[i].rect, &enemy[x][y].rect))
          {
            enemy[x][y].alive = 0;
            enemy[x][y].death_time = SDL_GetTicks();
            enemy_total--;
            Mix_PlayChannel(-1, gShotdown, 0);
            bullet_destroy(i);

            // Increase score based on enemy type
            if (y == 0)
              gScore += 30;
            else if (y == 1 || y == 2)
              gScore += 20;
            else
              gScore += 10;
          }
        }
      }
    }
  }

  // Check if ship was shot down
  for (i = 0; i < 10; i++)
  {
    if (bullets[i].active && !bullets[i].friendly && ship.alive)
    {
      if (checkRectCollision(&bullets[i].rect, &ship.rect))
      {
        ship.alive = 0;
        gLives--;
        Mix_PlayChannel(-1, gShotdown, 0);
        bullet_destroy(i);


        // render explosion (swap between 2 frames)
        SDL_BlitScaled(shipexplosionsurf, NULL, gScreen, &ship.rect);
        SDL_UpdateWindowSurface(gWindow);
        SDL_Delay(100);
        SDL_BlitScaled(shipexplosionsurf2, NULL, gScreen, &ship.rect);
        SDL_UpdateWindowSurface(gWindow);
        SDL_Delay(100);
        SDL_BlitScaled(shipexplosionsurf, NULL, gScreen, &ship.rect);
        SDL_UpdateWindowSurface(gWindow);
        SDL_Delay(100);
        SDL_BlitScaled(shipexplosionsurf2, NULL, gScreen, &ship.rect);
        SDL_UpdateWindowSurface(gWindow);
        SDL_Delay(100);
        SDL_BlitScaled(shipexplosionsurf, NULL, gScreen, &ship.rect);
        SDL_UpdateWindowSurface(gWindow);
        SDL_Delay(100);

        ship_reset();
        enemy_reset();
        defense_reset();
        bullet_reset();
      }
    }
  }

  // Check for bullets shooting down bullets
  for (x = 0; x < 10; x++)
  {
    for (y = 0; y < 10; y++)
    {
      if (bullets[x].active && bullets[y].active && bullets[x].friendly && !bullets[y].friendly && x != y)
      {
        if (checkRectCollision(&bullets[x].rect, &bullets[y].rect))
        {
          bullet_destroy(x);
          bullet_destroy(y);
        }
      }
    }
  }

  // Check if bullets hit defense structures
  for (i = 0; i < 4; i++)
  {
    for (y = 0; y < 2; y++)
    {
      for (x = 0; x < 11; x++)
      {
        for (j = 0; j < 10; j++)
        {
          if (bullets[j].active && (defense[i].state[x][y] < 3))
          {
            if (checkRectCollision(&bullets[j].rect, &defense[i].stretch[x][y]))
            {
              defense[i].state[x][y]++;
              bullet_destroy(j);
            }

          }

        }
      }
    }
  }

  // Check if command ship was shot down
  for (i = 0; i < 10; i++)
  {
    if (bullets[i].active && bullets[i].friendly && command.alive)
    {
      if (checkRectCollision(&bullets[i].rect, &command.rect))
      {
        command.alive = 0;
        command.death_time = SDL_GetTicks();
        Mix_HaltChannel(-1);
        Mix_PlayChannel(-1, gCommandExit, 0);

        bullet_destroy(i);

        gScore += command_points;
      }
    }
  }

  // Check if enemies reach defense structures, game over
  for (i = 0; i < 4; i++)
  {
    for (y = 0; y < 5; y++)
    {
      for (x = 0; x < 11; x++)
      {
        if (enemy[x][y].alive)
        {
          if (checkRectCollision(&defense[i].rect, &enemy[x][y].rect))
          {
            // game over, invaders have invaded
            ship.alive = 0;
            enemy[x][y].alive = 0;
            gLives = 0;
          }
        }
      }
    }
  }
}
Ejemplo n.º 5
0
Archivo: tank.c Proyecto: d11/sdl_tank
///////// GAME /////////////
void do_game()
{

	// Reset timer
	old_time = time;

	// Ask SDL for the time in milliseconds
	time = SDL_GetTicks();

	// Print frame rate
	if (PRINT_FPS && (time_since_fps > 1000)) {
		print_fps();
		time_since_fps = 0;
	} else {
		time_since_fps += time - old_time;
	}

	// Work out how much game time has passed since the previous frame
	float dt = (float)(time - old_time)*GAME_SPEED;

	// Maybe create new bot ** TEMP **
	if (rand()/(float)RAND_MAX < 0.01*dt) {
		spawn_bot(bot, 
					 random_int(DISPLAY_WIDTH - PLAYER_BOUND_WIDTH) + PLAYER_BOUND_WIDTH,
					 random_int(DISPLAY_HEIGHT - PLAYER_BOUND_WIDTH) + PLAYER_BOUND_WIDTH,
					 random_angle());
	}

	// Handle game objects
	do_walls(wal);
	do_player(&plr, bul, wal, dt);
	do_bots(bot, &plr, bul, wal, dt);
	do_bullets(bul, dt);

	// check for collisions between various objects
	int bul_i, bot_i, wall_i;
	for (bul_i = 0; bul_i < BULLET_MAX; bul_i++)
	{
		if (bul[bul_i].ex)
		{
			// Check for player being hit by a bullet
			if (player_hit_by_bullet(&plr, &bul[bul_i]))
			{
				bullet_destroy(&bul[bul_i]);
				player_take_bullet(&plr, &bul[bul_i]);
			}


			// Check for bot being hit by a bullet
			for (bot_i = 0; bot_i < BOT_MAX; bot_i++)
			{
				if (bot_hit_by_bullet(&bot[bot_i], &bul[bul_i]))
				{
					bullet_destroy(&bul[bul_i]);
					bot_take_bullet(&bot[bot_i], &bul[bul_i]);
				}
			}
			
			// Check for wall being hit by a bullet
			for (wall_i = 0; wall_i < WALL_MAX; wall_i++)
			{
				if (wall_hit_by_bullet(&wal[wall_i], &bul[bul_i]))
				{
					bullet_destroy(&bul[bul_i]);
					wall_take_bullet(&wal[wall_i]);
				}
			}
		}
	}


}