Pool

[Stonemonkey]

A MAV is usually due to reading or writing to an address that you're not supposed to such as out of the range of an array or reading/writing fast pixels outside of the screen. I've not looked into this yet but the freeze is probably due to it getting stuck in some loop somewhere.

[rain_storm]

First I would suggest abandoning the traditional 2d movement of x+dirx / y+diry with a pool game it would be far more efficient imho to work with angles and momentum you can then obtain the dirx as cos(angle)*momentum and diry as sin(angle)*momentum you could of course keep things the way they are and obtain the angle by using the atan(adjacent,opposite) command but that would mean switching between one form to the other just to revert to the original form. better to just work in angles alone. if you post the code as it is now I would incorporate this feature. also I was thinking that when the setup routine is running that if you include a tiny amount of random displacement to the ball positions it would result in a totally unique break each time. the amount of displacement should be so small that it doesnt show up on a pixel basis but large enough to have a dramatic effect on the collisions.

[Clanky]

Thanx guys. I did do abit of the angle last night, got it working - with the exception of the spin and power... but I did it before I read these.
How could I make spin? I got it working before without having cue angles, but now it has cue angles it hits it funny.
I will see where I can get too...

@ Rain_Storm: How far have you got with your pool? Have you started writting it up yet?
@ Jim: Thanx for the codes, much appreciated.

[Clanky]

Here's the newest add... it has got Jim's help code, with Rain_Storm's too... but it is still hitting funny. I know why this is:

Code: [Select]

  if dirx=0 wx=wx+cos(dx)*((power/1.2)+(wbdirx/45))

**where**
'wx' is the white ball's X position;
'dx' is the angle hit;
'power' is the total power hit - decreases;
'wbdirx' is the spin.
**     **

Hope this can clear things up... I really want to finish this game. It's been a real knowledge booster. Thanks Guys! 

[rain_storm]

Im am workin on typin it but its takin awhile its over 200 lines but its just really what you already have but with collisions (balls and pockets are the same but one scores the other bounces) and thats about it. Alright heres how spin works
1) topspin - add cos(topspin_angle) to foward momentum if this value is negative its called backspin
    topspin will make a ball travel foward faster or slower but will have the opposite effect when the ball collides
    with something backspin slow before collision fast after topspin fast before slow after

2) sidespin does this for sideways momentum and will make the ball travel along a curve to the left or right but it is
    different when the ball collides with something it changes the angle of the bounce effect slightly

whilst traveling between collisions -

Code: [Select]

   dirx = cos(ball_ang)*foward_momentum + cos(ball_ang+pi/2)*side_momentum
   diry = sin(ball_ang)*foward_momentum + sin(ball_ang+pi/2)*side_momentum
   new_posx = posx + dirx
   new_posy = posy + diry

this should help you with the collisions with other balls and walls -

Code: [Select]

open window 640,512
window origin "cc"
degree = pi/180
doubpi = pi*2
halfpi = pi/2
kg = 1
m = 30
secs = 30
mins = 60*secs
mps = m/secs
rpm = doubpi/mins

rem initialise balls -
balls = 4
radius = 30
dim posx(balls), posy(balls), posz(balls)
dim dirx(balls), diry(balls), dirz(balls)
dim rotx(balls), roty(balls), rotz(balls)
dim r(balls), g(balls), b(balls)
for b = 0 to balls
  repeat

    rem randomise ball location -
    posx(b) = ran(200) - ran(200)
    posy(b) = ran(200) - ran(200)
    posz(b) = ran(200) - ran(200)

    rem ensure initial positions are clear of other balls -
    h = radius*3
    for a = 0 to balls
      if (a <> b) then

        rem check if location is already occupied -
        adj = posx(b) - posx(a)
        opp = posy(b) - posy(a)
        hyp = sqrt(adj*adj + opp*opp)
        if (hyp < h) h = hyp
      fi
    next
  until (h>radius*2)

  rem initialise other properties -
  dirx(b) = ran(mps)*5 : rem only positive values are allowed
  diry(b) = ran(mps)*5 : rem only positive values are allowed
  dirz(b) = ran(mps)*5 : rem only positive values are allowed
  rotx(b) = ran(doubpi)
  roty(b) = ran(doubpi)
  rotz(b) = ran(doubpi)
  r(b) = ran(100)+ran(100)+ran(55) : rem balanced random colours
  g(b) = ran(100)+ran(100)+ran(55) : rem balanced random colours
  b(b) = ran(100)+ran(100)+ran(55) : rem balanced random colours
