How to remove magnetic effect in collision!

varynoob

Hello everyone,

Looking for some realism in collision and updation, i mean i have a ball in centre, squares coming from right to left,
1. If ball touches the left of square, everything stops.
2. Now the ball should be made to jump over the square, roll on and go ahead. But when i jump, the ball magnetically sticks to the box!! No realism , so what should i do to make it look smooth and kind of real!!

#SelectExpand
  1for(int i=0; i < ssize ; i++)
{
  if(shapeS[i].live) // checks whether the square is on the screen
  {
    if(((shapeS[i].pos_rect_x1 < shapeB.pos_X + shapeB.boundx +7)
      &&(shapeS[i].pos_rect_x1+ 40 > shapeB.pos_X - shapeB.boundx))
      &&!((shapeS[i].pos_rect_y1 < shapeB.pos_Y + shapeB.boundy)
      &&(shapeS[i].pos_rect_y1+40 > shapeB.pos_Y - shapeB.boundy)))// basic collision detection for top 
    {
        shapeB.LeftCollision = false;
          shapeB.pos_Y = shapeS[i].pos_rect_y1 - shapeB.boundy - 7 ; // this updates ball position and causes magnetic effect
          shapeB.isOnSquare = true;
    }
        
    else if((shapeS[i].pos_rect_x1 < shapeB.pos_X + shapeB.boundx+ 7)
      &&(shapeS[i].pos_rect_x1 > shapeB.pos_X - shapeB.boundx)) // checks for left collision
    {
      shapeB.LeftCollision = true;
    }
 20
    else
    {
      shapeB.LeftCollision = false;
      
    }
  }
}

Steve Terry

You are only snapping y to the top of the box, if you want to make it roll off you need to apply gravity and forward momentum.

varynoob

Is it like, adding and && comdition in the JUMP mechanism ? (!isOnGround && LeftCollision) ? ?

How do i apply forward momentum ? ?

Steve Terry

changing anything in your if statement won't get the ball rolling forward. You will need to post more code if we are to figure out how to apply forward momentum. Usually it just means incrementing x.

varynoob

The code goes as this(excluding code fr BG, Explosions, Globals, main() part b4 game loop), so where do i apply momentum ?
also, if i want triangles and square in a particular pattern, but random at the same time, ie that pattern should be random.

How do i go for it, i understand it is just some logic, but what i want to ask is, should i take triangle and square in the same struct and same loop in else if conditions or do as i have done here with different structs.

I can attach the setup as well, if needed, the game is running, but with triangle-triangle overlap and square-triangle overlap and that magnetic effect!!

#SelectExpand
   1
   2/***********************
  GAME LOOP
   4************************/
