The code for this function will go in the Engine.cpp file we have recently created.

Add the following code and then we can discuss it:

#include "stdafx.h" 
#include "Engine.h" 
 
Engine::Engine() 
{ 
   // Get the screen resolution  
   // and create an SFML window and View 
   Vector2f resolution; 
   resolution.x = VideoMode::getDesktopMode().width; 
   resolution.y = VideoMode::getDesktopMode().height; 
 
   m_Window.create(VideoMode(resolution.x, resolution.y), 
      "Thomas was late", 
      Style::Fullscreen); 
 
   // Initialize the fullscreen view 
   m_MainView.setSize(resolution); 
   m_HudView.reset( 
      FloatRect(0, 0, resolution.x, resolution.y)); 
 
   // Inititialize the split screen Views 
   m_LeftView.setViewport( 
      FloatRect(0.001f, 0.001f, 0.498f, 0.998f)); 
 
   m_RightView.setViewport( 
      FloatRect(0.5f, 0.001f, 0.499f, 0.998f)); 
 
   m_BGLeftView.setViewport( 
      FloatRect(0.001f, 0.001f, 0.498f, 0.998f)); 
 
   m_BGRightView.setViewport( 
      FloatRect(0.5f, 0.001f, 0.499f, 0.998f)); 
    
   m_BackgroundTexture = TextureHolder::GetTexture( 
      "graphics/background.png"); 
 
   // Associate the sprite with the texture 
   m_BackgroundSprite.setTexture(m_BackgroundTexture); 
 
} 

Much of the code we have seen before. For example, there are the usual lines of code to get the screen resolution as well as to create a RenderWindow. At the end of the previous code we use the now familiar code to load a texture and assign it to a Sprite. In this case we are loading the background.png texture and assigning it to m_BackgroundSprite.

It is the code in between, the four calls to the setViewport function, that needs some explanation. The setViewport function assigns a portion of the screen to an SFML View object. It doesn't work using pixel coordinates, however. It works using a ratio. Where "1" is the entire screen (width or height), the first two values in each call to setViewport are the starting position (horizontally, then vertically) and the last two are the ending position.

Notice that the m_LeftView and m_BGLeftView are placed in exactly the same place, starting at virtually the far left (0.001) of the screen, and ending two 1,000ths from the center (0.498).

The m_RightView and m_BGRightView are also in exactly the same position, starting just left of the previous two View objects (0.5) and extending to almost the far right-hand side (0.998) of the screen.

Furthermore, all the views leave a tiny sliver of a gap at the top and bottom of the screen. When we draw these View objects on the screen on top of a white background, it will have the effect of splitting the screen with a thin white line between the two sides of the screen, as well as a thin white border around the edges.

I have tried to represent this effect in the following diagram:

The best way to understand it is to finish this chapter, run the code, and see it in action.

The code for this function will go in the Engine.cpp file we have recently created.

Add the following code immediately after the previous constructor code:

void Engine::run() 
{ 
   // Timing    
   Clock clock; 
 
   while (m_Window.isOpen()) 
   { 
      Time dt = clock.restart(); 
      // Update the total game time 
      m_GameTimeTotal += dt; 
      // Make a decimal fraction from the delta time 
      float dtAsSeconds = dt.asSeconds(); 
 
      // Call each part of the game loop in turn 
      input(); 
      update(dtAsSeconds); 
      draw(); 
   } 
} 

The run function is the center of our engine—it initiates all the other parts. First, we declare a Clock object. Next, we have the familiar while(window.isOpen()) loop, which creates the game loop. Inside this while loop, we do the following:

All of this should look very familiar. What is new is that it is wrapped in the run function.

As explained previously, the code for this function will go in its own file because it is more extensive than the constructor or the run function. We will use #include "Engine.h" and prefix the function signature with Engine:: to make sure the compiler is aware of our intentions.

Right-click Source Files in the Solution Explorer and select Add | New Item.... In the Add New Item window, highlight (by left-clicking) C++ File ( .cpp ) and then in the Name field, type Input.cpp. Finally, click the Add button. We are now ready to code the input function.

Add the following code:

void Engine::input() 
{ 
   Event event; 
   while (m_Window.pollEvent(event)) 
   { 
      if (event.type == Event::KeyPressed) 
      {         
         // Handle the player quitting 
         if (Keyboard::isKeyPressed(Keyboard::Escape)) 
         { 
            m_Window.close(); 
         } 
 
         // Handle the player starting the game 
         if (Keyboard::isKeyPressed(Keyboard::Return)) 
         { 
            m_Playing = true; 
         } 
 
         // Switch between Thomas and Bob 
         if (Keyboard::isKeyPressed(Keyboard::Q)) 
         { 
            m_Character1 = !m_Character1; 
         } 
 
         // Switch between full and split screen 
         if (Keyboard::isKeyPressed(Keyboard::E)) 
         { 
            m_SplitScreen = !m_SplitScreen; 
         } 
      } 
   }   
} 