next
diry(0) = diry(0)*3

rem draw fake phong shaded balls -
sub pcircle(a,b,c) x = a+c/3 : y = b+c/3 : f = pi/8
  for e = 0 to doubpi step f
    gtriangle x,y to a+cos(e)*c,b+sin(e)*c to a+cos(e+f)*c,b+sin(e+f)*c
  next
end sub

repeat
  setdispbuf draw
  draw = 1 - draw
  setdrawbuf draw
  clear window

  rem draw balls
  for b = 0 to balls
    red = r(b)
    grn = g(b)
    blu = b(b)
    setrgb 1, red, grn, blu
    setrgb 2, red/10, grn/10, blu/10
    setrgb 3, red/10, grn/10, blu/10
    pcircle(posx(b),posy(b),radius)
    setrgb 1, red*2, grn*2, blu*2
    fill circle posx(b)+radius/3,posy(b)+radius/3,3
  next

  rem collision detection
  for b = 0 to balls

    rem update current ball position -
    posx(b) = posx(b) + cos(rotz(b))*diry(b)
    posy(b) = posy(b) + sin(rotz(b))*diry(b)

    rem check new position against other balls
    for a = 0 to balls
      if (a <> b) then

        rem calculate the distance between both balls
        adj = posx(b) - posx(a)
        opp = posy(b) - posy(a)
        hyp = sqrt(adj*adj + opp*opp)

        rem check if both balls overlap -
        if (hyp < radius*2) then

          rem find out how much they are overlapping by -
          penetration = (radius*2) - hyp

          rem rewind the current ball to the point of collision -
          posx(b) = posx(b) - cos(rotz(b))*penetration
          posy(b) = posy(b) - sin(rotz(b))*penetration

          rem calculate new trajectories for the both balls -
          rotz(b) = atan(-adj, opp) + halfpi
          rotz(a) = atan(-adj, opp) - halfpi

          rem energy is transferred between both balls and
          rem each ball will lose energy as a result -
          dx = dirx(b)/4 + dirx(a)/4 : rem relative velocity x
          dy = diry(b)/4 + diry(a)/4 : rem relative velocity y
          dx = dx*0.8 : rem coefficient of restitution
          dy = dy*0.8 : rem coefficient of restitution
          dirx(a) = dirx(a)/2 + dx
          diry(a) = diry(a)/2 + dy
          dirx(b) = dirx(b)/2 + dx
          diry(b) = diry(b)/2 + dy
        else
          dirx(b) = dirx(b)*0.9999 : rem coefficient of friction
          diry(b) = diry(b)*0.9999 : rem coefficient of friction
        fi
      fi
    next

    rem ensure that current ball doesn't leave the screen -
    if    (posx(b) < -320+radius) then
      rotz(b) = pi - rotz(b)
      posx(b) = -320 + radius
    elsif (posx(b) >  320-radius) then
      rotz(b) = pi - rotz(b)
      posx(b) =  320 - radius
    fi
    if    (posy(b) < -256+radius) then
      rotz(b) = -rotz(b)
      posy(b) = -256 + radius
    elsif (posy(b) >  256-radius) then
      rotz(b) = -rotz(b)
      posy(b) =  256 - radius
    fi
  next
until (1 = 0)


[Clanky]

Thanks, I will take this into account.

[rain_storm]

I will include the angular movement and collisions in the last version of pool you posted tomarrow and will put it on the forum its far too late now

[rain_storm]

Guese what I'm takin the day off today I should've been sleepin last night but I just couldn't help it and threw this together its fairly bug free and commented too
###############################
# Comments that look like this are important #
###############################

enjoy

[Jim]

That's a lot of progress for one night!  K++!

The collisions look pretty inelastic at the moment - is it possible to reduce the total enery at the time of the collision?  That would model real life where some kinetic energy is lost as sound and heat, and might make it look a little more realistic.