while(!done)
{
  ALLEGRO_EVENT ev;
  al_wait_for_event(event_queue, &ev);
  
  
  time_remaining --;
  if((time_remaining/60) % 3 == 0)
    inc_speed +=0.001;
  14
  15
  if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
  {
    switch(ev.keyboard.keycode)
    {
    case ALLEGRO_KEY_LEFT:
        keys[LEFT] = true;
        break;
    case ALLEGRO_KEY_RIGHT:
        keys[RIGHT] = true;
        break;
    case ALLEGRO_KEY_SPACE:
        keys[SPACE] = true;
        if(state == TITLE)
          ChangeState(state, PLAYING);
        else if(state == LOST)
          ChangeState(state, PLAYING);
  32
        break;
  34
    }
  36
  }
  else if(ev.type == ALLEGRO_EVENT_KEY_UP)
  {
    switch(ev.keyboard.keycode)
    {
    case ALLEGRO_KEY_LEFT:
        keys[LEFT] = false;
        break;
    case ALLEGRO_KEY_RIGHT:
        keys[RIGHT] = false;
        break;
    case ALLEGRO_KEY_ESCAPE:
      done=true;
      break;
    case ALLEGRO_KEY_SPACE:
        keys[SPACE] = false;
        break;
    }
  }
  else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
  {
    done = true;
  }
  60
  /***********************
      UPDATE
  ************************/
  64

  else if(ev.type == ALLEGRO_EVENT_TIMER)
  {
    redraw = true;
    /*if(keys[LEFT])
      MoveLeftBall(shapeB);
    if(keys[RIGHT])
      MoveRightBall(shapeB);*/
  73
  74
  75
    if (shapeB.isOnGround || shapeB.isOnSquare )           
    { // means the ball is on the ground 
      if(keys[SPACE])         
      {
        if (shapeB.canJump)       //CAN JUMP
        {
          shapeB.dy= -10;        //VELOCITY UPWARDS
          shapeB.canJump = false;  
        }
      }
    else
      shapeB.canJump = true;        
    }
  89
     
  91
    if(!shapeB.isOnGround || !shapeB.isOnSquare)          
      {
        shapeB.dy += 0.5;
        speed = 5+inc_speed ;
      }
    else
      speed = 3+inc_speed;
  99
    if (keys[SPACE] && shapeB.isOnGround && shapeB.isOnSquare && shapeB.dy > 0)    
    shapeB.dy -= 0.1; // got to be LESS than 0.5 here.  
 102
    if(shapeB.dy>5)            
      shapeB.dy = 5;
    
    shapeB.pos_Y  += shapeB.dy;          
 107
    if(shapeB.pos_Y > HEIGHT-20)
    {        
      shapeB.pos_Y = HEIGHT-20;
      shapeB.dy = 0;
    }
 113
 114
    if(state == TITLE)
    {}
    else if(state == PLAYING)
    {
      if(shapeB.LeftCollision == false)
      {
        
      UpdateBackground(BG);
 123
      UpdateTriangle(shapeT,NUM_TRIANGLES, shapeB);
    
      UpdateSquare(shapeS,NUM_TRIANGLES, shapeB);
      }
      UpdateExplosions(explosions);
      UpdateBall(shapeB);
      StartTriangle(shapeT, NUM_TRIANGLES);
      StartSquare(shapeS, NUM_TRIANGLES);
      CollideTriangle(shapeT,shapeS, NUM_TRIANGLES, shapeB, explosions);
      CollideSquare(shapeS, NUM_TRIANGLES, shapeB, explosions);
      if(shapeB.lives <=0 || time_remaining < 1)
        ChangeState(state, LOST);
    }
    else if(state == LOST)
    {}
      
  
/***********************
    RENDERING
************************/
 144
 145
  if(redraw && al_is_event_queue_empty(event_queue))
  {
    redraw= false;
 149
    if(state == TITLE)
    {
      al_draw_bitmap(title, 0 ,0 ,0);
    }
    else if(state == PLAYING)
    {
      DrawBackground(BG);
      DrawBall(shapeB);
      DrawTriangle(shapeT,NUM_TRIANGLES);
      DrawSquare(shapeS,NUM_TRIANGLES);
      DrawExplosions(explosions);
    
      al_draw_textf(font18, al_map_rgb(255,255,255),0,0,0,
        "Player has %i lives. Score : %i",shapeB.lives,shapeB.score);
      
      al_draw_textf(font18, al_map_rgb(255,255,255),600,0,0,
        "Time Remaining: %i",time_remaining/60);
 167
    }
    else if(state == LOST)
    {
      al_draw_bitmap(lost, 0, 0, 0);
      al_draw_textf(font18, al_map_rgb(0,255,255),WIDTH - 10 ,20,ALLEGRO_ALIGN_RIGHT,
        "Final Score : %i",shapeB.score);
    }
 175
    
    al_flip_display();
    al_clear_to_color(al_map_rgb(0,0,0));
        
    }
  }

}

/**********************************
  DESTROYING GAME OBJECTS
**********************************/
 188
al_destroy_sample(boom);
al_destroy_sample_instance(songInstance);
al_destroy_bitmap(bgImage);
al_destroy_bitmap(title);
al_destroy_bitmap(lost);
al_destroy_bitmap(expImage);
al_destroy_bitmap(ballImage);
al_destroy_event_queue(event_queue);
al_destroy_timer(timer);
al_destroy_font(font18);
al_destroy_display(display);            
 200
