Somewhere in that doUpdate() function, we have to call Application.DoEvents() so the form can be refreshed. If we call it every frame, that will also be wasteful because Application.DoEvents() processes the event messages for form controls (like the Timer as well as for drawing the controls). If we call it every frame, then our game loop will be even more limited than it was with the timer! No, we need to learn just when and where to use this function and that calls for a knowledge of frame-rate timing.

Public Function FrameRate() As Integer
    Static count As Integer = 0
    Static lastTime As Integer = 0
    Static frames As Integer = 0
    REM calculate core frame rate
    Dim ticks As Integer = Environment.TickCount()
    count += 1
    If ticks > lastTime + 1000 Then
        lastTime = ticks
        frames = count
        count = 0
    End If
    Return frames
End Function

Do you recall the Game class from way back in Chapter 5? We will be using the Game class again in this chapter. The Game class is a good home for the FrameRate() function. While we’re at it, let’s add two more helper functions that we need for calculating random numbers (which is good for simulating the rolling of dice—absolutely essential when rolling new RPG characters!).

Private p_random As Random

Public Function Random(ByVal max As Integer)
    Return Random(0, max)
End Function

Public Function Random(ByVal min As Integer, ByVal max As Integer)
    Return p_random.Next(min, max)
End Function

Now that those dependencies are added, let’s take a look at the new doUpdate() function, which is called from within the main While loop that will drive our game. I’ll stick with just the bare minimum for now, leaving out any code specific to one example or another, and just show you a skeleton version of the function.

Private Sub doUpdate()
    Dim frameRate As Integer = game.FrameRate()
    Dim ticks As Integer = Environment.TickCount()
    Static drawLast As Integer = 0
    If ticks > drawLast + 16 Then
        drawLast = ticks
        game.Print(0, 0, "Frame rate " + frameRate.ToString())
        game.Update()
        Application.DoEvents()
    Else
        Threading.Thread.Sleep(1)
    End If
End Sub

This bare minimum version of doUpdate() handles its own timing and is more action packed than it at first appears. First, we need to get the frame rate from the Game class, and this needs to happen before the If statement, because it needs to run as fast as possible. Everything within the If statement block of code is slowed down code for rendering. Anything we need to draw in the game goes inside that If block.

If ticks > drawLast + 16 Then

The If statement will be true once every 16 milliseconds. Where does that value come from? That is approximately 60 frames per second—a desirable goal for a game.

1 second = 1000 ms

delay = 1000 ms / 60 fps

delay = 16.66667 ms

Truncating the decimal part gives our code a few free frames per second, causing the actual frame rate to clock in at around 64 fps, but that depends on the processor—it might be less than 60 on some systems. The point is, we need this uber-vital code in the game loop to keep slow stuff from bottlenecking the whole game! That’s exactly what was happening in Chapter 11’s demos, which had no time-limiting code.

So, we first get the current system timer value in milliseconds with Environment. TickCount(), which will be some large millisecond number like 3828394918. That doesn’t matter. What matters is how many milliseconds transpire from one frame to the next. Keeping track of that tick value in the drawLast variable allows our code to use it for comparison in the next frame. If at least 16 ms have gone by since the last time drawLast was set, then it’s time to draw!

The real frame rate of a game is not the 60 fps draw rate, it’s the rate at which the game is updated every frame. That includes any math and physics calculations, collision detection (which can be very time consuming!), A.I. for enemy movements, and so on. If we tried to do all of these things inside the 60 fps game loop, it would immediately drop to below that desired refresh rate, all the while many frames are going to waste outside the If statement.

Now to address the processor throttling: In Chapter 11, one thread would max out one processor core just to draw the tilemap, which seems silly for such a simple 2D graphic. The problem was not the drawing code but the timer. We’ll correct that now. If 16 ms have not transpired so that it’s time to draw, then we tell the current thread to sleep for 1 ms. This has the effect of allowing the processor core to rest if the game is idling for that short time period. 16 ms is an extremely small amount of time in human terms, but for the computer it’s enough time to read a whole book! The Else statement in the code below kicks in if 16 ms have not yet transpired.

