High Fixed Rate Logic

Monkey Forums/Monkey Programming/High Fixed Rate Logic

erebel55

(Posted 2014) [#1]

I am developing a game for android and ios that is getting close to release. For timing I found the following thread quite a while ago

http://www.monkeycoder.co.nz/Community/posts.php?topic=449

From here I copied the high fixed rate logic method that therevills uses in the following sample.

Strict

import mojo

' Store the device width and height
Global SCREEN_WIDTH%
Global SCREEN_HEIGHT%

' Game Width and Height
Const WIDTH#=320
Const HEIGHT#=240

Global game:MyGame

Function Main:int()
	game = new MyGame()
	return 0
End Function

Class MyGame extends App
	Field player:Player
	Field level:Level

	Field offsetX#, offsetY#
	Field scrollX#, scrollY#

	Field frameRate# = 200
	Field ms# = 0
	Field tmpMs#
	Field numTicks#
	Field lastNumTicks#
	Field maxMs% = 50
	Field lastTime#

	Method OnCreate:Int()

		SetUpdateRate 60
		
		' Store the device width and height
		SCREEN_WIDTH = DeviceWidth()
		SCREEN_HEIGHT = DeviceHeight()
		
		level = new Level()
		level.load()
		
		' timing
		player = new Player(level.playerX, level.playerY)
		ms = 1000 / frameRate
		numTicks = 0
		lastNumTicks = 1
		lastTime = Millisecs()
		
		return 0
	End Method
	
	Method OnUpdate:Int()
		local now% = Millisecs()
		
		If now < lastTime
			numTicks = lastNumTicks
		else
			tmpMs = now - lastTime
			if tmpMs > maxMs tmpMs = maxMs
			numTicks = tmpMs / ms
		Endif
	
		lastTime = now
		lastNumTicks = numTicks
	
		For local i% = 1 to Floor(numTicks)
			player.update()
		Next
		
		return 0
	End Method
	
	Method OnRender:Int()
		FPSCounter.update()
		Cls 
		PushMatrix 
		Scale SCREEN_WIDTH/WIDTH, SCREEN_HEIGHT/HEIGHT
		level.draw()
		player.draw(game.scrollX, game.scrollY)
		DrawText "Ticks:" + numTicks, 10, 10
		FPSCounter.draw(10, 20)
		PopMatrix
		return 0
	End Method	
end class

Class GameImage
	Field w%, h%
	Field w2%, h2%
End Class

Class Player
	Field x#, y#
	Field dx#, dy#
	Field speedX#, speedY#
	Field image:GameImage
	Field jumping:Bool
	
	Method New(x#, y#)
		self.x = x
		self.y = y
		image = new GameImage
		image.w = 16
		image.h = 16
		image.w2 = image.w / 2
		image.h2 = image.h / 2
		speedX = 1
		speedY = 3
	End Method
	
	Method draw:Void(offsetx# = 0, offsety# = 0)
		SetColor 0,255,0
		DrawOval x - image.w2 - offsetx, y - image.h2 - offsety, image.w, image.h
		SetColor 255, 255, 255
	End Method
	
	Method update:Void()
	
		if KeyDown(KEY_LEFT)
			Local tempx# = x - speedX
			if game.level.getCollisionTile(tempx - image.w2 , y + image.h2 - 1 ) = 0 and
				game.level.getCollisionTile(tempx - image.w2 , y - image.h2) = 0 and
				game.level.getCollisionTile(tempx - image.w2 , y) = 0 then
						
				x = tempx
			else
				x = round((x-image.w2)/Level.TILE_SIZE)*Level.TILE_SIZE + image.w2
			endif
		else if KeyDown(KEY_RIGHT)
			Local tempx# = x + speedX
			if game.level.getCollisionTile(tempx + image.w2 , y + image.h2 - 1 ) = 0 and
				game.level.getCollisionTile(tempx + image.w2 , y - image.h2) = 0 and
				game.level.getCollisionTile(tempx + image.w2 , y) = 0 then
				
				x = tempx
			else
				x = round((x+image.w2)/Level.TILE_SIZE)*Level.TILE_SIZE - image.w2
			endif
		End if
		
		If KeyDown(KEY_SPACE) And not jumping Then
			dy=-speedY
			jumping = true
		EndIf
		
		Local amount:Int = 1
		Local amountY:int = 1
		
		if not jumping
			if game.level.getCollisionTile(x - image.w2 + amount, y + image.h2) = 0 and 
				game.level.getCollisionTile(x + image.w2 - amount, y + image.h2) = 0 and 
				game.level.getCollisionTile(x, y + image.h2) = 0 then
				
				jumping = true
			endif
		endif
		
		if jumping
			dy +=Level.GRAVITY
			
			local tempY# = y + dy
			if dy <> 0
				if dy > 0
					if game.level.getCollisionTile(x - image.w2 + amount, tempY + image.h2 - amountY) > 0 or 
						game.level.getCollisionTile(x + image.w2 - amount, tempY + image.h2 -amountY) > 0 or
						game.level.getCollisionTile(x, tempY + image.h2 - amountY) > 0 then
						
						dy = 0
						jumping = false
						y = round( (tempY + image.h2) / Level.TILE_SIZE ) * Level.TILE_SIZE - image.h2
					else
						y = tempY
					endif
				else
					if game.level.getCollisionTile(x - image.w2 + amount, tempY - image.h2 ) > 0 or 
						game.level.getCollisionTile(x + image.w2 - amount, tempY - image.h2) > 0 or
						game.level.getCollisionTile(x, tempY - image.h2 ) > 0 then
						
						dy = 0
						y = round((tempY - image.h2) / Level.TILE_SIZE) * Level.TILE_SIZE + image.h2
						
					else
						y = tempY
					endif
				endif
			endif
		endif
		
		Local border% = 200
		If x-game.scrollX < border Then game.level.scrollHorizontal((x-game.scrollX)-border)
		If x-game.scrollX > WIDTH-border Then game.level.scrollHorizontal((x-game.scrollX)-(WIDTH-border))
	End Method
	
End Class

Function round%(f#)
	Return Floor(f+0.5)
End Function

Class Level
	Const TILE_SIZE% = 16
	Const GRAVITY# = 0.06
	
	Field map:Tile[][]
	Field width%, height%
	Field pixelWidth% = 0
	Field pixelHeight% = 0
	
	Field playerX%, playerY%
	
	' 32 across
	Global level1:=[
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,124,0,0,0,16,124,16,124,16,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
		116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
		115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,115,
		0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]

	Method load:Void()
		width = 32
		height = 16
		
		pixelWidth = width * TILE_SIZE
		pixelHeight = height * TILE_SIZE
		
		map = tileArray(width, height)
		
		For Local x:Int = 0 To width - 1
			For Local y:Int = 0 To height - 1
				map[x][y] = New Tile((level1 [ x + y * width ] ))
			Next
		Next
		
		playerX = 10
		playerY = 200
		
	End Method
	
	Method draw:Void()
		For Local x% = 0 To width - 1
			For Local y% = 0 To height - 1
				If map[x][y].frame > 0
					SetColor map[x][y].red, map[x][y].green, map[x][y].blue
					DrawRect Int(x * TILE_SIZE - game.scrollX), Int(y * TILE_SIZE - game.scrollY), TILE_SIZE, TILE_SIZE
				endif
			Next
		Next
	End Method
	
	Method scrollHorizontal:Void(change#)
		game.scrollX+=change

		If game.scrollX <0 Then
			game.scrollX = 0
		Else
			Local maxX% = pixelWidth - WIDTH
			If game.scrollX > maxX Then game.scrollX = maxX
		EndIf
	End Method
	
	Method getCollisionTile:Int(x:Float, y:Float)
		If x < 0 Or x >= pixelWidth Or y < 0 Or y >= pixelHeight Then Return 0
		
		local xx% = (Floor(x / TILE_SIZE)) 
		local yy% = (Floor(y / TILE_SIZE))
		
		Return map[xx][yy].frame
	End Method
End Class

Function tileArray:Tile[][](x_size:Int, y_size:Int)
	Local map:Tile[x_size][]
	For Local x:Int=0 Until x_size
	   map[x]=New Tile[y_size]
	Next
	Return map
End Function

Class Tile
	Field frame:Int
	Field red%, green%, blue%	
	
	Method New(frame:Int=0)
		self.frame = frame
		red = 255 - frame
		green = 255 - frame
		blue = 255 - frame
	End
End

Class FPSCounter Abstract
	Global fpsCount:Int
	Global startTime:Int
	Global totalFPS:Int

	Function update:Void()
		If Millisecs() - startTime >= 1000
			totalFPS = fpsCount
			fpsCount = 0
			startTime = Millisecs()
		Else
			fpsCount+=1
		EndIf
	End Function

	Function draw:Void(x% = 0, y% = 0, ax# = 0, ay# = 0)
		DrawText("FPS: " + totalFPS, x, y, ax, ay)
	End Function
End Class

Is this method appropriate for my release? Or was it mainly for testing purposes?

I just want to make sure I am okay with leaving it as is.

Also, how was the framerate determined to be 200?

Field frameRate# = 200

Thank you

erebel55

(Posted 2014) [#2]

Should I scrap this and use SetUpdateRate(0) ?

therevills

(Posted 2014) [#3]

FRL and SetUpdateRate is different.

The FRL (Fixed-Rate-Logic) is running the OnUpdate at 200Hz (or tries to) whilst SetUpdateRate(0) will run OnUpdate and OnRender as fast as possible.

I used FRL so that the movement of objects wouldnt got thru walls, but I've changed now to use ray casting to detect collisions.

erebel55

(Posted 2014) [#4]

Okay, thanks therevills. Any chance you have a dumbed down example of how the ray casting works? What method do you now use for timing, just delta timing?

ziggy

(Posted 2014) [#5]

IMHO, delta timing with an minimum and maximum delta factor threshold is usually the easiest approach. Just in case the device is too slow, make the game slower before it drops too many frames and collisions start to fail, and also force the game to be slower if it's getting too quick on the device to prevent rounding errors caused by a too small delta factor.

ImmutableOctet(SKNG)

(Posted 2014) [#6]

I'm not usually one to promote my own modules, but here's my delta-time module.

It's a delta-timing module I wrote a while ago, and it works reasonably well for my uses. Assuming of course that you haven't already looked into another solution.

For the STDCPP target, you'd need this module, but for other targets, it'll just use Mojo.

erebel55

(Posted 2014) [#7]

Is FRL an appropriate alternative to delta timing?

therevills

(Posted 2014) [#8]

Any chance you have a dumbed down example of how the ray casting works? What method do you now use for timing, just delta timing?

Ray casting:

Local pts:Vector2D[]
Local okayToMove:Bool = False
Local tempx = player.x + player.speedX
pts = BresenhamLine(New Vector2D(player.x, player.y), New Vector2D(tempx, player.y))
okayToMove = true
For Local v:Vector2D = EachIn pts
	if CollisionTile(v.x, v.y) <> 0 Then
		okayToMove = False
		player.x = v.x
		Exit
	End
Next

You fire a line from the start positionto the end position, checking each position.

Is FRL an appropriate alternative to delta timing?

No, you should use them together.