Casual Mechanics

On habrahabr, attempts are periodically made to describe the game-making process from various sides - from the embodiment of 3D graphics to the creation of network protocols. These topics are certainly important, but rather narrow. In this article I will try to use a broader approach - I will consider the principle of creating a game engine for the so-called casual games. The described mechanics is quite suitable for creating all sorts of pacman, arkanoid, platformer, etc. The description of the process will be based on the example of a primitive scrolldown shooter (from nostalgic feelings for Zybex and Xevious ) - we fly across the field, knock meteorites. Tool - Qt.

Immediately make a reservation that there are no beauties and completeness in the code. Classes are primitive and repeat code, functions are not optimal, graphicsugly no, but it puffs and tosses and turns. This is the basis from which you can work further. Experienced programmers - flipping through a cup of something hot, beginning or pouring into the topic may give food for thought. Getting started.

Application cycle

In order to choose the right way to organize the program, you need to decide on the participants in the main cycle. In any casual (and most non-casual) game there are at least three of them:

• Gameplay Clock
• Continuity simulator
• Scene rendering

Other points are also possible - animation manager, artificial intelligence, etc. For example, these three will be enough for us.

What kind of participants are they?

The gameplay clock is tied to a timer ... um ... the gameplay clock. It controls the movement of objects on the playing field. Its main purpose is to ensure the integrity of the gameplay and its identity . This is very important - not only so that the speed of the game does not depend on the performance of the computer, but also to ensure synchronization when playing on the network.

Continuity simulator- These are auxiliary functions, the main purpose of which is to ensure that something important does not happen between calls to the game generator. For example, consider such a game moment:


Two consecutive calls of the game generator clock are shown on the left and right. Suppose that the speed of the yellow circle = 3. The distance between the circle and the rectangle, as can be seen from the figure, = 2. It turns out that the circle and the rectangle will not collide if they are not helped. This is what the continuity simulator provides.

Scene rendering - everything seems to be clear here. It is a separate item, since:

• should not depend on the speed of the gameplay;
• should ensure smoothness of the image (at the speed of the object = 10 points on the screen and the frequency of the game = 30, jerks of a moving object will be visible if the frames are rendered only at the moment the game generator is called)

Possible ways to organize loops

Immediately it occurred to me to create a separate stream for each of the participants. However, this approach is not optimal, since:

• does not provide default synchronization between the participants in the loop. Suddenly you have to sacrifice rendering and animation in order to maintain the synchronism of network battles?
• significantly complicates the development and as a result increases the number of errors. Different threads = different resources, synchronization and sharing issues, and other delights of multithreaded programs.

Therefore, we will do the threads, but in a slightly different way - a separate thread for processing messages from the OS (rendering, keyboard polling), and a separate thread for the game process, in which all three participants are called.
With the rendering and polling of the keyboard, everything is clear - it's just a stream of the main form of the application. We will deal with the flow of gameplay.

Game Stream

The structure of the stream is shown in the figure:


Now a little code with explanations.
First, set the frequencies. Roughly speaking, how many ms should pass between calls to processing logic, rendering:

Copy Source  | Copy HTML

1. // Clock: FREQ - logic, FPS - rendering
2. const int FREQ = 1000/40; // 1000 / FPS
3. const int MAX_FPS = 1000/180;

And here is the main loop code - with a call to all participants, time checks, etc.

Copy Source  | Copy HTML

1. while (true)
2. {
3.     qint64 time_cur_tick = QDateTime :: currentMSecsSinceEpoch ();
4.     int numLoops = 0;
5.  
6.     bool ft = true;
7.     while (time_prev_tick <time_cur_tick && numLoops <MAX_LOOPS)
8.     {
9.         // Call Logic
10.         w-> UpdateLogic (1 / FREQ);
11.         numLoops ++;
12.  
13.         if (ft)
14.         {
15.             ft = false;
16.             last_freq = time_cur_tick;
17.         }
18.         time_prev_tick + = FREQ;
19.  
20.         // Update time_cur_tick for more accurate timing
21.         time_cur_tick = QDateTime :: currentMSecsSinceEpoch ();
22.     }
23.  
24.     time_tmp = QDateTime :: currentMSecsSinceEpoch ();
25.     w-> SimulateConsistLogic ((float) (time_tmp - last_freq) / FREQ);
26.  
27.     time_tmp = QDateTime :: currentMSecsSinceEpoch ();
28.     if (time_tmp - time_lastrender> = MAX_FPS &&
             w-> paint_mx.tryLock ())
29.     {
30.         time_lastrender = time_tmp;
31.         float freq_bit = 0;
32.         if (time_tmp! = last_freq)
33.             freq_bit = (float) (time_tmp - last_freq) / FREQ;
34.  
35.         emit signalGUI (freq_bit);
36.         w-> paint_mx.unlock ();
37.     }
38. }

(note - if you look at the source code, everything is a bit more complicated there. Frames are being counted per second, information is displayed, etc.)