How well does it handle smashing a pack?  How well does it handle a very fast cue ball hitting (or not!) a stationary ball?

Jim

[rain_storm]

Aha well spotted you're exactly right the balls are alot harder than the code above implies since I set the coefficient of restitution to around 0.8 when it should be above 0.9 for balls that hard but this is because all the balls momentum is randomised so there is far more energy on the table at the moment then there would be from the break with all balls stationary also I have set the coefficient of restitution for the bunkers stlightly lower 0.78 i think to reflect the softer surface, the coefficient of friction is 0.999 preatty smooth slowdown and the coefficient for angular momentum is 0.99 so balls will stay spinnin for quite a bit these values must be played with to suit a static layout with only the cue ball having momentum and I have left notes in the code of how to play with them and what ranges are good.
From my own observations the maximum speed you can get away with before collisions begin to suffer is about 10 meters per second since the screen is updated 100 times per second, one meter is also 100 this means that at 1*mps a ball will travel one pixel each frame so at 10*mps a ball will move exactly one radius (radius = 10) each frame I have included a feature that forbids overlapping balls by rewinding the moving ball to the point of collision but if the ball moves more than one radius that feature may move the ball to the opposite side of the other ball and generate incorrect collisions also the bunkers are a bounding box with the balls inside it there is the possibility that a ball may get stuck outside those bounds and start vibrating. this is also stated in the code but again well spotted as this is an important part in a pool game the physics have got to be right in fact the only thing you can really cheat is the balls mass which is the same for all balls so it can be assumed to be one and ignored. phew that was a long post

[Jim]

if the ball moves more than one radius that feature may move the ball to the opposite side of the other ball

If you limit it to < half a ball radius that can't happen.

Jim

[rain_storm]

thats gonna have to be the road to take
I've noticed a bug in the way I was rewinding the moving ball back to the point of collision thats messin things up in the pack.
At the destination point ball A is overlapping ball B. so we rewind ball A to the point of collision, but at this point in time ball A's new position overlaps ball C, collisions are not detected between ball A and ball C. by right we should collide with ball C, ignore ball A and let that be that. but we are in the middle of a for next loop so it will also require a goto statement to break out of it. but what if there are two balls occupying a part of that new space. Its gonna be a real problem if at any point an overlap is missed and two ball become glued together. The best solution I can think of is to simply detect collisions in one loop then find the closest of those in another loop. complex or what?

[Jim]

  I'm pretty sure there are some good articles on the web about this.

[JumpMan]

I have this code I downloaded a while back when I was still using Blitzbasic. It  may not be exactly what you are looking for but, maybe it is helpfull to somebody.

Code: [Select]

;------------------------------------------
;2D COLLISION DEMO CODE
;------------------------------------------
; By Joseph 'Phish' Humfrey
; This type of collision response isn't
; just useful for pool and billiard style
; games, and in fact, I didn't write it for
; that reason at all. I wrote it because I
; needed to have collision for the space
; ships in my game 'Unity'. When their
; shields are up, they use this relatively
; simple method. It can be used for almost
; anything - player character bouncing off
; enemies in a platform game, to space
; ship collision, to a game which does
; actually involve balls. The basic
; algorithm which I used would work for
; both 2d and 3d, so if you would like to
; see it, email me at phish@aelius.com
;------------------------------------------
; The actual code which works out what
; happens after a collision is in the
; UpdateCirclePhysics() function.
;------------------------------------------
; Enjoy!
;------------------------------------------
;------------------------------------------

Graphics 800, 600, 16, 2
SetBuffer BackBuffer()
SeedRnd MilliSecs()



;------------------------------------------
; MAIN DATA TYPE
;------------------------------------------
; This exact type isn't supposed to be used
; Instead, you should use some of the fields
; in your own type, or just use this one
; for reference, to see what each field does
Type circle
Field x#, y#;position
Field dx#, dy#;x and y speeds

Field radius#;radius of circle
Field mass#;mass of circle
End Type
;------------------------------------------
;------------------------------------------






