{"id":259,"date":"2009-07-12T23:24:22","date_gmt":"2009-07-12T17:54:22","guid":{"rendered":"http:\/\/techtwaddle.net\/?p=259"},"modified":"2011-04-12T23:24:50","modified_gmt":"2011-04-12T17:54:50","slug":"bouncingcolliding-marbles-directdraw-part-8","status":"publish","type":"post","link":"https:\/\/techtwaddle.co.in\/blog\/2009\/07\/12\/bouncingcolliding-marbles-directdraw-part-8\/","title":{"rendered":"Bouncing\/Colliding marbles, DirectDraw, Part 8"},"content":{"rendered":"
The code for colliding marbles is built on top of earlier changes to the DDEX3<\/span> sample. Look here<\/a>, here<\/a> and here<\/a> for more information. There are a few changes I made in the code for making the marbles collide and I hope you have already gone through Prof. Fu-Kwun Hwang post<\/a> on how to make stuff bounce off each other.<\/div>\n



\nCreate a structure to store the information about a marble:<\/span>

\n

\n\/*<\/span>

\nThis structure stores the info related to a ball.<\/span>

\nIts center (xPos, yPos)<\/span>

\nIts velocity along both axes (dwVelX, dwVelY)<\/span>

\nIts radius in pixels<\/span>

\n*\/<\/span>

\ntypedef struct _ballinfo<\/span>

\n{<\/span>

\n    int xPos;<\/span>

\n    int yPos;<\/span>

\n    int dwVelX;<\/span>

\n    int dwVelY;<\/span>

\n    int radius;<\/span>

\n} BALLINFO;<\/span>
\n<\/p>\n

And here are the globals we use in the source file:<\/div>\n



\n#define MAX_BALLS 3<\/span>

\n

\n\/\/we’ll be bouncing 3 balls around here.<\/span>

\nBALLINFO g_BallInfo[MAX_BALLS];<\/span>

\n

\n\/\/to store the rects of each ball<\/span>

\nRECT g_Rect[MAX_BALLS];<\/span>
\n<\/p>\n

To add more marbles to the program you just need to change the MAX_BALLS<\/span> macro and recompile the code. Well, the terms balls and marbles are used interchangeably (:<\/div>\n

 <\/p>\n

We initialize our global data in InitApp()<\/span> function, we call InitializeData()<\/span> just before InitApp()<\/span> returns:<\/div>\n



\nvoid InitializeData()<\/span>

\n{<\/span>

\n    int radius = 22;<\/span>

\n

\n    for (int i=0; i < MAX_BALLS; i++)<\/span>

\n    {<\/span>

\n        g_BallInfo[i].xPos = RandInt(radius, 216);<\/span>

\n

\n        \/\/switch on i to decide on yPos so that the balls dont overlap when they are created<\/span>

\n        switch(i)<\/span>

\n        {<\/span>

\n            \/\/dividing the screen into 3 horizontal sections with one ball in each<\/span>

\n            case 0:<\/span>

\n                g_BallInfo[i].yPos = RandInt(radius, 100-radius);<\/span>

\n                break;<\/span>

\n            case 1:<\/span>

\n                g_BallInfo[i].yPos = RandInt(100+radius, 200-radius);<\/span>

\n                break;<\/span>

\n            case 2:<\/span>

\n                g_BallInfo[i].yPos = RandInt(200+radius, 300-radius);<\/span>

\n                break;<\/span>

\n            default:<\/span>

\n                g_BallInfo[i].yPos = RandInt(radius, 320-radius);<\/span>

\n        }<\/span>

\n

\n        g_BallInfo[i].dwVelX = RandInt(-6, 6);<\/span>

\n        g_BallInfo[i].dwVelY = RandInt(-6, 6);<\/span>

\n

\n        g_BallInfo[i].radius = radius;<\/span>

\n

\n        printf("Ball %d details:\\n", i+1);<\/span>

\n        printf("X=%d  Y=%d  VelX=%d  VelY=%d\\r\\n", g_BallInfo[i].xPos, g_BallInfo[i].yPos,<\/span>

\n                    g_BallInfo[i].dwVelX, g_BallInfo[i].dwVelY);<\/span>

\n    }<\/span>

\n}<\/span><\/p>\n

Here we initialize all the data related to each marble, its center, velocity and the radius. The switch case makes sure that the balls do not overlap initially, currently I am only checking for three marbles in the switch. So if there are more than 3, there is still some possibility of the balls overlapping. I’ll leave that part for later and lets focus on more important things.<\/div>\n

 <\/p>\n

The RandInt()<\/span> function is simple, it returns a random value between the two ranges specified:<\/div>\n



\nDWORD RandInt(DWORD low, DWORD high)<\/span>

\n{<\/span>

\n    DWORD range = high – low;<\/span>

\n    DWORD num = Random() % range;<\/span>

\n

\n    return (num + low);<\/span>

\n}<\/span>

\n

\n

\nNext, we look at the UpdateFrame()<\/span> function:<\/span>

\n

\nstatic void UpdateFrame(HWND hWnd)<\/span>

\n{<\/span>

\n    HRESULT                     hRet;<\/span>

\n    DDBLTFX                     ddbltfx;<\/span>

\n    int i = 0, j = 0;<\/span>

\n

\n    memset(&ddbltfx, 0, sizeof(ddbltfx));<\/span>

\n    ddbltfx.dwSize = sizeof(ddbltfx);<\/span>

\n    ddbltfx.dwFillColor = 0;<\/span>

\n    ddbltfx.dwROP = SRCCOPY;<\/span>

\n

\n    \/\/clear the back buffer (color fil with black)<\/span>

\n    g_pDDSBack->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAITNOTBUSY, &ddbltfx);<\/span>

\n

\n    for (i = 0; i < MAX_BALLS; i++)<\/span>

\n    {<\/span>

\n        g_Rect[i].top = g_BallInfo[i].yPos – 24;<\/span>

\n        g_Rect[i].left = g_BallInfo[i].xPos – 24;<\/span>

\n        g_Rect[i].bottom = g_BallInfo[i].yPos + 24;<\/span>

\n        g_Rect[i].right = g_BallInfo[i].xPos + 24;<\/span>

\n    }<\/span>

\n

\n    ddbltfx.ddckSrcColorkey.dwColorSpaceLowValue = RGB(0, 0, 0);<\/span>

\n    ddbltfx.ddckSrcColorkey.dwColorSpaceHighValue = RGB(0, 0, 0);<\/span>

\n

\n    \/\/blt all the balls on the screen<\/span>

\n    for (i = 0; i<MAX_BALLS; i++)<\/span>

\n    {<\/span>

\n        while (TRUE)<\/span>

\n        {<\/span>

\n            hRet = g_pDDSBack->Blt(&g_Rect[i], g_pDDSOne, NULL, DDBLT_ROP | DDBLT_KEYSRCOVERRIDE, &ddbltfx);<\/span>

\n            if (hRet == DD_OK)<\/span>

\n                break;<\/span>

\n            if (hRet == DDERR_SURFACELOST)<\/span>

\n            {<\/span>

\n                hRet = RestoreAll();<\/span>

\n                if (hRet != DD_OK)<\/span>

\n                    break;<\/span>

\n            }<\/span>

\n            if (hRet != DDERR_WASSTILLDRAWING)<\/span>

\n                break;<\/span>

\n        }<\/span>

\n    }<\/span>

\n

\n    \/\/update the balls positions and check for bounds<\/span>

\n    for (i = 0; i<MAX_BALLS; i++)<\/span>

\n    {<\/span>

\n        g_BallInfo[i].xPos = g_BallInfo[i].xPos + g_BallInfo[i].dwVelX;<\/span>

\n        g_BallInfo[i].yPos = g_BallInfo[i].yPos + g_BallInfo[i].dwVelY;<\/span>

\n

\n        if(g_BallInfo[i].xPos <= 24)<\/span>

\n        {<\/span>

\n            g_BallInfo[i].xPos = 24;<\/span>

\n            g_BallInfo[i].dwVelX = -g_BallInfo[i].dwVelX;<\/span>

\n        }<\/span>

\n

\n        if(g_BallInfo[i].xPos >= (240 – 24))<\/span>

\n        {<\/span>

\n            g_BallInfo[i].xPos = 240 – 24;<\/span>

\n            g_BallInfo[i].dwVelX = -g_BallInfo[i].dwVelX;<\/span>

\n        }<\/span>

\n

\n        if(g_BallInfo[i].yPos <= 24)<\/span>

\n        {<\/span>

\n            g_BallInfo[i].yPos = 24;<\/span>

\n            g_BallInfo[i].dwVelY = -g_BallInfo[i].dwVelY;<\/span>

\n        }<\/span>

\n

\n        if (g_BallInfo[i].yPos >= (320 – 24))<\/span>

\n        {<\/span>

\n            g_BallInfo[i].yPos = 320 – 24;<\/span>

\n            g_BallInfo[i].dwVelY = -g_BallInfo[i].dwVelY;<\/span>

\n        }<\/span>

\n    }<\/span>

\n

\n    \/\/check for collisions between all the balls<\/span>

\n    for (i = 0; i < MAX_BALLS-1; i++)<\/span>

\n    {<\/span>

\n        for (j = i+1; j < MAX_BALLS; j++)<\/span>

\n        {<\/span>

\n            if(Collision(&g_BallInfo[i], &g_BallInfo[j]))<\/span>

\n            {<\/span>

\n                printf("Balls HIT!\\n");<\/span>

\n                CalculateNewVelocities(&g_BallInfo[i], &g_BallInfo[j]);<\/span>

\n                MessageBeep(MB_OK);<\/span>

\n            }<\/span>

\n        }<\/span>

\n    }<\/span>

\n}<\/span><\/p>\n

This is more or less the same as before except that the same things are done for all the three marbles here. Calculate the RECTs<\/span> for each marble in g_Rect[]<\/span>. Blt the marbles, update the marbles’ position and check for collisions between marbles. This is the interesting part.<\/div>\n

 <\/p>\n

Let me digress a bit here. How do you find out if the marbles are colliding? The presence of RECTs<\/span> tricks your mind into thinking that you can check if the two RECTs<\/span> overlap, which is what I did initially and which was really dumb, really. I used IntersectRect()<\/span><\/a> api to find out if the two RECTs<\/span> overlap, and if they did I decided its a collision! The problem here is that the two RECTs<\/span> may overlap but there might actually be no collision for example when only the corners of the two RECTs<\/span> intersect. And that happens way too many times, and watching the program run like that leaves you baffled, things dont make sense! It didn’t take me long to figure out a better way, instead of checking for overlapping RECTs<\/span>, you had to check if the two circles (marbles) overlapped. Let the radius of the two circles be R1<\/span> and R2<\/span>, calculate the distance between the centers of the two marbles, lets call it D<\/span>. The marbles collide when D <= R1 + R2<\/span>. Well, they actually collide when D = R1 + R2<\/span>, but because our program updates the frames by a certain delta everytime we need to check for D <= R1 + R2<\/span>.<\/div>\n

 <\/p>\n

The Collision()<\/span> function takes two BALLINFO<\/span> structures as input and determines if they collide, returns TRUE<\/span> if they do and FALSE<\/span> otherwise:<\/div>\n



\nBOOL Collision(const BALLINFO *ball1, const BALLINFO *ball2)<\/span>

\n{<\/span>

\n    int distance = 0, temp = 0;<\/span>

\n

\n    int MinDistance = ball1->radius + ball2->radius;<\/span>

\n

\n    \/\/calculate the distance between the centers of the two balls<\/span>

\n    int dx = ball2->xPos – ball1->xPos;<\/span>

\n    int dy = ball2->yPos – ball1->yPos;<\/span>

\n    temp = dx*dx + dy*dy;<\/span>

\n    distance = sqrt(temp);<\/span>

\n

\n    \/\/printf("COLLISION: distance=%d, 2*R=%d\\n", distance, MinDistance);<\/span>

\n

\n    if(distance <= MinDistance)<\/span>

\n    {<\/span>

\n        return TRUE;<\/span>

\n    }<\/span>

\n

\n    return FALSE;<\/span>

\n}<\/span><\/p>\n

We use the standard formula to calculate the distance between two points, Distance = SQRT((x2-x1)<\/span>2<\/sup> + (y2-y1)<\/span>2<\/sup>)<\/span>. If the marbles do collide then we have to calculate the new velocities for the marbles, and this is how we do it:<\/div>\n



\nvoid CalculateNewVelocities(BALLINFO *ball1, BALLINFO *ball2)<\/span>

\n{<\/span>

\n    int ed = 1, mass1 = 20, mass2 = 20;<\/span>

\n

\n    double velX1, velY1, velX2, velY2;<\/span>

\n

\n    double dx = ball2->xPos – ball1->xPos;<\/span>

\n    double dy = ball2->yPos – ball1->yPos;<\/span>

\n

\n    \/\/calculate the distance between their centers<\/span>

\n    double distance = sqrt(dx*dx+dy*dy);<\/span>

\n

\n    double vp1 = ball1->dwVelX*dx\/distance + ball1->dwVelY*dy\/distance;<\/span>

\n    double vp2 = ball2->dwVelX*dx\/distance + ball2->dwVelY*dy\/distance;<\/span>

\n

\n    double dt = (ball1->radius + ball2->radius – distance)\/(vp1 – vp2);<\/span>

\n

\n    \/\/printf("CENTERS BEFORE: X1=%d, Y1=%d     X2=%d, Y2=%d\\n", xPos1, yPos1, xPos2, yPos2);<\/span>

\n

\n    \/\/the centers of the ball when they actually collided<\/span>

\n

\n    ball1->xPos = ball1->xPos – floor(ball1->dwVelX*dt + 0.5);<\/span>

\n    ball1->yPos = ball1->yPos – floor(ball1->dwVelY*dt + 0.5);<\/span>

\n

\n    ball2->xPos = ball2->xPos – floor(ball2->dwVelX*dt + 0.5);<\/span>

\n    ball2->yPos = ball2->yPos – floor(ball2->dwVelY*dt + 0.5);<\/span>

\n

\n    \/\/now calulate the distance between centers (this should be very close to the sum of their radii)<\/span>

\n    dx = ball2->xPos – ball1->xPos;<\/span>

\n    dy = ball2->yPos – ball1->yPos;<\/span>

\n    distance = sqrt(dx*dx+dy*dy);<\/span>

\n

\n    \/\/ Unit vector in the direction of the collision<\/span>

\n    double ax = dx\/distance, ay=dy\/distance;<\/span>

\n

\n    \/\/ Projection of the velocities in these axes<\/span>

\n    double va1 = (ball1->dwVelX*ax + ball1->dwVelY*ay);<\/span>

\n    double vb1 = (-ball1->dwVelX*ay + ball1->dwVelY*ax);<\/span>

\n

\n    double va2 = (ball2->dwVelX*ax + ball2->dwVelY*ay);<\/span>

\n    double vb2 = (-ball2->dwVelX*ay + ball2->dwVelY*ax);<\/span>

\n

\n    \/\/ New velocities in these axes (after collision): ed<=1,  for elastic collision ed=1<\/span>

\n    double vaP1 = va1 + (1+ed)*(va2-va1)\/(1 + mass1\/mass2);<\/span>

\n    double vaP2 = va2 + (1+ed)*(va1-va2)\/(1 + mass2\/mass1);<\/span>

\n

\n    \/\/ Undo the projections<\/span>

\n    velX1 = vaP1*ax-vb1*ay;  velY1 = vaP1*ay+vb1*ax;\/\/ new vx,vy for ball 1 after collision<\/span>

\n    velX2 = vaP2*ax-vb2*ay;  velY2 = vaP2*ay+vb2*ax;\/\/ new vx,vy for ball 2 after collision<\/span>

\n

\n    \/\/printf("CENTERS AFTER: X1=%d, Y1=%d     X2=%d, Y2=%d\\n", xPos1, yPos1, xPos2, yPos2);<\/span>

\n

\n    \/\/printf("Old Vel: velX1=%d, velY1=%d     velX2=%d, velY2=%d\\n", dwVelX1, dwVelY1, dwVelX2, dwVelY2);<\/span>

\n

\n    \/\/new velocities of the balls<\/span>

\n    ball1->dwVelX = floor(velX1 + 0.5);<\/span>

\n    ball1->dwVelY = floor(velY1 + 0.5);<\/span>

\n    ball2->dwVelX = floor(velX2 + 0.5);<\/span>

\n    ball2->dwVelY = floor(velY2 + 0.5);<\/span>

\n

\n    \/\/undo the correction done before<\/span>

\n    ball1->xPos = ball1->xPos + floor(ball1->dwVelX*dt + 0.5);<\/span>

\n    ball1->yPos = ball1->yPos + floor(ball1->dwVelY*dt + 0.5);<\/span>

\n    ball2->xPos = ball2->xPos + floor(ball2->dwVelX*dt + 0.5);<\/span>

\n    ball2->yPos = ball2->yPos + floor(ball2->dwVelY*dt + 0.5);<\/span>

\n

\n    \/\/printf("New Vel: velX1=%d, velY1=%d     velX2=%d, velY2=%d\\n", dwVelX1, dwVelY1, dwVelX2, dwVelY2);<\/span>

\n

\n}<\/span><\/p>\n

This function is taken directly from Professor Fu-Kwun Hwang’s explanation<\/a> on 2D collisions. Changes made to the velocities and positions in CalculateNewVelocities()<\/span> will be reflected back in the caller.<\/div>\n

 <\/p>\n

Note<\/span>: I ran this program quite many times and sometimes it does fail. Maybe something like once in 30 runs. The marbles stick to each other and don’t let go. The problem is in the calculation of ‘dt<\/span>‘, where it tries to calculate where the balls would have been when they were about to collide (i.e. D = R1 + R2<\/span>), but since even this is an approximation, it fails sometimes. One fix for this problem is to check if  the balls collide after calculating the new position and velocities. If they do then adjust the position values such that new D > R1 + R2<\/span>. The problem mentioned above happens when after calculating the new positions and velocities for both marbles they still overlap.<\/div>\n

<\/p>\n","protected":false},"excerpt":{"rendered":"

The code for colliding marbles is built on top of earlier changes to the DDEX3 sample. Look here, here and here for more information. There are a few changes I made in the code for making the marbles collide and I hope you have already gone through Prof. Fu-Kwun Hwang post on how to make … Continue reading Bouncing\/Colliding marbles, DirectDraw, Part 8<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"spay_email":"","jetpack_publicize_message":"","jetpack_is_tweetstorm":false},"categories":[1],"tags":[],"jetpack_featured_media_url":"","jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p1ktFF-4b","_links":{"self":[{"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/posts\/259"}],"collection":[{"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/comments?post=259"}],"version-history":[{"count":1,"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/posts\/259\/revisions"}],"predecessor-version":[{"id":260,"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/posts\/259\/revisions\/260"}],"wp:attachment":[{"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/media?parent=259"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/categories?post=259"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/techtwaddle.co.in\/blog\/wp-json\/wp\/v2\/tags?post=259"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}