Else
    Threading.Thread.Sleep(1)
End If

It turns out that we need to make some new improvements to the Sprite class introduced back in Chapter 6, “Sprites and Real-Time Animation”. The changes are needed not because of a lack of foresight back then, but because of changing needs as work on Celtic Crusader progresses. Expect future needs and the changes they will require—versatility is important in software development! First, we need to gain access to the animation system in the Sprite class. It was originally designed with a very useful Animate() function, but I want to be able to set the starting frame of animation to a random value for the random trees example, and presently there is no way to specifically set the sprite frame. Here’s a new property to do that:

Public Property CurrentFrame() As Integer
    Get

        Return p_currentFrame
    End Get
    Set(ByVal value As Integer)
        p_currentFrame = value
    End Set
End Property

Next, we need a new Draw() function. Adding a second version of the function will overloadDrawin the class, giving it more features, but we must be careful not to disrupt any existing code in the process. Specifically, I need to be able to draw a copy of a sprite, based on its current animation frame, to any location on the screen, without changing the sprite’s position. That calls for a new Draw() function that accepts screen coordinates. For reference, here is the existing Draw() function:

REM draw sprite frame at current position
Public Sub Draw()
    Dim frame As New Rectangle
    frame.X = (p_currentFrame Mod p_columns) * p_size.Width
    frame.Y = (p_currentFrame  p_columns) * p_size.Height
    frame.Width = p_size.Width
    frame.Height = p_size.Height
    p_game.Device.DrawImage(p_bitmap, Bounds(), frame, GraphicsUnit.Pixel)
End Sub

And here is the new overloaded function:

REM draw sprite at specified position without changing original position
Public Sub Draw(ByVal x As Integer, ByVal y As Integer)
    REM source image
    Dim frame As New Rectangle
    frame.X = (p_currentFrame Mod p_columns) * p_size.Width
    frame.Y = (p_currentFrame  p_columns) * p_size.Height
    frame.Width = p_size.Width
    frame.Height = p_size.Height
    REM target location
    Dim target As New Rectangle(x, y, p_size.Width, p_size.Height)
    REM draw sprite
    p_game.Device.DrawImage(p_bitmap, target, frame, GraphicsUnit.Pixel)
End Sub

Now that we have a new Level class and modified versions of the Game and Sprite classes, we can finally go over a new example involving interactive objects in the game world. In this example, the objects won’t exactly be interactive—yet! The random trees will be visible and will seem to scroll with the tiles. The Random Tree Demo program includes optimizations to the game loop, with the addition of the game level renderer (via the Level class), and a linked list of tree sprites that are scattered randomly around the upper-left corner of the game level (so we don’t have to move very far to see them all—but it is very easy to scatter the trees throughout the entire level). The source image for the tree scenery objects is shown in Figure 12.2. The images used in the demo are each 64 × 64 pixels in size.

Figure 12.2. The tree sprite sheet has 32 unique trees and bushes that can be used for scenery. Courtesy of Reiner Prokein.

Figure 12.3 shows the Random Trees demo program running. Note the frame rate value! As you can see in the source code listing below, the trees are only randomly placed within the first 1000 pixels, in both the horizontal and vertical directions. Feel free to experiment with the code, extending the range of the trees to the entire level if you wish. Just be mindful of the number of objects being added. Although only the visible tree sprites are drawn, the entire list is looked at every frame, which can slow down the program quite a bit if there are too many objects. Why don’t you perform a little experiment? See how many trees you can add before the frame rate drops too low to be playable?

Figure 12.3. Random trees are added to the game world.