Surely the question arose - why do the rendering and continuity simulator functions need to know the time that has passed since the last update of the game logic? Everything is simple - in order to calculate the instantaneous state of the scene, and correctly process it and display it on the screen. To save resources, calling the continuity simulator can also transfer the time of its last call.

How does it all work

In our example, there are three kinds of objects:

• player ship
• bullets
• meteorites

The corresponding classes are made for them (CShip, CBullet, CMeteorite). For bullets and meteorites, QVector storage containers are specified.
To process user input, an array of “directions of movement” was created and the keyReleaseEvent and keyPressEvent functions were redefined:
keyReleaseEvent checks to see if there is a released key in the array of pressed keys and deletes it if any.
keyPressEvent accordingly puts the pressed key into the array of pressed keys (if it is not there). Processing of this array occurs in the function of the clock generator of the game process. There are moving objects of the game, the calculation of inertia during the movement of the ship, creating meteorites:

Copy Source  | Copy HTML

1. void MainWindow :: UpdateLogic (float ftime)
2. {
3.     float speed = 2;
4.     for (int i = 0; i <m_dir.size (); i ++)
5.     {
6.         if (m_dir [i] == MainWindow :: UP)
7.             actor1.adjustDirection (QVector2D (0, -speed));
8.         if (m_dir [i] == MainWindow :: DOWN)
9.             actor1.adjustDirection (QVector2D (0, speed));
10.         if (m_dir [i] == MainWindow :: LEFT)
11.             actor1.adjustDirection (QVector2D (-speed, 0));
12.         if (m_dir [i] == MainWindow :: RIGHT)
13.             actor1.adjustDirection (QVector2D (speed, 0));
14.  
15.         if (m_dir [i] == MainWindow :: SPACE &&
                 m_allowbullet == 0)
16.         {
17.             m_bullets.push_back (CBullet (actor1.getX (), actor1.getY () - 1, QVector2D (0, -15)));
18.             qDebug (QString ("Added bullet. Pos% 1"). arg (m_bullets.size () - 1) .toAscii ());
19.             m_allowbullet = 5;
20.             fired ++;
21.         }
22.     }
23.     actor1.stepDirection ();
24.     bool dir_touched = false;
25.     for (int i = 0; i <m_dir.size (); i ++)
26.     {
27.         if (m_dir [i]! = MainWindow :: SPACE)
28.         {
29.             dir_touched = true;
30.             break;
31.         }
32.     }
33.  
34.     if (! dir_touched)
35.     {
36.         m_allowmove = 0;
37.         float inertia = 0.5;
38.         if (actor1.getSpeed ​​() <0.5)
39.             inertia = 1;
40.         actor1.adjustSpeed ​​(inertia);
41.     }
42.  
43.  
44.     for (int i = 0; i <m_bullets.size (); i ++)
45.         m_bullets [i] .stepDirection ();
46.  
47.     for (int x = 0; x <m_enemies1.size (); x ++)
48.         m_enemies1 [x] .stepDirection ();
49.  
50.     CheckGameRules ();
51.     if (m_enemies1.size () <max_enemies)
52.     {
53.         CMeteorite meteo (mrand (field_ident + CMeteorite :: meteo_size,
                                     field_ident + field_w - CMeteorite :: meteo_size),
54.                           -mrand (0, 20),
55.                       QVector2D (0, 1));
56.         while (true)
57.         {
58.             int i = 0;
59.             while (i <m_enemies1.size ())
60.             {
61.                 if (meteo.getBoundsT (). intersects (m_enemies1 [i] .getBoundsT ()))
62.                     break;
63.  
64.                 i ++;
65.             }
66.  
67.             if (i == m_enemies1.size ())
68.                 break;
69.  
70.             meteo = CMeteorite (mrand (1, 100), -mrand (0, 20),
71.                                   QVector2D (0, 1));
72.  
73.         }
74.         m_enemies1.push_back (meteo);
75.     }
76.     UpdateBullet ();
77. }

The CheckGameRules function checks the game rules - who crashed into someone, who went beyond what, and so on. By the way, in 2D this is all very conveniently done by the functions of the QPolygon, QRect classes and others like them.

Copy Source  | Copy HTML

