Chapter 1

Figure 9.2
On the right, you can see the familiar GUI application classes – application, document, app
UI, and app view.
On the left, you can see the classes that represent the application's persistent data: the
controller and engine. The engine has two fleet objects: iMyFleet stores the actual layout
of the fleet of ships the player is trying to sink; iOppFleet stores what the player has
discovered so far about the fleet (by making shots at it). Each fleet object has a number of
ships in it, represented by TShip, a class not shown on the diagram.
Note
'Engine' is a synonym for 'model' in the model-view-controller (MVC) sense.
Inside Symbian, these words are used interchangeably.
The application's view displays the target fleet, and handles input (the user's shots). The
MGameViewCmdHandler interface class is used to communicate from the view to the
controller.
Note that the document class owns only the objects that hold the application data (controller,
engine, fleets), while the app UI owns only the object that displays it (view). This separation
will be essential when we come to add persistence to the program.
9.2.2 The Engine
Solo Ships is a simple, one-player game in which the user plays against a randomly
generated layout of battleships. However, the application has been designed with flexibility in
mind so it can be expanded to a full, multiplayer game in future: Solo Ships and the full
Battleships game have the same engine code.
As mentioned earlier, the engine has two fleet objects:
� One fleet object (termed the 'opponent' fleet) is initialized to be entirely empty at the
beginning of the game. This is the fleet displayed in the application's view, and it
represents what the player has discovered so far about the target fleet that they are
trying to sink.
� The real information about the target fleet (termed 'my fleet') is contained in the other
fleet object. This is initialized randomly at the beginning of the game.
Each time the user shoots at a square, the controller asks the 'my fleet' object what is at that
square, and updates the 'opponent fleet' object appropriately. This is then reflected in the
view. So, during the game, the player gets to know more and more about the opponent fleet
until – when he's sunk it entirely – he knows everything about it.