return 0;
 202}
 203
 204
 205
 206void InitBall(Ball &shapeB, ALLEGRO_BITMAP *image = NULL)
 207{
shapeB.ID=BALL;
shapeB.pos_X= WIDTH/2;
shapeB.pos_Y= HEIGHT;
shapeB.lives = 3;
shapeB.speed = 6;
shapeB.score = 0;
shapeB.boundx = 23;
shapeB.boundy = 16;
shapeB.dx = 1;
shapeB.dy = 1;
shapeB.canJump = false;
shapeB.isOnGround = true;
shapeB.isOnSquare = false;
shapeB.LeftCollision = false;
 222
shapeB.maxFrame = 8;
shapeB.curFrame = 0;
shapeB.frameCount = 0;
shapeB.frameDelay = 5;
shapeB.frameWidth = 64;
shapeB.frameHeight = 48;
shapeB.animationColumns = 8;
shapeB.animationDirection = 1;
shapeB.animationRow = 0;
 232
time_remaining = 10800;        //A calculated value to display remainging time
speed=0;
inc_speed=0;
 236
if(image != NULL)
  shapeB.image = image;
 239
 240}
 241void DrawBall(Ball &shapeB)
 242{

int fx = (shapeB.curFrame % shapeB.animationColumns) * shapeB.frameWidth;
int fy = shapeB.animationRow * shapeB.frameHeight;
 246
al_draw_bitmap_region(shapeB.image, fx, fy, shapeB.frameWidth,
  shapeB.frameHeight, (shapeB.pos_X - shapeB.frameWidth/2), (shapeB.pos_Y - shapeB.frameHeight/2), 0);
 249
//al_draw_filled_rectangle(shapeB.pos_X - shapeB.boundx, shapeB.pos_Y - shapeB.boundy,
//  shapeB.pos_X + shapeB.boundx, shapeB.pos_Y + shapeB.boundy, al_map_rgba(255,0,255,100));
 252
 253
 254}
 255//void MoveLeftBall(Ball &shapeB)
 256//{
 257//  shapeB.pos_X -=shapeB.speed;
 258//  if(shapeB.pos_X <(WIDTH/2) - 100)
 259//    shapeB.pos_X = (WIDTH/2) - 100;
 260//}
 261//void MoveRightBall(Ball &shapeB)
 262//{
 263//  shapeB.pos_X += shapeB.speed; 
 264//  if(shapeB.pos_X >(WIDTH/2)+100)
 265//    shapeB.pos_X = (WIDTH/2)+100 ;
 266//}
 267
 268
 269void UpdateBall(Ball &shapeB)
 270{
if(shapeB.pos_Y < HEIGHT-20)
  shapeB.isOnGround = false;
else
  shapeB.isOnGround = true;

if(!shapeB.LeftCollision)
{
  if(++shapeB.frameCount >= shapeB.frameDelay)
  {
    if(++shapeB.curFrame >= shapeB.maxFrame)
    {
      shapeB.curFrame = 0;
    
    }
 285
    shapeB.frameCount = 0;
  
  }
 289
}
 291}
 292
 293
 294void InitTriangle(Triangle shapeT[], int size)
 295{
for(int i=0; i<size; i++)
{
shapeT[i].ID = TRIANGLE;
shapeT[i].live = false;


shapeT[i].bound_triangle_x = 10;
shapeT[i].bound_triangle_y = 16;
shapeT[i].collidingS = false;
shapeT[i].collidingT = false;

}
 308}
 309
 310void DrawTriangle(Triangle shapeT[], int size)
 311{
for(int i=0; i<size; i++)
{
  if(shapeT[i].live && shapeT[i].collidingT == false)
  {  
 316
     
      al_draw_triangle(shapeT[i].pos_x1-8,shapeT[i].pos_y1 + 10,shapeT[i].pos_x1,shapeT[i].pos_y1-10,
    shapeT[i].pos_x1+8,shapeT[i].pos_y1+10,al_map_rgb(255,0,255),2);
    

  }
}
 324}
 325
 326void StartTriangle(Triangle shapeT[], int size)
 327{
for (int i = 0 ; i < size; i++)
{
  if(!shapeT[i].live)
  {
    if(rand() % 400 == 0)
    {
      if(time_remaining % 2 == 0 && time_remaining % 25 != 0)
      {
        shapeT[i].live = true;
        shapeT[i].pos_x1 = WIDTH;  
        shapeT[i].pos_y1 = HEIGHT-10;
      
        break;
      }
    }
  }
}
 345}
 346
 347void UpdateTriangle(Triangle shapeT[], int size, Ball &shapeB)
 348{
for(int i=0; i<size; i++)
{
  if((shapeT[i].live) && shapeT[i].collidingT == false)
  {
    shapeT[i].pos_x1 -= speed;
 354
 355
 356
    if(shapeT[i].pos_x1-15 < 0)
      {
        shapeT[i].live = false;
        shapeB.score++;
      }
  }
}
 364}
 365
 366void CollideTriangle(Triangle shapeT[], Square shapeS[], int csize, Ball &shapeB, Explosion &explosion)
 367{
for(int i = 0; i < csize; i++)
{
  if(shapeT[i].live)
  {
    
          
     if((shapeT[i].pos_x1 - shapeT[i].bound_triangle_x < shapeB.pos_X + shapeB.boundx)
      && (shapeT[i].pos_x1 + shapeT[i].bound_triangle_x > shapeB.pos_X - shapeB.boundx)
      &&(shapeT[i].pos_y1 - shapeT[i].bound_triangle_y < shapeB.pos_Y + shapeB.boundy)
      &&(shapeT[i].pos_y1 + shapeT[i].bound_triangle_y > shapeB.pos_Y - shapeB.boundy))
    {
      
      shapeT[i].live = false;
      shapeB.pos_Y = shapeT[i].pos_y1 - shapeT[i].bound_triangle_y - shapeB.boundy - 20;
 382
      StartExplosions(explosion,shapeB.pos_X, shapeB.pos_Y);
      al_play_sample(boom, 1,0,1,ALLEGRO_PLAYMODE_ONCE,0);
      shapeB.lives--;
              
    }
     /*if(time_remaining % 25 == 0)
     {
       if(shapeT[i].pos_x1 - shapeT[i].bound_triangle_x < shapeS[i].pos_rect_x1 + 40 
         && shapeT[i].pos_y1 - shapeT[i].bound_triangle_y < shapeS[i].pos_rect_y1+40
         && shapeS[i].pos_rect_x1 < shapeT[i].pos_x1+shapeT[i].bound_triangle_x 
         && shapeS[i].pos_rect_y1 < shapeT[i].pos_y1+shapeT[i].bound_triangle_y)
       {
         shapeT[i].collidingT = true;
       
       }
 398
     }*/
 400
 401
 402
 403
 404
 405
 406
 407
  }
}
 410
 411}
 412
 413
 414void InitSquare(Square shapeS[], int size)
 415{
for(int i = 0; i < size ; i++)
{
  shapeS[i].ID = SQUARE;
  shapeS[i].live = false;
  shapeS[i].collidingS = false;
}
 422}
 423void DrawSquare(Square shapeS[], int size)
 424{
for(int i = 0; i<size; i++)
{
  if(shapeS[i].live)
  {
      al_draw_rounded_rectangle(shapeS[i].pos_rect_x1,shapeS[i].pos_rect_y1,
        shapeS[i].pos_rect_x1+40,shapeS[i].pos_rect_y1+40,6,6,al_map_rgb(255,255,255),2);
  }
}
 433}
 434void StartSquare(Square shapeS[], int size)
 435{
for (int i = 0 ; i < size; i++)
{
  if(!shapeS[i].live)
  {
    if(rand() % 100 == 0)
    {
      if((time_remaining % 25) == 0)
      shapeS[i].live = true;
      shapeS[i].pos_rect_x1 = WIDTH+40;
      shapeS[i].pos_rect_y1 = HEIGHT-40;
      
      break;
 448
    }
  }
}
 452}
 453void UpdateSquare(Square shapeS[], int size, Ball &shapeB)
 454{
for(int i=0; i<size; i++) 
{
  if(shapeS[i].live)
  {
    shapeS[i].pos_rect_x1 -= speed;
    
    if(shapeS[i].pos_rect_x1+40 <= 0)
      {
        shapeS[i].live = false;
        shapeB.score++;
      }
  }
}
 468}
 469
 470void CollideSquare(Square shapeS[], int ssize, Ball &shapeB, Explosion &explosion)
 471{
for(int i=0; i < ssize ; i++)
{
  if(shapeS[i].live)
  {
    if(((shapeS[i].pos_rect_x1 < shapeB.pos_X + shapeB.boundx +7)
      &&(shapeS[i].pos_rect_x1+ 40 > shapeB.pos_X - shapeB.boundx))
      &&!((shapeS[i].pos_rect_y1 < shapeB.pos_Y + shapeB.boundy)
      &&(shapeS[i].pos_rect_y1+40 > shapeB.pos_Y - shapeB.boundy)))
    {
        shapeB.LeftCollision = false;
          shapeB.pos_Y = shapeS[i].pos_rect_y1 - shapeB.boundy - 7 ;
          shapeB.isOnSquare = true;
    }
        
    else if((shapeS[i].pos_rect_x1 < shapeB.pos_X + shapeB.boundx+ 7)
      &&(shapeS[i].pos_rect_x1 > shapeB.pos_X - shapeB.boundx))
    {
      shapeB.LeftCollision = true;
    }
 491
    else
    {
      shapeB.LeftCollision = false;
      
    }
  }
}
 499}