As with both of the previous projects, we check the RenderWindow event queue each frame. Also, as we have done before, we detect specific keyboard keys using if (Keyboard::isKeyPressed(Keyboard::E)). What is most relevant in the code we just added is what the keys actually do:

The majority of this keyboard functionality will be fully working by the end of the chapter. We are getting close to being able to run our game engine. Next, let's code the update function.

As explained previously, the code for this function will go in its own file because it is more extensive than the constructor or the run function. We will use #include "Engine.h" and prefix the function signature with Engine:: to make sure the compiler is aware of our intentions.

Right-click Source Files in the Solution Explorer and select Add | New Item.... In the Add New Item window, highlight (by left-clicking) C++ File ( .cpp ) and then in the Name field, type Update.cpp. Finally, click the Add button. We are now ready to write some code for the update function.

Add the following code to the Update.cpp file to implement the update function:

#include "stdafx.h" 
#include "Engine.h" 
#include <SFML/Graphics.hpp> 
#include <sstream> 
 
using namespace sf; 
 
void Engine::update(float dtAsSeconds) 
{ 
 
   if (m_Playing) 
   { 
      // Count down the time the player has left 
      m_TimeRemaining -= dtAsSeconds; 
 
      // Have Thomas and Bob run out of time? 
      if (m_TimeRemaining <= 0) 
      { 
         m_NewLevelRequired = true; 
      } 
 
   }// End if playing 
       
} 

First of all, notice that the update function receives the time the previous frame took as a parameter. This, of course, will be essential for the update function to fulfill its role.

The preceding code doesn't achieve anything visible at this stage. It does put in the structure that we will require for future chapters. It subtracts the time the previous frame took from m_TimeRemaining. It checks whether time has run out, and if it has, it sets m_NewLevelRequired to true. All this code is wrapped in an if statement that only executes when m_Playing is true. The reason for this is because, as with the previous projects, we don't want time advancing and objects updating when the game has not started.

We will build on this code as the project continues.

As explained previously, the code for this function will go in its own file, because it is more extensive than the constructor or the run function. We will use #include "Engine.h" and prefix the function signature with Engine:: to make sure the compiler is aware of our intentions.

Right-click Source Files in the Solution Explorer and select Add | New Item.... In the Add New Item window, highlight (by left-clicking) C++ File ( .cpp ) and then in the Name field, type Draw.cpp. Finally, click the Add button. We are now ready to add some code to the draw function.

Add the following code to the Draw.cpp file to implement the draw function:

#include "stdafx.h" 
#include "Engine.h" 
 
void Engine::draw() 
{ 
   // Rub out the last frame 
   m_Window.clear(Color::White); 
 
   if (!m_SplitScreen) 
   { 
      // Switch to background view 
      m_Window.setView(m_BGMainView); 
      // Draw the background 
      m_Window.draw(m_BackgroundSprite); 
      // Switch to m_MainView 
      m_Window.setView(m_MainView);     
   } 
   else 
   { 
      // Split screen view is active 
 
      // First draw Thomas' side of the screen 
 
      // Switch to background view 
      m_Window.setView(m_BGLeftView); 
      // Draw the background 
      m_Window.draw(m_BackgroundSprite); 
      // Switch to m_LeftView 
      m_Window.setView(m_LeftView); 
       
      // Now draw Bob's side of the screen 
 
      // Switch to background view 
      m_Window.setView(m_BGRightView); 
      // Draw the background 
      m_Window.draw(m_BackgroundSprite); 
      // Switch to m_RightView 
      m_Window.setView(m_RightView); 
             
   } 
 
   // Draw the HUD 
   // Switch to m_HudView 
   m_Window.setView(m_HudView); 
    
    
   // Show everything we have just drawn 
   m_Window.display(); 
} 

In the preceding code, there is nothing we haven't seen before. The code starts, as usual, by clearing the screen. In this project, we clear the screen with white. What is new is the way the different drawing options are separated by a condition, which checks whether the screen is currently split or full:

if (!m_SplitScreen) 
{ 
} 
else 
{ 
} 

If the screen is not split, we draw the background sprite in the background View (m_BGView) and then switch to the main fullscreen View (m_MainView). Note that at the moment, we don't actually do any drawing in m_MainView.

If, on the other hand, the screen is split, the code in the else block is executed and we draw m_BGLeftView with the background sprite on the left of the screen, followed by switching to m_LeftView.

Then, still in the else block, we draw m_BGRightView with the background sprite on the right of the screen, followed by switching to m_RightView.

Outside of the if…else structure just described, we switch to  m_HUDView. At this stage, we are not actually drawing anything in m_HUDView.

As with the other two (input, update) of the three most significant functions, we will be back here at the draw function often. We will add new elements of our game that need to be drawn. You will notice that each time we do, we will add code into each of the main, left, and right sections.

Let's quickly recap the Engine class and then we can fire it up.