コード例 #1
0
ファイル: game.c プロジェクト: jerryxzhang/Kernel-Sanders
/**
 * Returns 1 if the bird at height h collides with an object, 0 otherwise.
 */
int bird_collide(int h) {
    int ret = detect_collision(h, BIRD_POS+3) ||
    detect_collision(h, BIRD_POS) ||
    detect_collision(h+1, BIRD_POS+4) ||
    detect_collision(h+1, BIRD_POS+3) ||
    detect_collision(h+1, BIRD_POS);

    return ret;
}
コード例 #2
0
ファイル: game.cpp プロジェクト: milleniumbug/river_raid
void Game::refresh()
{
	if(level_reset_requested)
		reset_level_commit();
	if(full_reset_requested)
		reset_all_commit();
	for(auto it = actions.begin(); it != actions.end(); )
	{
		if(--it->first == 0)
		{
			it->second();
			actions.erase(it++);
		}
		else
			++it;
	}
	for(auto it1 = entities.begin(); it1 != std::prev(entities.end()); ++it1)
	{
		for(auto it2 = it1; it2 != entities.end(); ++it2)
		{
			if(detect_collision((*it1)->hitbox(), (*it2)->hitbox()))
				(*it1)->collide_with(**it2);
		}
	}
	for(auto& entity : entities)
		if(entity)
		{
			bool should_destroy = entity->refresh(*this);
			if(should_destroy || !detect_collision(entity->hitbox(), current_game_area_hitbox()))
				entity.reset();
		}
	for(auto it = entities_to_activate.begin(); it != entities_to_activate.end();)
	{
		if(!is_it_reachable((*it)->hitbox()))
		{
			auto erased_entity_iterator = it++;
			entities_to_activate.erase(erased_entity_iterator);
		}
		else if(detect_collision((*it)->hitbox(), current_game_area_hitbox()))
		{
			auto moved_entity_iterator = it++;
			entities.push_back(*moved_entity_iterator);
			entities_to_activate.erase(moved_entity_iterator);
		}
		else
			break;

	}
	for(auto& entity : entities_to_add)
		push_to_container(entity);
	entities.erase(std::remove(entities.begin(), entities.end(), nullptr), entities.end());
	entities_to_add.clear();
}
コード例 #3
0
ファイル: breakout.c プロジェクト: praemdonck/space_invaders
// ball paddle collision handler
void ball_paddle(sprite_t* s1, sprite_t* s2)
{
  sprite_t* ball;
  sprite_t* paddle;
  unsigned int collision_direction;

  ball = s1->type == BALL_SPRITE ? s1 : s2;
  paddle = s1->type == PADDLE_SPRITE ? s1 : s2;

  sound_play_fast_invader(0);

  collision_direction = detect_collision(paddle, ball);

  if (collision_direction == NORTH_COLLISION && breakout_data.ball_speed_y > 0 )
    //|| collision_direction == SOUTH_COLLISION )
  {
    breakout_data.ball_speed_y = -breakout_data.ball_speed_y;
    breakout_data.ball_speed_x += breakout_data.paddle_speed_x / 8;
    
    // Make sure the ball is above the paddle to avoid multiple collition between the ball and the paddle      
    ball->center_pos_y = paddle->center_pos_y - (paddle->size_y_div_2 + ball->size_y_div_2);
  }
    

  if (collision_direction == EAST_COLLISION ||
      collision_direction == WEST_COLLISION )
  {
    breakout_data.ball_in_play = false;
    sprite_release(&breakout_sprites_vector, ball);
  }
}
コード例 #4
0
ファイル: breakout.c プロジェクト: praemdonck/space_invaders
// brick ball collision handler
void brick_ball(sprite_t* s1, sprite_t* s2)
{
  sprite_t* ball;
  sprite_t* brick;
  unsigned int collision_direction;

  ball = s1->type == BALL_SPRITE ? s1 : s2;
  brick = s1->type == BRICK_SPRITE ? s1 : s2;

  collision_direction = detect_collision(ball, brick);

  if (collision_direction == NORTH_COLLISION ||
      collision_direction == SOUTH_COLLISION )
    breakout_data.ball_speed_y = -breakout_data.ball_speed_y;

  if (collision_direction == EAST_COLLISION ||
      collision_direction == WEST_COLLISION )
    breakout_data.ball_speed_x = -breakout_data.ball_speed_x;


  ball_tick(ball);
  breakout_data.num_bricks--;
  if (breakout_data.num_bricks)
  {
    //sound_play_enemy_killed();
    sound_play_shoot();
  }
  else
  {
    sound_play_big_explosion(); 
  }

  sprite_release(&breakout_sprites_vector, brick);
}
コード例 #5
0
ファイル: Menu.cpp プロジェクト: Michael-Z/Geometry-Wars
int CMenu::CheckMouseOver()
{
    int mouse_x, mouse_y;
    SDL_GetMouseState(&mouse_x, &mouse_y);

    SDL_Rect mouse = {mouse_x, mouse_y, 0, 0};

    for(size_t i = 0; i < this->Buttons.size(); i++)
    {
        SDL_Rect button = this->Buttons[i]->norm->clip_rect;
        button.x = this->Buttons[i]->x;
        button.y = this->Buttons[i]->y;

        if(detect_collision(mouse, button))
        {
            this->Buttons[i]->active = this->Buttons[i]->high;
            if(IsPressed(SDL_BUTTON_LEFT))
                return this->Buttons[i]->id;
        }
        else
        {
            this->Buttons[i]->active = this->Buttons[i]->norm;
        }
    }

    return -1;
}
コード例 #6
0
ファイル: game.cpp プロジェクト: milleniumbug/river_raid
void Game::push_to_container(std::shared_ptr<Entity> e)
{
	if(!is_it_reachable(e->hitbox()))
		return;
	else if(detect_collision(current_game_area_hitbox(), e->hitbox()))
		entities.push_back(e);
	else
		entities_to_activate.insert(e);
}
コード例 #7
0
ファイル: game.cpp プロジェクト: milleniumbug/river_raid
bool is_land_at(Game& game, Zespolona pozycja)
{
	for(auto& entity : game.active_entities())
	{
		if(dynamic_cast<Land*>(entity.get()))
		{
			bool land = detect_collision(entity->hitbox(), AxisAlignedBoundingBox(pozycja - Zespolona(10, 10), pozycja + Zespolona(10, 10)));
			if(land) return true;
		}
	}
	return false;
}
コード例 #8
0
ファイル: playerSnake.cpp プロジェクト: inge91/2playersnake
// Checks if the snake has bitten itself
bool playerSnake::touched_self(){
    // Locate position of the head
    SDL_Rect locHead = mparts_locations.at(0);
    SDL_Rect part;

    // Now check if the head has collided with other elements of the body
    for(int i = 1; i < mparts_locations.size(); i ++){
        part = mparts_locations.at(i);
        if(detect_collision(locHead, part) == true){
            return true;
        }
    }
    return false;
}
コード例 #9
0
ファイル: entity.c プロジェクト: jfoster39/2110Homework9
// If true, player is dead.
int is_player_dead( EntityClass* player_ship )
{
    for( int i = 0; i < enemy_num; i++ )
    {
        if( enemies[i].row != 0 )
        {
            if( detect_collision( player_ship, &enemies[i] ) == 1 )
            {
                return 1;
            }
        }
    }

    return 0;
}
コード例 #10
0
ファイル: entity.c プロジェクト: jfoster39/2110Homework9
void check_collisions() {
    for( int i = 0; i < max_enemies; i++ )
    {
        for( int j = 0; j < projectile_num; j++ )
        {
            if( detect_collision( &enemies[i], &projectiles[j] ) == 1 )
            {
                enemies[i]     = enemies[max_enemies+1];
                projectiles[j] = projectiles[max_projectiles+1];
                kills++;
                break;
            }
        }
    }
}
コード例 #11
0
ファイル: forces_inline.hpp プロジェクト: Haider-BA/espresso
/** Calculate non bonded forces between a pair of particles.
    @param p1        pointer to particle 1.
    @param p2        pointer to particle 2.
    @param d         vector between p1 and p2. 
    @param dist      distance between p1 and p2.
    @param dist2     distance squared between p1 and p2. */