;------------------------------------------
; SET UP BALLS INTO A POOL STYLE ARRANGEMENT
; FOR DEMO
;------------------------------------------
.Setup
ballTriangleSize=5
For xloop = ballTriangleSize To 1 Step -1
For yloop = 1 To xloop
c.circle = New circle
c\x = (5-xloop)*27 + 200
c\y = yloop*31-(xloop*31)/2.0 + 300
c\dx=0
c\dy=0
c\radius = 15
c\mass = 50
Next
Next

;Cue ball (smaller so you know which it is :)
cue.circle = New circle
cue\x = 800
cue\y = 300 +20
cue\dx = -20
cue\dy = Rnd(4)-2
cue\radius = 14
cue\mass = 50
;------------------------------------------
;------------------------------------------







;------------------------------------------
;MAIN LOOP
;------------------------------------------
; This is the main While..Wend game loop
While Not KeyDown(1)

Cls

UpdateCirclePhysics()
RenderCircles()

;------------
; Reset button
Text 10, 10, "Press a mouse button to reset."
Text 10, 25, "Press Esc to exit."
If GetMouse() Then
For c.circle = Each circle
Delete c
Next
Goto setup
End If
;------------

Flip

Wend
;------------------------------------------
;------------------------------------------
End









;------------------------------------------
Function UpdateCirclePhysics()
;------------------------------------------
; This is the main physics function for the
; circles. It contains the very basic
; movement physics as well as the collision
; response code.
;------------------------------------------

For c.circle = Each circle

;update positions
c\x=c\x+c\dx
c\y=c\y+c\dy

;gradually slow down
c\dx=c\dx*0.991
c\dy=c\dy*0.991

;------------------------------------------
;COLLISION CHECKING
;------------------------------------------
; Check each circle in the loop against
; every other (c against c2)
For c2.circle = Each circle

collisionDistance# = c\radius+c2\radius
actualDistance# = Sqr((c2\x-c\x)^2+(c2\y-c\y)^2)

;Collided or not?
If actualDistance<collisionDistance Then

collNormalAngle#=ATan2(c2\y-c\y, c2\x-c\x)

;Position exactly touching, no intersection
moveDist1#=(collisionDistance-actualDistance)*(c2\mass/Float((c\mass+c2\mass)))
moveDist2#=(collisionDistance-actualDistance)*(c\mass/Float((c\mass+c2\mass)))
c\x=c\x + moveDist1*Cos(collNormalAngle+180)
c\y=c\y + moveDist1*Sin(collNormalAngle+180)
c2\x=c2\x + moveDist2*Cos(collNormalAngle)
c2\y=c2\y + moveDist2*Sin(collNormalAngle)


;------------------------------------------
;COLLISION RESPONSE
;------------------------------------------
;n = vector connecting the centers of the circles.
;we are finding the components of the normalised vector n
nX#=Cos(collNormalAngle)
nY#=Sin(collNormalAngle)

;now find the length of the components of each movement vectors
;along n, by using dot product.
a1# = c\dx*nX  +  c\dy*nY
a2# = c2\dx*nX +  c2\dy*nY

;optimisedP = 2(a1 - a2)
;             ----------
;              m1 + m2
optimisedP# = (2.0 * (a1-a2)) / (c\mass + c2\mass)

;now find out the resultant vectors
;r1 = c1\v - optimisedP * mass2 * n
c\dx = c\dx - (optimisedP*c2\mass*nX)
c\dy = c\dy - (optimisedP*c2\mass*nY)

;r2 = c2\v - optimisedP * mass1 * n
c2\dx = c2\dx + (optimisedP*c\mass*nX)
c2\dy = c2\dy + (optimisedP*c\mass*nY)

End If

Next
;------------------------------------------
;------------------------------------------


;Simple Bouncing off walls.
If c\x<c\radius Then
c\x=c\radius
c\dx=c\dx*-0.9
End If
If c\x>GraphicsWidth()-c\radius Then
c\x=GraphicsWidth()-c\radius
c\dx=c\dx*-0.9
End If
If c\y<c\radius Then
c\y=c\radius
c\dy=c\dy*-0.9
End If
If c\y>GraphicsHeight()-c\radius Then
c\y=GraphicsHeight()-c\radius
c\dy=c\dy*-0.9
End If

Next

End Function





;------------------------------------------
Function RenderCircles()
;------------------------------------------
; Simple function draws all the circles
; on the screen.
;------------------------------------------