1. void MainWindow :: CheckGameRules (const float ftime)
2. {
3.     QRect field_rect (field_ident, field_ident,
                         field_w,
                         field_h);
4.  
5.     for (int i = 0; i <m_bullets.size (); i ++)
6.     {
7.         CBullet blt = m_bullets [i];
8.         float tx = 0, ty = 0;
9.         blt.getTickCoords (ftime, tx, ty);
10.  
11.         blt.setX (tx);
12.         blt.setY (ty);
13.  
14.         if (! field_rect.contains (m_bullets [i] .getX (), m_bullets [i] .getY ()))
15.         {
16.             m_bullets.remove (i--);
17.         }
18.         else
19.         {
20.             for (int j = 0; j <m_enemies1.size (); j ++)
21.             {
22.                 CMeteorite enm = m_enemies1 [j];
23.                 float etx = 0, ety = 0;
24.                 enm.getTickCoords (ftime, etx, ety);
25.                 enm.setX (etx);
26.                 enm.setY (ety);
27.  
28.                 if (blt.checkCollision (enm.getBodyT ()))
29.                 {
30.                     m_enemies1.remove (j--);
31.                     m_bullets.remove (i--);
32.                     score ++;
33.                     break;
34.                 }
35.             } // for
36.         }
37.     }
38.  
39.     for (int j = 0; j <m_enemies1.size (); j ++)
40.     {
41.  
42.         CMeteorite enm = m_enemies1 [j];
43.         if (! field_rect.contains (enm.getBoundsT ()) &&
44.              field_rect.bottomRight (). y () <enm.getBoundsT (). topLeft (). y ())
45.         {
46.             m_enemies1.remove (j--);
47.         }
48.  
49.         if (actor1.checkCollision (enm.getBodyT ()))
50.         {
51.             m_enemies1.remove (j--);
52.             hits ++;
53.         }
54.     }
55.  
56.  
57.     if (! field_rect.contains (actor1.getBoundsT (), true))
58.     {
59.         while (field_rect.x ()> = actor1.getBoundsT (). left ())
60.             actor1.setX (actor1.getX () + 1);
61.  
62.         while (field_rect.x () * 2 + field_rect.width () <= actor1.getBoundsT (). x () + actor1.getBoundsT (). width ())
63.             actor1.setX (actor1.getX () - 1);
64.  
65.         while (field_rect.top ()> = actor1.getBoundsT (). top ())
66.             actor1.setY (actor1.getY () + 1);
67.  
68.         while (field_rect.y () * 2 + field_rect.height () <= actor1.getBoundsT (). y () + actor1.getBoundsT (). height ())
69.             actor1.setY (actor1.getY () - 1);
70.  
71.         actor1.stop ();
72.  
73.     }
74. }

Accordingly, the call of the simulator of continuity is simple to disgrace. With just a small step, we check the game logic:

Copy Source  | Copy HTML

1. void MainWindow :: SimulateConsistLogic (float ftime)
2. {
3.     for (float bt = 0; bt <ftime; bt = bt + 0.1)
4.     {
5.         CheckGameRules (bt);
6.     }
7. }

Rendering draws the playing field and calls Draw () of all objects with the parameter of the current indentation from the last call of the game generator clock. Plus output of service information:

Copy Source  | Copy HTML

1. void MainWindow :: Render ()
2. {
3.     QPainter qpainter (this);
4.  
5.     const int bgw = 2;
6.     qpainter.setPen (QPen (Qt :: black, bgw));
7.     qpainter.setBrush (QBrush (Qt :: darkGray));
8.     qpainter.drawRect (field_ident, field_ident,
                          field_w + field_ident,
                          field_h + field_ident);
9.  
10.  
11.     for (int i = 0; i <m_bullets.size (); i ++)
12.     {
13.         CBullet blt = m_bullets [i];
14.         blt.Draw (qpainter, freq_bit);
15.     }
16.  
17.     for (int i = 0; i <m_enemies1.size (); i ++)
18.     {
19.         CMeteorite enm = m_enemies1 [i];
20.         enm.Draw (qpainter, freq_bit);
21.     }
22.  
23.     actor1.Draw (qpainter, freq_bit);
24.  
25.     QPalette pal;
26.     qpainter.setBrush (pal.brush (QPalette :: Window));
27.     qpainter.setPen (QPen (pal.color (QPalette :: Window), 1));
28.     qpainter.drawRect (field_ident - bgw / 2, 0,
                           field_w + field_ident + bgw / 2,
                           field_ident - bgw);
29.  
30.     qpainter.setPen (QPen (Qt :: black, bgw));
31.     qpainter.setBrush (QBrush (Qt :: darkGray, Qt :: NoBrush));
32.     qpainter.drawRect (field_ident, field_ident,
                           field_w + field_ident,
                           field_h + field_ident);
33.  
34.     ui-> label_freq-> setText (QString ("% 1"). arg (freq) .toAscii ());
35.     ui-> label_fps-> setText (QString ("% 1"). arg (fps) .toAscii ());
36.     ui-> label_speed-> setText (QString ("% 1"). arg (actor1.getSpeed ​​()) .toAscii ());
37.  
38.     ui-> label_score-> setText (QString ("% 1"). arg (score) .toAscii ());
39.     ui-> label_fired-> setText (QString ("% 1"). arg (fired) .toAscii ());
40.     ui-> label_hits-> setText (QString ("% 1"). arg (hits) .toAscii ());
41.  
42. }

Actually, the rest is trivial programming. The application skeleton is disassembled, and implementation details can be found in the attached source code. As a result - the appearance of what I did:

Sources here . We fly with arrows, shoot with a space.
Sources on github .