inline void add_non_bonded_pair_force(Particle *p1, Particle *p2, 
					double d[3], double dist, double dist2)
{
  IA_parameters *ia_params = get_ia_param(p1->p.type,p2->p.type);
  double force[3] = { 0., 0., 0. };
  double torque1[3] = { 0., 0., 0. };
  double torque2[3] = { 0., 0., 0. };
  int j;

  /***********************************************/
  /* bond creation and breaking                  */
  /***********************************************/

#ifdef COLLISION_DETECTION
  if (collision_params.mode > 0)
    detect_collision(p1,p2);
#endif

  /*affinity potential*/
#ifdef AFFINITY
  add_affinity_pair_force(p1,p2,ia_params,d,dist,force);
#endif
  
  FORCE_TRACE(fprintf(stderr, "%d: interaction %d<->%d dist %f\n", this_node, p1->p.identity, p2->p.identity, dist));

  /***********************************************/
  /* thermostat                                  */
  /***********************************************/

#ifdef DPD
  /* DPD thermostat forces */
  if ( thermo_switch & THERMO_DPD ) add_dpd_thermo_pair_force(p1,p2,d,dist,dist2);
#endif

  /** The inter dpd force should not be part of the virial
      
#ifdef INTER_DPD
  add_inter_dpd_pair_force(p1,p2,ia_params,d,dist,dist2);
#endif
  
  /***********************************************/
  /* non bonded pair potentials                  */
  /***********************************************/

   calc_non_bonded_pair_force(p1,p2,ia_params,d,dist,dist2,force,torque1,torque2);
   
  /***********************************************/
  /* short range electrostatics                  */
  /***********************************************/

#ifdef ELECTROSTATICS
  if (coulomb.method == COULOMB_DH)
    add_dh_coulomb_pair_force(p1,p2,d,dist,force);
  
  if (coulomb.method == COULOMB_RF)
    add_rf_coulomb_pair_force(p1,p2,d,dist,force);
#endif

  /*********************************************************************/
  /* everything before this contributes to the virial pressure in NpT, */
  /* but nothing afterwards                                            */
  /*********************************************************************/
#ifdef NPT
  for (j = 0; j < 3; j++)
    if(integ_switch == INTEG_METHOD_NPT_ISO)
      nptiso.p_vir[j] += force[j] * d[j];
#endif

  /***********************************************/
  /* semi-bonded multi-body potentials            */
  /***********************************************/
  
   /* Directional LJ */
#ifdef LJ_ANGLE
   /* This is a multi-body forces that changes the forces of 6 particles */
   add_ljangle_force(p1, p2, ia_params, d, dist);
#endif
  
  /***********************************************/
  /* long range electrostatics                   */
  /***********************************************/

#ifdef ELECTROSTATICS

  /* real space coulomb */
  double q1q2 = p1->p.q*p2->p.q;
  switch (coulomb.method) {
#ifdef P3M
  case COULOMB_ELC_P3M: {
	  if (q1q2) {
		  p3m_add_pair_force(q1q2,d,dist2,dist,force);

		  // forces from the virtual charges
		  // they go directly onto the particles, since they are not pairwise forces
		  if (elc_params.dielectric_contrast_on)
			  ELC_P3M_dielectric_layers_force_contribution(p1, p2, p1->f.f, p2->f.f);
	  }
	  break;
  }
  case COULOMB_P3M_GPU:
  case COULOMB_P3M: {
#ifdef NPT
	  if (q1q2) {
		  double eng = p3m_add_pair_force(q1q2,d,dist2,dist,force);
		  if(integ_switch == INTEG_METHOD_NPT_ISO)
			  nptiso.p_vir[0] += eng;
	  }
#else
	  if (q1q2) p3m_add_pair_force(q1q2,d,dist2,dist,force);
#endif
	  break;
  }
#endif
  case COULOMB_MMM1D:
	  if (q1q2) add_mmm1d_coulomb_pair_force(q1q2,d,dist2,dist,force);
	  break;
  case COULOMB_MMM2D:
	  if (q1q2) add_mmm2d_coulomb_pair_force(q1q2,d,dist2,dist,force);
	  break;
#ifdef EWALD_GPU
  case COULOMB_EWALD_GPU:
	  if (q1q2) add_ewald_gpu_coulomb_pair_force(p1,p2,d,dist,force);
	  break;
#endif
  default:
	  break;
  }

#endif /*ifdef ELECTROSTATICS */


  /***********************************************/
  /* long range magnetostatics                   */
  /***********************************************/


#ifdef DIPOLES
  /* real space magnetic dipole-dipole */
  switch (coulomb.Dmethod) {
#ifdef DP3M
  case  DIPOLAR_MDLC_P3M: 
   //fall trough 
  case DIPOLAR_P3M: {
#ifdef NPT
    double eng = dp3m_add_pair_force(p1,p2,d,dist2,dist,force);
    if(integ_switch == INTEG_METHOD_NPT_ISO)
      nptiso.p_vir[0] += eng;
#else
    dp3m_add_pair_force(p1,p2,d,dist2,dist,force);
#endif
    break;
  }
#endif /*ifdef DP3M */
  default:
      break;
  }  
#endif /* ifdef DIPOLES */
  
  /***********************************************/
  /* add total nonbonded forces to particle      */
  /***********************************************/

  for (j = 0; j < 3; j++) {
    p1->f.f[j] += force[j];
    p2->f.f[j] -= force[j];
#ifdef ROTATION
    p1->f.torque[j] += torque1[j];
    p2->f.torque[j] += torque2[j];
#endif
  }
}
コード例 #12
0
ファイル: playerSnake.cpp プロジェクト: inge91/2playersnake
// Touched the mouse?
bool playerSnake::touched_mouse(mouse myMouse){
    SDL_Rect mouseLoc =myMouse.get_pos();
    SDL_Rect head = mparts_locations.at(0);

    return detect_collision(mouseLoc, head);
}
コード例 #13
0
ファイル: file.cpp プロジェクト: isaactl/OpenGL-game
void keyboard(unsigned char key, int x, int y)
{
	float ypozr,typos1;
	ypozr=ypoz*3.14/180;
	switch (key) {
		case 27:
			exit(0);
			break;
		case 99:
			if(camera<4)
			{
				camera++;
			}
			else
			{
				camera=0;
			}
			break;
		case 't':
			int fi;
			fi=detect_collision(1);
			if(matrix[tz][tx].type==5)
			{
				if(tz==t1z && tx==t1x)
				{
					txpos=matrix[t2z][t2x].x1+1;
					tzpos=matrix[t2z][t2x].z1+1;

				}
				else
				{
					txpos=matrix[t1z][t1x].x1+1;
					tzpos=matrix[t1z][t1x].z1+1;

				}
			}
		case 'w':
			if(camera==4)
			{
				if(matrix[sel_i+1][sel_j].type!=1)
				{
					sel_i=sel_i+1;
				}
			}
			break;
		case 'a':
			if(camera==4)
			{
				if(matrix[sel_i][sel_j-1].type!=1)
				{
					sel_j=sel_j-1;
				}
			}
			break;
		case 's':
			if(camera==4)
			{
				if(matrix[sel_i-1][sel_j].type!=1)
				{
					sel_i=sel_i-1;
				}
			}
			break;
		case 'd':
			if(camera==4)
			{
				if(matrix[sel_i][sel_j+1].type!=1)
				{
					sel_j=sel_j+1;
				}
			}
			break;
		case '1':
			if(camera==3)
			{
				zoom=zoom+0.05;
			}
			break;
		case '2':
			if(camera==3)
			{
				zoom=zoom-0.05;
			}
			break;

		case 'r':
			speed=2.5;
			break;
		case ' ':
			float uy=4.0;
			float g=4.0;
			float temp,time=0.1;
			temp=frangle;
			frangle=60.0;
			jump=1;
			int typ=3;
			while(typ==3 && uy>1)
			{
				time=0.1;
			while(1)
			{
				typos1=uy*time-(g*time*time)/2;
				tzpos=tzpos+0.06*cos(ypozr)*vel*speed;
				txpos=txpos+0.06*sin(ypozr)*vel*speed;
				typos=typos1+typos;
				display();
				col_prev=detect_collision(0);
//				printf("%f %d %f\n",matrix[tz][tx].height,matrix[tz][tx].type,h-1);
				if(matrix[tz][tx].type==2 || matrix[tz][tx].type==4)
				{
					if(typos<h-1)
					{
						tzpos=tzpos-0.06*cos(ypozr)*vel*speed;
						txpos=txpos-0.06*sin(ypozr)*vel*speed;
						detect_collision(1);
						typos=typos-typos1;
						break;
					}
				}
				else if(matrix[tz][tx].height>typos1)
				{
					if(matrix[tz][tx].type!=1)
						typos=typos-typos1;
//					printf("%d %d %f %f\n",tx,tz,matrix[tx][tz].height,typos1);
					break;
				}
				typos=typos-typos1;

				time=time+0.05;
			}
			typ=col_prev;
			uy=uy-1.0;
			}
			jump=0;
			/*	 for(float time=0.1;time<2.0;time=time+0.1)
				 {
				 typos1=uy*time-(4.0*time*time)/2;
				 tzpos=tzpos+0.12*cos(ypozr)*vel*speed;
				 txpos=txpos+0.12*sin(ypozr)*vel*speed;
				 typos=typos1+typos;
				 display();
				 typos=typos-typos1;
				 }*/
			//	 col_prev=detect_collision(0);
			if(col_prev==1)
			{
				display();
				printf("GAME-OVER-JUMP\n");
				sleep(2);
				exit(0);
			}
			frangle=temp;
			break;
	}
}
コード例 #14
0
ファイル: file.cpp プロジェクト: isaactl/OpenGL-game
void keyboard1(int key, int x, int y)
{
	float ypozr;
	ypozr=ypoz*3.14/180;
	if(frangle>20.0)
	{
		flag=-1.0*flag;
	}
	if(frangle<-20.0)
	{
		flag=-1.0*flag;
	}
	switch (key) {
		case GLUT_KEY_LEFT:         
			ypoz=ypoz+5;
			if (ypoz>360) ypoz=0;
			glutPostRedisplay();
			break;
		case GLUT_KEY_UP:
			vel=1.0;
			frangle=frangle+3.0*flag*speed;
			tzpos=tzpos+0.08*cos(ypozr)*speed;
			txpos=txpos+0.08*sin(ypozr)*speed;
			int col;
			col=detect_collision(1);
					if(col==1)
					{
						fall();
					}
			if(move==0 && col_prev==0 && h>1.0)
			{
				frangle=frangle-3.0*flag*speed;
				tzpos=tzpos-0.08*cos(ypozr)*speed;
				txpos=txpos-0.08*sin(ypozr)*speed;
				col=detect_collision(1);
			}
			col_prev=col;
			//printf("%f %f\n",tzpos,txpos);

			break;
		case GLUT_KEY_DOWN:
			vel=-1.0;
			speed=1.0;
			frangle=frangle-3.0*flag;
			//		tzpos=tzpos+0.08;
			tzpos=tzpos-0.08*cos(ypozr);
			txpos=txpos-0.08*sin(ypozr);
			int col1;
			if(col1==1)
			{
				fall();

			}
			col1=detect_collision(1);
			if(move==0 && col_prev==0 && h>1.0)
			{
				frangle=frangle+3.0*flag;
				//		tzpos=tzpos+0.08;
				tzpos=tzpos+0.08*cos(ypozr);
				txpos=txpos+0.08*sin(ypozr);
				col=detect_collision(1);
			}
			col_prev=col;
			break;
		case GLUT_KEY_RIGHT:
			ypoz=ypoz-5;
			if (ypoz<-360) ypoz=0;
			glutPostRedisplay();
			break;
	}

}
コード例 #15
0
ファイル: game.cpp プロジェクト: milleniumbug/river_raid
bool Game::is_it_reachable(const AxisAlignedBoundingBox& box) const
{
	return detect_collision(AxisAlignedBoundingBox(Zespolona(0, std::numeric_limits<double>::infinity()),
	                                               Zespolona(level_width(), pozycja_gracza().imag() - 400)),
	                        box);
}
コード例 #16
0
// called if timer event 
// id is the id of the timer; you can schedule as many timer events as you want in the callback setup section of glut_setup
void my_TimeOut(int id) { 
 
   double accel, vel, y2; //temporary values for comparisons

  //BIG for loop for updating particle coordinates with physics
  for (int aa = 0; aa < 25; aa++)
  {
	  //Exit if shape hasn't been made yet
	  if (list_of_shapes[aa].p_ptr == NULL)
	  {
		  break;
	  }
	  else
	  {
		 //rectangles dropping
		 if (aa % 2 == 0)
		 {
			 current = ANIMATION_SPEED/1000.0;  // get current time change (converted from milliseconds to seconds)
			 
			 //Update particle values using equations from lecture
			 for (int g = 0; g < 4; g++)
			 {
				 accel = list_of_shapes[aa].p_ptr[g].force / list_of_shapes[aa].p_ptr[g].mass;
				 vel = list_of_shapes[aa].p_ptr[g].velocity;
				 //printf("%f - v\n", vel); //DEBUG
				 y2 = list_of_shapes[aa].p_ptr[g].y;
				
				 list_of_shapes[aa].p_ptr[g].velocity = vel + (accel * current);
				 list_of_shapes[aa].p_ptr[g].y = y2 + (vel * current) + ( (accel*0.5) * (current*current));
			 }

			 //Update y coordinate of object's center
			 list_of_shapes[aa].curr_y = (list_of_shapes[aa].p_ptr[2].y + list_of_shapes[aa].p_ptr[0].y)/2.0;

			//check for collisions
			for (int j = 0; j < 25; j++)
			{
			  //Don't check for collisions with itself or nonexistant objects
			  if (j == aa || list_of_shapes[j].p_ptr == NULL)
				  continue;
			  
			  //Distance between two shapes
			  double distance = detect_collision(list_of_shapes[aa], list_of_shapes[j]);
			  
			  //printf("%f distance between shape %d and %d\n", distance, aa, j); //DEBUG
			 
			  //Only go in if statement if current object is still in motion
			  if (distance < 0.03 && list_of_shapes[aa].p_ptr[0].force != 0.0)
			  {
				  //DEBUG
				  //printf("%f, %f\n", abs(list_of_shapes[aa].old_vel2 - list_of_shapes[aa].p_ptr[0].velocity), list_of_shapes[aa].difference);
				
				//IF object keeps colliding with a surface with the same velocity than it should stop moving
				//Animation becomes more realistic
				if ( abs(list_of_shapes[aa].old_vel2 - list_of_shapes[aa].p_ptr[0].velocity) ==  list_of_shapes[aa].difference && list_of_shapes[j].curr_y < list_of_shapes[aa].curr_y)
				{
					//printf("COllision!!\n");  //DEBUG
					for (int r = 0; r < 4; r++)
					{
						//stop shape from moving
						list_of_shapes[aa].p_ptr[r].velocity = 0.0;
						list_of_shapes[aa].p_ptr[r].force = 0.0;
					}
				}
				else  //Slow down object due to collision
				{
					list_of_shapes[aa].difference = abs(list_of_shapes[aa].old_vel2 - list_of_shapes[aa].p_ptr[0].velocity);

					for (int r = 0; r < 4; r++)
					{
						list_of_shapes[aa].p_ptr[r].velocity *= -.75;
						//Send object at top of collision upwards
						if (list_of_shapes[aa].curr_y > list_of_shapes[j].curr_y)
						{
							list_of_shapes[aa].p_ptr[r].y += ((0.03-distance)*.9);
							list_of_shapes[aa].curr_y += ((0.03-distance)*.9);
						}
						else //Send object at bottom of collision downwards
						{
							list_of_shapes[aa].p_ptr[r].y -= ((0.03-distance)*.9);
							list_of_shapes[aa].curr_y -= ((0.03-distance)*.9);
						}
					}
				}

				list_of_shapes[aa].old_vel2 = list_of_shapes[aa].p_ptr[0].velocity;
			  }
			}

			double offset;

			 for (int g = 0; g < 4; g++)
			 {
				 //Collision detection with the bottom
				if (list_of_shapes[aa].p_ptr[g].y < 0.0)
				{   
					offset = abs((0.0 - list_of_shapes[aa].p_ptr[g].y));

					//This stops shapes from bouncing on the ground when they should've stopped moving
					if (abs(list_of_shapes[aa].p_ptr[g].velocity) == list_of_shapes[aa].old_vel)
					{
						for (int r = 0; r < 4; r++)
						{
							//printf("STOPPED\n");  //DEBUG
							//stop shape from moving
							list_of_shapes[aa].p_ptr[r].velocity = 0.0;
							list_of_shapes[aa].p_ptr[r].force = 0.0;
						}
						break;
					}
					else
					{
						for (int r = 0; r < 4; r++)
						{
							//switch velocity sign and decreases by 75% due to collision with floor
							list_of_shapes[aa].p_ptr[r].velocity *= -.75;
							list_of_shapes[aa].p_ptr[r].y += offset;
						}
						break;
					}
					//printf("vel - %f\n", list_of_shapes[aa].p_ptr[g].velocity);  //DEBUG
					list_of_shapes[aa].old_vel = list_of_shapes[aa].p_ptr[g].velocity;
				}
			 }
		 }
		 else if (aa % 2 == 1)	//Circles with PHYSICS
		 {
			 //Update particle values
			 current = ANIMATION_SPEED/1000.0;  // get current time change (convert milliseconds to seconds)

			 //Update particles according to equations from lecture
			 for (int g = 0; g < 12; g++)
			 {
				 accel = list_of_shapes[aa].p_ptr[g].force / list_of_shapes[aa].p_ptr[g].mass;
				
				 // printf("%f\n", accel); //DEBUG
				 
				 vel = list_of_shapes[aa].p_ptr[g].velocity;
				 y2 = list_of_shapes[aa].p_ptr[g].y;

				 list_of_shapes[aa].p_ptr[g].velocity = vel + (accel * current);
				 list_of_shapes[aa].p_ptr[g].y = y2 + (vel * current) + ( (accel*0.5) * (current*current));
			 }
			 
			 //Update y coordinate of object's center
			 list_of_shapes[aa].curr_y = list_of_shapes[aa].p_ptr[0].y;

			//check for collisions
			for (int j = 0; j < 25; j++)
			{
			  //Don't check for collisions with itself or nonexistant objects
			  if (j == aa || list_of_shapes[j].p_ptr == NULL)
				  continue;

			  //Distance between two shapes
			  double distance = detect_collision(list_of_shapes[aa], list_of_shapes[j]);
			  
			  //Only go in if statement if current object is still in motion
			  if (distance < 0.03 && list_of_shapes[aa].p_ptr[0].force != 0.0)
			  {
				//printf("vel - %f\n", list_of_shapes[aa].p_ptr[0].velocity); //DEBUG

				//IF object keeps colliding with a surface with the same velocity than it should stop moving
				//Animation becomes more realistic
				if ( abs(list_of_shapes[aa].old_vel2 - list_of_shapes[aa].p_ptr[0].velocity) ==  list_of_shapes[aa].difference && list_of_shapes[j].curr_y < list_of_shapes[aa].curr_y)
				{
					//printf("COllision!!\n"); //DEBUG
					
					for (int r = 0; r < 12; r++)
					{
						//stop shape from moving
						list_of_shapes[aa].p_ptr[r].velocity = 0.0;
						list_of_shapes[aa].p_ptr[r].force = 0.0;
					}
				}
				else  //Slow down object due to collision
				{
					list_of_shapes[aa].difference = abs(list_of_shapes[aa].old_vel2 - list_of_shapes[aa].p_ptr[0].velocity);

					for (int r = 0; r < 12; r++)
					{
						list_of_shapes[aa].p_ptr[r].velocity *= -.75;
						//Send object at top of collision upwards
						if (list_of_shapes[aa].curr_y > list_of_shapes[j].curr_y)
						{
							list_of_shapes[aa].p_ptr[r].y += ((0.03-distance)*.9);
							list_of_shapes[aa].curr_y += ((0.03-distance)*.9);
						}
						else //Send object at bottom of collision downwards
						{
							list_of_shapes[aa].p_ptr[r].y -= ((0.03-distance)*.9);
							list_of_shapes[aa].curr_y -= ((0.03-distance)*.9);
						}
					}
				}
				list_of_shapes[aa].old_vel2 = list_of_shapes[aa].p_ptr[0].velocity;
			  }
			}

			double offset;

			 for (int g = 0; g < 12; g++)
			 {
				 //Collision detection with the bottom
				if (list_of_shapes[aa].p_ptr[g].y <= 0.0)
				{
					offset = abs((0.0 - list_of_shapes[aa].p_ptr[g].y));
				
					//This stops shapes from bouncing on the ground when it should've stopped moving
					if (abs(list_of_shapes[aa].p_ptr[g].velocity) == list_of_shapes[aa].old_vel)
					{
						for (int r = 0; r < 12; r++)
						{
							//printf("STOPPED\n"); //DEBUG

							//stop shape from moving
							list_of_shapes[aa].p_ptr[r].velocity = 0.0;
							list_of_shapes[aa].p_ptr[r].force = 0.0;
						}
						break;
					}
					else
					{
						for (int r = 0; r < 12; r++)
						{
						  //switch velocity sign and decrease by 75% due to collision with floor
						  list_of_shapes[aa].p_ptr[r].velocity *= -.75;
						  list_of_shapes[aa].p_ptr[r].y += offset;
						}
						break;
					}
					list_of_shapes[aa].old_vel = list_of_shapes[aa].p_ptr[g].velocity;
				}
			 }
		 }
	  }
	}// END of for loop

	// clear the buffer 
    glClear(GL_COLOR_BUFFER_BIT) ;

	 //Animate shapes to drop down to botton of screen Tetris style
	for (int aa = 0; aa < 25; aa++)
    {
	  //If shape doesn't exist then don't animate it
	  if (list_of_shapes[aa].p_ptr == NULL)
	  {
		  break;
	  }
	  else
	  {
		//animate rectangles
		 if (aa % 2 == 0)
		 {
		   glColor3f(0,0,1) ; // Blue rectangles
		    
		   //Draw changes made by simulated gravity
		    glBegin(GL_QUADS);
	   
			for(int g= 0; g < 4; g++)
			{
				glVertex2d(list_of_shapes[aa].p_ptr[g].x, list_of_shapes[aa].p_ptr[g].y);
			}

			glEnd();
		 }
		 else
		 {
			 glColor3f(1,0,0) ; //Red circles
			 
			 //Draw changes made by simulated gravity
			 glBegin(GL_TRIANGLE_FAN);
		 
			 for(int x= 0; x < 12; x++)
			 {
				glVertex2d(list_of_shapes[aa].p_ptr[x].x, list_of_shapes[aa].p_ptr[x].y);
			 }
		 
			 glEnd();
		 }
	  }
	}
 
   // buffer is ready; show me the money! 
   glutSwapBuffers();

  glutTimerFunc(ANIMATION_SPEED, my_TimeOut, 0);// schedule next timer event, according to ANIMATION_SPEED

}