Public Class Form1
    Public Structure keyStates
        Public up, down, left, right As Boolean
    End Structure

  Private game As Game
  Private level As Level
  Private keyState As keyStates
  Private gameover As Boolean = False
  Private treeImage As Bitmap
  Private tree As Sprite
  Private trees As List(Of Sprite)
  Private treesVisible As Integer = 0

  Private Sub Form1_Load(ByVal sender As System.Object, _
      ByVal e As System.EventArgs) Handles MyBase.Load
      Me.Text = "Random Tree Demo"
      REM create game object
      game = New Game(Me, 800, 600)
      REM create tilemap
      level = New Level(game, 25, 19, 32)
      level.loadTilemap("tilemap.xml")
      level.loadPalette("palette.bmp", 5)
      REM load trees
      treeImage = game.LoadBitmap("trees64.png")
      trees = New List(Of Sprite)
      For n = 0 To 100
          Dim tree As New Sprite(game)
          tree.Image = treeImage
          tree.Columns = 4
          tree.TotalFrames = 32
          tree.CurrentFrame = game.Random(31)
          tree.Size = New Point(64, 64)
          tree.Position = New PointF(game.Random(1000), game.Random(1000))
          trees.Add(tree)
     Next n
     REM game loop
     While Not gameover
         doUpdate()
     End While
 End Sub

 Private Sub Form1_KeyDown(ByVal sender As Object, _
     ByVal e As System.Windows.Forms.KeyEventArgs) Handles Me.KeyDown
     Select Case (e.KeyCode)

            Case Keys.Up, Keys.W : keyState.up = True
            Case Keys.Down, Keys.S : keyState.down = True
            Case Keys.Left, Keys.A : keyState.left = True
            Case Keys.Right, Keys.D : keyState.right = True
        End Select
    End Sub

    Private Sub Form1_KeyUp(ByVal sender As System.Object, ByVal e As System.
Windows.Forms.KeyEventArgs) Handles MyBase.KeyUp
        Select Case (e.KeyCode)
            Case Keys.Escape : End
            Case Keys.Up, Keys.W : keyState.up = False
            Case Keys.Down, Keys.S : keyState.down = False
            Case Keys.Left, Keys.A : keyState.left = False
            Case Keys.Right, Keys.D : keyState.right = False
        End Select
    End Sub

    Private Sub DrawTrees()
        Dim sx As Integer
        Dim sy As Integer
        treesVisible = 0
        For Each tree As Sprite In trees
            sx = level.ScrollPos.X
            sy = level.ScrollPos.Y
            If tree.X > sx And tree.X < sx + 23 * 32 _
            And tree.Y > sy And tree.Y < sy + 17 * 32 Then
                Dim rx As Integer = Math.Abs(sx - tree.X)
                Dim ry As Integer = Math.Abs(sy - tree.Y)
                tree.Draw(rx, ry)
                treesVisible += 1
            End If
        Next
    End Sub

    Private Sub doUpdate()
        REM respond to user input
        Dim steps As Integer = 8
        Dim pos As PointF = level.ScrollPos
        If keyState.up Then pos.Y -= steps

        If keyState.down Then pos.Y += steps
        If keyState.left Then pos.X -= steps
        If keyState.right Then pos.X += steps
        level.ScrollPos = pos
        REM refresh level renderer
        level.Update()
        REM get the untimed core frame rate
        Dim frameRate As Integer = game.FrameRate()
        REM drawing code should be limited to 60 fps
        Dim ticks As Integer = Environment.TickCount()
        Static drawLast As Integer = 0
        If ticks > drawLast + 16 Then '1000/60 = 16 ms
            drawLast = ticks
            REM draw the tilemap
            level.Draw(0, 0, 800, 600)
            REM draw the trees in view
            drawTrees()
            REM print da stats
            game.Print(0, 0, "Scroll " + level.ScrollPos.ToString())
            game.Print(250, 0, "Frame rate " + frameRate.ToString())
            game.Print(500, 0, "Visible trees " + treesVisible.ToString() + "/
100")
            REM refresh window
            game.Update()
            Application.DoEvents()
        Else
            REM throttle the cpu
            Threading.Thread.Sleep(1)
        End If
    End Sub
End Class