Steve Terry

I still don't see anywhere where you are updating your x position. If you are on top of a square just keep your x position incrementing.

varynoob

The x position, increments by itself. i.e the Square keeps on scrolling towards left, while ball is in the same position during the gameplay!
What i meant to say was, when the ball collides with the left of square or comes on top, it magnetically sticks to the square, until the square scrolls beyond the ball's position!

Also, the LeftCollision value does not get updated in the Update() section!!

#SelectExpand
   1#include "GameObject.h"
   2
   3GameObject :: GameObject()
   4{
   5  x = 0;
   6  y = 0;
   7
   8  velX = 0;
   9  velY = 0;
  10
  11  dirX = 0;
  12  dirY = 0;
  13  
  14  boundX = 0;
  15  boundY = 0;
  16
  17  LeftCollision = false;
  18  
  19
  20  maxFrame = 0;
  21  curFrame = 0;
  22  frameCount = 0;
  23  frameDelay = 0;
  24  frameWidth = 0;
  25  frameHeight = 0;
  26  animationColumns = 0;
  27  animationDirection = 0;
  28
  29  image = NULL;
  30
  31  alive = true;
  32  collidable = true;
  33}
  34
  35void GameObject :: Destroy()
  36{
  37  
  38}
  39
  40void GameObject ::  Init(float x, float y, float velX, float velY, int dirX, int dirY, int boundX, int boundY)
  41{
  42  GameObject :: x = x;
  43  GameObject :: y = y;
  44
  45  GameObject :: velX = velX;
  46  GameObject :: velY = velY;
  47
  48  GameObject :: dirX = dirX;
  49  GameObject :: dirY = dirY;
  50
  51  GameObject :: boundX = boundX;
  52  GameObject :: boundY = boundY;
  53}
  54void GameObject :: Update()
  55{
  56  if(LeftCollision == false)            // Always remains false!! Inspite of it being updated to TRUE, below in the Check Collision section!!
  57  {
  58    x += velX * dirX;
  59    y += velY * dirY;
  60  }
  61}
  62void GameObject :: Render()
  63{
  64}
  65
  66bool GameObject :: CheckCollisions(GameObject *otherObject)
  67{
  68  float oX = otherObject->GetX();
  69  float oY = otherObject->GetY();
  70
  71  int obX = otherObject->GetBoundX();
  72  int obY = otherObject->GetBoundY();
  73
  74
  75    if( x + boundX > oX - obX &&
  76    x - boundX < oX + obX &&
  77    y + boundY > oY - obY &&
  78    y - boundY < oY + obY && otherObject->GetID() == TRIANGLE)
  79  {
  80    return true;
  81  }
  82  else if(((oX < x + boundX + 14)&&(oX+ 40 >x - boundX))&&!((oY < y + boundY)&&(oY+40 > y - boundY)) 
  83    && otherObject->GetID() == SQUARE)
  84  {
  85    y = oY - boundX;
  86    //x = oX + 40;
  87    return true;
  88  }
  89  else if((oX < x + boundX + 14) && (oX > x - boundX) && otherObject->GetID() == SQUARE)
  90  {
  91    LeftCollision = true;      //this becomes true, as and when condition is me
  92    return false;
  93  }
  94  else
  95  {
  96    return false;
  97    LeftCollision = false;
  98  }
  99}
 100void GameObject :: Collided(int objectID)
 101{
 102  
 103}
 104bool GameObject :: Collidable()
 105{
 106  return alive && collidable;
 107}

Thread #609656. Printed from Allegro.cc