Simple Pinball or Minigolf

BlitzMax Forums/BlitzMax Beginners Area/Simple Pinball or Minigolf

Shortwind

(Posted 2011) [#1]

Anyone have any code they would like to share on a simple version of a pinball game, or mini-golf? Blitzmax simple 2D preferred.

Issues associated with this project, Pinball oriented:

1. How to make the ball (round of course) follow around a curved surface.

2. Realistic kickback off Round bumpers, straight bumbers.

3. How to simulate the rubber on a kicker/flipper so the ball doesn't "bounce" too much when rolling onto a flipper. How did you handle the "sticky" feel of a flipper for better ball control?

4. I assume instead of reinventing some of the wheels there is a good blitzmax physics library that handles weight, gravity, hardness of the object, shape of the object, etc?

5. This project is just too hard and I should let the professionals figure it out. :)

Of course in this day and age, using a 3d engine would make for much better graphics. But alas, I don't do 3d. :(

It would be awesome if someone would re-create all the pinball machines from the classics. There was a project to do this, but last I knew it died. There are some really awesome pinball machines out there. And some of the funnest ones were not even complicated.

Well, didn't know if anyone had created a pinball game for max, so thought i'd ask if there is any code that people would like to share.

:)

Last edited 2011

YellBellzDotCom