For c.circle = Each circle
If c\radius=15 Then Color 200, 50, 50 Else Color 255, 255, 255
Oval c\x-c\radius, c\y-c\radius, c\radius*2, c\radius*2
Next

End Function
;------------------------------------------
;------------------------------------------


[Clanky]

I've done some great graphics for this game now...
I had a look at your collisions Rain, but it was too complex for my simple mind - great though!

I have done all the rules, and have pause & restart options. All I need now is the collisions and to fix the spin (can't get it to work even with your codes Rain?... don't know whats going on there) and it's finished.

For the spin, I have said (along the line of):

Code: [Select]

side_momentum = (power + spin_x)
forward_momentum = (power + spin_y)
I did this because the side spin will be affected by the x-spin value, and the forward the y-spin value??? Correct?
I can get back spin, but not top or either side spin?
I also need to find a way to make it so when the white ball hits something else - wall(s) or ball(s) - it changes it's spin... if I read correctly in one of your post's Rain?

Great help you guys... this is the most inspiring game out I have tried to make!!!

Oh... and to Stonemonkey: I showed a friend your pool clone program and he was impressed! I think that maybe, if you would like - maybe look at completing it with rules and stuff... because that would be a great game!!!

[rain_storm]

hypotenuse as you know must be less than 2*radius for a collision to occur after that you can use adj and opp to determine the angle of the line of action. the trajectories will change according to this angle its the angle of the line between both center points. Its easier to use atan because this will return the tan of that angle. so the value in line_of_action isnt the true line of action but rather a line perpendicular to it, this is in effect a wall angled correctly that both balls simply bounce away from. once we have that angle we either add or subtract 90 degrees (pi/2) for each ball

Code: [Select]

adj = ballx(a) - ballx(b) : rem (distance between centters along x axis)
opp = bally(a) - bally(b) : rem (distance along y axis)
hyp = sqrt(adj*adj + opp*opp) : rem (true distance between points)
if (hyp < radius*2) then
   line_of_action = atan(-adj, opp)
   trajectory(a) = line_of_action + pi/2 : rem new angle for ball a
   trajectory(b) = line_of_action - pi/2 : rem new angle for ball b
fi
this will send the both balls heading off in the correct direction. Once you got it you will see that circle to circle collisions are far more easy and much faster than box to box collisions

[rain_storm]

Sorry Clanky, I misread what you were asking.

   "side_momentum = (power + spin_x)
    forward_momentum = (power + spin_y)"

(side_momentum = (power + spin_x) <- is spin_x the current rotation value or the increment? You need to find the increment its the rate of rotation that is effecting side momentum not the current angle. should be more like this)

    side_momentum = cos(spin_x_increment)    <-    no power added here power effects foward momentum
    forward_momentum = power + cos(spin_y_increment)
    (if cos isnt workin try sin its the same principal though)

"I did this because the side spin will be affected by the x-spin value, and the forward the y-spin value??? Correct?
I can get back spin, but not top or either side spin?
I also need to find a way to make it so when the white ball hits something else - wall(s) or ball(s) - it changes it's spin... if I read correctly in one of your post's Rain?"

now you have backspin workin thats a sign that you are on the right road with foward momentum. sidespin should be one of the last things you add in you need to get the collisions running perfectly or else you will not be able to observe how sidespin is effecting things. it should only have a slight effect on the balls motion until the ball hits something then sidespin becomes really noticeable as the ball shoots off in a direction you would not have expected it should be a lot easier once the collisions are up and runnin

[Clanky]

K, that makes it abit clearier... i will try the collisions again, and wait till i get that working - then try the spins haha!
Can't wait for this sucker to be complete!!! YAYz

Thanks for your help 'again' Rain... been a pleasure working on this with you.

[rain_storm]

You're gonna get a ton of karma when its done I'll see to that

[Clanky]

Ok, here's the problem...

My old computer which I used to make the pool game can't burn CD's, and my new computer doesn't have a floppy disc drive... and, to top that off, my brothers' MP3 is stuffing up - like normal - so I am not able to put it up here Rain... gawd annoying things like this get too me real bad!

I have no way in knowing when I can get it up here for you Rain if you want to fix it, so I guess I will have to keep trying... bare with me.