(Posted 2011) [#2]

Depending on how much time your willing to spend on such a project, I would look at using a pong style structured game. Get the basics in, get the ball moving around and bouncing off objects, get user input in for starting the ball, flicking the flappers, etc.

Once you get that you can always add stuff. Including a rewrite using an existing 2d physics library.

Just a thought!

TomToad

(Posted 2011) [#3]

Using something like Box2d might help. It's one of Brucey's mods. The bounciness can be adjusted on various objects to simulate everything from cement to glue. You can even have an object add to yhe velocity such as a bumper would do.

therevills

(Posted 2011) [#4]

Maybe look for Gfk's Hole In One - I believe there is source code was available with Blitz at on time...

EOF	(Posted 2011) [#5]

Here is something to play around with. The example lets you fire a ball around, which will bounce off walls (vector lines)
There is an edit mode so that you can add/clear lines

Small bug: Occasionally, the ball will 'jitter' and escape through a line. I don't know how to stop this though

Example #1

SuperStrict

Framework BRL.GLMax2D
Import BRL.Blitz
Import "vec2d.bmx"

' ###########################
vec2d.UpdateTimer

Global wallList:TList=New TList
Global w:vec2d
w=vec2d.Create(200,280,460,340) ; wallList.addlast w
w=vec2d.Create(460,340,500,300) ; wallList.addlast w
w=vec2d.Create(500,300,320,80) ; wallList.addlast w
w=vec2d.Create(320,80,190,160) ; wallList.addlast w

' set up ball
Global ball:vec2d=vec2d.Create(120,380,124,382)
ball.rad=14
ball.SetLength 5
ball.fric=0.984
ball.vx=0 ; ball.vy=0

Global starttime% , timeout%
Global mx# , my#

Type edit
	Global mode%,line%,sx%,sy%,mx%,my%
End Type

Graphics 640,480
AddSideWalls

' =======================================================
Repeat
	vec2d.UpdateTimer
	Cls
	If KeyHit(KEY_E)
		edit.mode=~edit.mode ; FlushMouse
		If edit.mode=False
			edit.line=0 ; ball.vx=0 ; ball.vy=0
		EndIf
	EndIf
	If edit.mode
		Editor
	Else
		GameUpdate
	EndIf	
	Flip
Until KeyDown(key_escape)
' =======================================================

Function GameUpdate()
	ball.Update
	ball.x1 = ball.x0+ball.vx ; ball.y1 = ball.y0+ball.vy
	ball.Calc
	' draw walls
	SetColor $88,$22,$22
	For w=EachIn wallList
		DeflectBall ball,w
		w.Draw
	Next
	' draw ball (and its vector line)
	SetColor $ff,$ff,$ff
	ball.Draw
	SetColor $00,$ff,$00
	ball.DrawVector
	'
	If ball.moving=False
		mx=MouseX() ; my=MouseY()
		SetColor $77,$77,$77
		DrawLine ball.x0,ball.y0 , mx,my
		If MouseHit(1)
			Local d#=Dist(mx,my,ball.x0,ball.y0)
			Local a#=Ang(mx,my,ball.x0,ball.y0)
			ball.vx=Sin(a)*(d/3.5)
			ball.vy=-Cos(a)*(d/3.5)
		EndIf
	EndIf
	Msg "[LMB] Shoot    [E] Edit mode"
End Function

' =======================================================

Function Editor()
	Cls
	Msg "[LMB] Draw walls    [C] Clear all walls    [E] Exit edit mode"
	edit.mx=MouseX() ; edit.my=MouseY()
	If KeyHit(KEY_C)
		wallList.Clear ; AddSideWalls
	EndIf
	SetColor $99,$64,$aa
	For w=EachIn wallList
		DrawLine w.x0,w.y0,w.x1,w.y1
	Next
	If MouseDown(1)
		If edit.line=0
			edit.sx=MouseX() ; edit.sy=MouseY()
			edit.line=1
		EndIf
		If edit.line=1
			' add new line when length is long enough
			If dist(edit.sx,edit.sy,edit.mx,edit.my)>32
				w=vec2d.Create(edit.sx,edit.sy,edit.mx,edit.my)
				wallList.addlast w
				edit.sx=edit.mx ; edit.sy=edit.my
			EndIf
		EndIf
	Else
		edit.line=0
	EndIf
End Function

Function Msg(t$)
	SetColor $ff,$ff,$ff
	DrawText t$,10,5
End Function

Function AddSideWalls()
	w=vec2d.Create(0,0,GraphicsWidth(),0) ; wallList.addlast w
	w=vec2d.Create(0,GraphicsHeight(),GraphicsWidth(),GraphicsHeight()) ; wallList.addlast w
	w=vec2d.Create(0,0,0,GraphicsHeight()) ; wallList.addlast w
	w=vec2d.Create(GraphicsWidth(),0,GraphicsWidth(),GraphicsHeight()) ; wallList.addlast w
End Function

vec2d.bmx (Import code)

SuperStrict

Import BRL.Blitz

Type vec2d
	Global thisTime%,frameTime#,lastTime%
	Global BallLineDist#
	Field x0#,y0#,x1#,y1#
	Field vx#,vy# , dx#,dy# , rx#,ry# , lx#,ly#
	Field ax#,ay# , rad# , fric#
	Field Length# , moving%
	'
	Function Create:vec2d(nx0#,ny0#,nx1#,ny1#)
		Local v:vec2d=New vec2d
		v.x0=nx0 ; v.y0=ny0 ; v.x1=nx1 ; v.y1=ny1
		v.Calc
		Return v
	End Function
	'
	Method MoveTo(nx0#,ny0#)
		x1:+nx0-x0 ; y1:+ny0-y0
		x0=nx0 ; y0=ny0
		'Calc
	End Method
	'
	Method PointTo(nx#,ny#)
		x1=nx ; y1=ny
		vx = x1-x0 ; vy = y1-y0
		SetLength Length
	End Method
	'
	Method Move(amt#=-123.321)
		If amt=-123.321 Then amt=Length
		x0:+dx*amt; y0:+dy*amt
		x1:+dx*amt ; y1:+dy*amt
	End Method

	Method SetLength(l#)
		Length=l
		Local a#=180-ATan2(vx,vy)
		vx=Sin(a)*Length
		vy=-Cos(a)*Length
		x1=x0+vx ; y1=y0+vy
		Calc
	End Method
	'
	Method Calc(vec%=False)
		' vector x and y
		vx = x1-x0 ; vy = y1-y0
		' length of vector
		Length = Sqr(vx*vx+vy*vy)
		' normalized unit-sized components
		If (Length>0) ' avoid dividing by 0
			dx = vx/Length ; dy = vy/Length
		EndIf
         ' Right hand and Left hand normals
		If vec=False
			rx = -vy ; ry = vx
			lx = vy ; ly = -vx
		Else
         		rx = -dy ; ry = dx
         		lx = dy ; ly = -dx
		EndIf
	End Method
	'
	Function UpdateTimer()
		vec2d.thisTime=MilliSecs()
		vec2d.frameTime=Float(vec2d.thisTime-vec2d.lastTime)/100.0
		vec2d.lastTime=vec2d.thisTime
	End Function
	'
	Method Update()
		vx:+ax ; vy:+ay ' acceleration
		vx:*fric ; vy:*fric
		moving=True
		If (vx>-0.06 And vx<0.06) Then vx=0
		If (vy>-0.06 And vy<0.06) Then vy=0
		If (vx=0 And vy=0) Then moving=False
		x0:+vx*vec2d.frameTime
		y0:+vy*vec2d.frameTime
	End Method
	'
	Method Draw()
		If rad>0
			DrawOval x0-rad,y0-rad,rad*2,rad*2
		Else
			DrawLine x0,y0,x1,y1
		EndIf
	End Method
	'
	Method DrawVector()
		DrawLine x0,y0,x0+vx,y0+vy
	End Method
	'
	Method DrawExtra()
		SetColor $ff,$00,$00 ; DrawLine x0,y0,x0+lx,y0+ly ' LH Normal
		SetColor $00,$ff,$00 ; DrawLine x0,y0,x0+rx,y0+ry ' RH Normal
	End Method
	'
	Method ShowInfo(y%=10)
		SetColor $60,$60,$60
		DrawText "X0="+String(x0)+"  Y0="+String(y0) , 5,y
		DrawText "X1="+String(x1)+"  Y1="+String(y1) , 5,y+16
		DrawText "vx="+String(vx)+"  vy="+String(vy) , 5,y+32
		DrawText "dx="+String(dx)+"  dy="+String(dy) , 5,y+48
		DrawText "Length="+String(Length), 5,y+64
		DrawText "lx="+String(lx)+"  ly="+String(ly) , 5,y+80
		DrawText "rx="+String(rx)+"  ry="+String(ry) , 5,y+96
	End Method
End Type


' Returns dot product of 2 vectors
' if [+] vectors go in same direction
' if [-] vectors go in opposite directions
Function DotProduct#(v1:vec2d,v2:vec2d)
	Return v1.vx*v2.vx + v1.vy*v2.vy
End Function

' Returns perpendicular dot product of 2 vectors
Function PerpProduct#(v1:vec2d, v2:vec2d)
	Return v1.vx*v2.vy - v1.vy*v2.vx
End Function

' return the interection point x/y where 2 vectors cross
' vx and vy hold vector coords for v1<-->v2
Function IntersectionPoint:vec2d(vec1:vec2d,vec2:vec2d)
	Local vec3:vec2d=New vec2d
	vec3.vx = vec2.x0 - vec1.x0
	vec3.vy = vec2.y0 - vec1.y0
	Local t# = PerpProduct(vec3,vec2) / PerpProduct(vec1,vec2)
	vec3.x0=vec1.x0 + vec1.vx*t
	vec3.y0=vec1.y0 + vec1.vy*t
	Return vec3
End Function

Function Dist#(x1#,y1#,x2#,y2#)
	Local dx#=Abs(x1-x2)
	Local dy#=Abs(y1-y2)
	Return Sqr(dx*dx + dy*dy)
End Function

Function Ang#(x1#,y1#,x2#,y2#)
	Local dx#=x1-x2
	Local dy#=y1-y2
	Return 180.0-ATan2(dx,dy)
End Function

' project movement vector v1 on v2
Function ProjectV:vec2d (vec1:vec2d , vec2:vec2d)
	' find dot product
	Local dp# = vec1.vx*vec2.vx + vec1.vy*vec2.vy
	Local proj:vec2d = New vec2d
	' projection components
	proj.vx = dp*vec2.dx ; proj.vy = dp*vec2.dy
	Return proj
End Function

' project vectors v1 on v2 (unit-based)
Function ProjectU:vec2d (vec1:vec2d , vec2:vec2d)
	Local proj:vec2d = New vec2d
	Local dp# = vec1.vx*vec2.dy + vec1.vy*-vec2.dx
	proj.vx = dp*(vec2.dy/vec2.Length)
	proj.vy = dp*(-vec2.dx/vec2.Length)
	' projection components
	Return proj
End Function

' project vectors v1 LH normal on v2
Function ProjectN:vec2d (vec1:vec2d , vec2:vec2d , LH%=True)
	Local dp# ' for dot product
	Local proj:vec2d = New vec2d
	If LH
		dp = vec1.vx*vec2.lx + vec1.vy*vec2.ly ' LH normal
		proj.vx = dp*(vec2.lx/vec2.Length)
		proj.vy = dp*(vec2.ly/vec2.Length)
	Else
		dp = vec1.vx*vec2.rx + vec1.vy*vec2.ry ' RH normal
		proj.vx = dp*(vec2.rx/vec2.Length)
		proj.vy = dp*(vec2.ry/vec2.Length)
	EndIf
	' projection components
	Return proj
End Function

' returns a vector collision from point (v1) to line (v2)
Function ProjectPointToLine:vec2d(v1:vec2d,v2:vec2d)
	Local v3:vec2d=ProjectN(v1,v2)
	v3.x0=v1.x0 ; v3.y0=v1.y0
	Local ip:vec2d=IntersectionPoint(v3,v2)
	v3.x1=ip.x0 ; v3.y1=ip.y0
	v3.Calc
	Return v3
End Function

Function Deflect:vec2d(vec1:vec2d , vec2:vec2d)
	'find intersection point
	Local vec3:vec2d=IntersectionPoint(vec1,vec2)
	' projection of movement vector on v2
	Local proj1:vec2d=ProjectV(vec1,vec2)
	' projection of movement vector on v2 (normal)
	Local proj2:vec2d=ProjectN(vec1,vec2)
	' reverse projection on the normal
	proj2.vx:*-1 ; proj2.vy:*-1
	' add up projecions to get deflected vector
	vec3.vx=proj1.vx+proj2.vx
	vec3.vy=proj1.vy+proj2.vy
	vec3.x1=vec3.x0+vec3.vx ; vec3.y1=vec3.y0+vec3.vy
	Return vec3
End Function

' Deflects a ball away from a wall if it is colliding
' The balls movement vector is deflected and the ball is
' moved off the wall thus clearing the collision
Function DeflectBall(v1:vec2d,v2:vec2d)
	Local d#=PointToLineDist(v1,v2)
	If d>v1.rad Return
	Local dp#
	Local oldlen#=v1.Length
	Local v3:vec2d=New vec2d
	' Find vector from the starting point of wall (v2)
	' to the center of ball (v1)
	v3.vx=v1.x0-v2.x0 ; v3.vy=v1.y0-v2.y0
	' find dot product between new vector (v3) and wall (v2) 
	dp#=v3.vx*v2.dx + v3.vy*v2.dy
	' if dot product <0 ball is closer to the starting point
	If dp<0
		v3.x0=v2.x0 ; v3.y0=v2.y0
		v3.x1=v3.x0+v3.vx ; v3.y1=v3.y0+v3.vy
		v3.SetLength v1.rad-Abs(d)+0.5
		v1.x1=v1.x0+v3.vx ; v1.y1=v1.y0+v3.vy
		v1.Calc ; v1.SetLength oldlen
		' move ball away from v2 start point
		v1.MoveTo v1.x0+v3.vx , v1.y0+v3.vy
		Return
	EndIf
	' Find vector from the ending point of wall (v2)
	' to the center of ball (v1)
	v3.vx=v1.x0-v2.x1 ; v3.vy=v1.y0-v2.y1
	' if dot product >0 ball is closer to the ending point
	dp#=v3.vx*v2.dx + v3.vy*v2.dy
	If dp>0
		v3.x0=v2.x1 ; v3.y0=v2.y1
		v3.x1=v3.x0+v3.vx ; v3.y1=v3.y0+v3.vy
		v3.SetLength v1.rad-Abs(d)+0.5
		v1.x1=v1.x0+v3.vx ; v1.y1=v1.y0+v3.vy
		v1.Calc ; v1.SetLength oldlen
		' move ball away from v2 start point
		v1.MoveTo v1.x0+v3.vx , v1.y0+v3.vy
		Return
	EndIf
	' ball must be closest to side of wall
	v3=ProjectPointToLine(v1,v2)
	v3=Deflect(v1,v2)
	v3.vx=v3.x1-v1.x1 ; v3.vy=v3.y1-v1.y0
	v1.x1=v1.x0+v3.vx ; v1.y1=v1.y0+v3.vy
	v1.Calc ; v1.SetLength oldlen
	' move ball away for wall
	Local wn:vec2d=ProjectN(v3,v2)
	wn.SetLength v1.rad-Abs(d)+0.5
	v1.MoveTo v1.x0+wn.vx , v1.y0+wn.vy
End Function

' Returns amount of penetration a ball is making into a line
' 0.0 means no contact
Function Penetration#(ball:vec2d,line:vec2d)
	Local p#=(PointToLineDist(ball,line)-ball.rad)
	If p>0.0 Then Return 0.0
	Return -p
End Function

' Returns the distance from POINT (pVec) to 
' closest point on LINE segment (lVec)
Function PointToLineDist#(pVec:vec2d,lVec:vec2d)
	Local dx#=lVec.x1-lVec.x0
	Local dy#=lVec.y1-lVec.y0
	Local t# = ( (pVec.y0-lVec.y0)*dy + (pVec.x0-lVec.x0)*dx ) / (dy*dy + dx*dx)
	If t<0
		dx=lVec.x0 ; dy=lVec.y0
	ElseIf t>1
		dx=lVec.x1 ; dy=lVec.y1
	Else
		dx = lVec.x0+t*dx
		dy = lVec.y0+t*dy
	End If
	dx:-pVec.x0 ; dy:-pVec.y0
	Return Sqr(dx*dx + dy*dy)
End Function