## 11. Plenty of Monsters

We will try to make a little game. You would not believe what has happened. Peter has found monsters in the maze. However, do not worry, we will arm him, and he will handle them. We will continue with the Way program from the previous chapter, in which the last method of control is turned on — Controlling by Holding Keys 2. The other possibility is to open the Monsters program, which is prepared as a sample program.

First, we will prepare the monster. In the Global Variables and Functions window, make a copy of the empty square element. Rename it to Monster and draw a monster into it, e.g. like this:

Monsters will be generated randomly. Add the conditional executing of commands element into the main program loop. Into the if valid condition test, insert the is less than comparative function (from the calculations group, comparisons subgroup). The first parameter for comparison will be the random number (0 <= x < 1) function (from the calculations group, functions subgroup). The second parameter will be a numeric constant set to 0.2 (either as the element text or using the digits and decimal point elements). In a while, we will add the monster creation construction.

What will the random function do? The elements texts tell us: "If it is valid that a random number is less than 0.2, create a monster." The random number is a decimal number with a random value between zero and one. 0.2 is one fifth of one. The random number is less than 0.2 in every fifth case. This means that the monster will be generated in one fifth of cases.

To create the monster, we will use Peter’s friend — Lucy. First, we will specify a random place where the monster will be created. Into the condition validity branch, drag the horizontal position and vertical position elements (from the Lucy group, Lucy - extension subgroup). Add the integer part function to both elements (from the calculations group, functions subgroup), as the squares’ coordinates are integers. Add the random number (0 <= x < 1) function to the integer elements. The random number can have a parameter specifying its range. For example, if you add 10, the random number is generated in the range from 0 to 10. We will add the width of sheet element to the random number for the horizontal position, and the height of sheet element for the vertical position (both elements are from the sheet group).

Let us take a closer look at the calculation of the horizontal random position. The referential element in the horizontal direction is the width of sheet . This element returns a number indicating the width of the sheet as a number of steps (squares). In our case, it will be 12, which is the width of sheet that we had set before. This number is passed to the random number (0 <= x < 1) function, which generates a number in the range from zero to the width of sheet (without the border value), that is, a number between 0 and 11.99999999. The random number is passed to the integer part function, which truncates the part of the number behind the decimal point and returns only its integer. This creates a number between 0 and 11, which are the coordinates of the first and last square in the horizontal direction. You may have noticed that the squares are numbered from the bottom left square, starting with zero.

Now we have Lucy on a random position on the sheet. We could lay the monster item onto the sheet now, but first we have to verify that the square is not occupied, e.g. by a wall. If the square is not free, nothing will be performed and no monster will be created. Here is the result; try to run the program:

Now we will improve the routines for controlling Peter’s steps. In the Global Variables and Functions window, use the right mouse button to copy the Cautious Step Forward function. A new function called Cautious Step Forward 2 is created. Rename it to Cautious Step in the Specified Direction.

Double-click the new function to edit it, and look at the bottom left window. It is called Local Variables and Functions. We don’t have to worry about the function of this window; we will only use the input variables element. From the Library of Variables and Functions window, drag a new numeric variable number into this element, and call the variable requested direction.

Switch back into the main program function. In the Controlling by Holding Keys 2 construction, find the first branch (for the Up arrow). Insert the new function called Cautious Step in the Specified Direction here. When you drop the function, you can see that the numeric variable called requested direction is connected to it. It is the one that we have just created. It will pass the requested direction of the step to the function. From the direction setting command, drag the up element to the function parameter. You can discard the remaining commands from the branch (the direction setting and the Cautious Step Forward function). Adjust the branches for the remaining directions in a similar way. This will be the construction for the step upwards:

Now we will prepare the contents of the Cautious Step in the Specified Direction function. Switch into it. First, for testing purposes, try to add the command for setting Peter’s direction, and add the requested direction variable as the parameter. This restores the original functionality of the program, and we can verify that we did not make any mistake. Run the program and test it, it should work as before. If everything is all right, you can delete the direction setting command.

If we used the original control method for shooting, it would be unpleasant that we would not be able to turn to the target without making a step towards it. For this reason, we will improve the control. If Peter is not turned in the requested direction, he will turn first, and only after that, he will go. By pressing the key once, we will turn Peter around, and by holding the key, we will tell him to go. Edit the function accordingly to the following picture.

The function begins by comparing Peter’s actual direction with the requested direction, which is passed as the function parameter. This way, we will check if Peter is already turned to the requested direction.

If Peter is turned in the appropriate direction, he can make a step forward. However, he will do so cautiously. First, he tests if there is a wall in front of him. If there is not, he can make a step. If there is, he will stay on his place, and the wait command will be executed. The main program loop has to last for at least one wait interval, so that new monsters can be generated evenly. One wait interval is performed in the main loop, if no key for movement is pressed. The waiting when a key is pressed is handled in the movement function. The program does not wait after the step command, the step ensures the waiting internally.

If Peter is not turned to the requested direction, he turns, and the program waits for a while. The waiting ensures that Peter does not start to go when a key is pressed shortly.

Run the program and test its control. Pay special attention to testing Peter’s turning on his place and changing directions during walking.

Now we will handle the shooting at the monsters. Once again, we will use Peter’s friend Lucy. Lucy will be the shot. She will surely not mind and will be glad to do this for Peter.

Double-click the Lucy sprite in the Global Variables and Functions window to edit it (note — sprite is a moving animated object). You will see a sheet with 4 x 5 pictures of Lucy. Click the Properties button. A window for setting the sprite properties appears. Change the Phases per Step (0 = Immediately) setting from 8 to 2 (the shot will fly quickly), and change the Moving Phases settings from 4 to 0 (the shot does not have to change its appearance during the flight). Press Enter (or click OK). The pictures of the sprite have changed, so that Lucy is only in one column now.

Drag the first picture of Lucy with the left mouse button, and drop it outside the pictures sheet. The picture disappears; we have deleted it from the sprite. Double-click the freed empty square. The sprite picture editor appears. Draw a picture of the shot — for example, a small gray ball (use the sphere tool and white color):

Keep the original violet color as the background. It is a transparent color, through which the original contents of the square around the shot can be seen. In the color picker of the editor, it is the color in the upper left corner.

Click Previous Edit to switch back to editing the Lucy sprite. Drag the first modified picture with the right mouse button to copy it into the remaining sprite squares. Later you can move the pictures, so that the shots will fly exactly from the barrel of the gun.

Test the modified sprite now. Click the Test button. A window with a green sheet appears, with the sprite of the shot in the middle. Click somewhere into the sheet, and the shot moves to the specified location. You can quit the test by clicking Cancel.

The shot is prepared, and now we have to handle its control. Return to the main program function. Into the main loop, right behind the construction for generating monsters, insert a new conditional executing of commands element, and call it shot from the gun. As shooting will be activated by the spacebar, insert the there is pressed key function with the spacebar element (from the keys group, character keys subgroup) into the if valid condition test.

The whole construction that handles shooting is on the following picture. We set the shot (Lucy) in the starting position, then the shot flies, and when it reaches a target, we turn it off.

In the beginning of the shot’s flight, we set its position and direction accordingly to those of Peter, and then we make it visible. We know the position and direction elements, but what is a visibility element? All sprites (moving objects, including Peter and Lucy) have two basic states — visible and invisible. When in the visible state, the sprite is animated, and moves slowly. If it is invisible, it moves to a new position immediately. Peter becomes a "Super Peter", as quick as lightning.

Lucy’s visibility will be set by the visible command. As the sprite visibility parameter, we usually use a logical constant yes or no ; this way, we switch between the "Slowcoach" and "Superman" modes. The activation of the shot is on the following picture. For the sake of readability, it is in a separate group.

Now we will handle the movement of the shot. Behind the group for preparation of the starting position of the shot, add a command repeating with specified run number cycle and label it shot flight. As a number of repetitions, type 4. This is the maximum distance that the shot can fly.

The flight will be interrupted, if the shot hits a wall. For this reason, in the beginning of the cycle body, add a condition testing if there is a Wall item in front of Lucy. If there is, the execution of the cycle will be interrupted by the break executing command (from the program control group). After we check for the wall, we can add the step element for the shot’s movement.

When the shot moves one step, we will test if it has hit the target. We will use a conditional command that will test, whether the item on Lucy’s position is a Monster. If it is, the monster will be deleted by laying down an empty square item, and the cycle of the shot’s flight will be interrupted. Some time in the future, you can add other elements here, such as a hit counter or a monster’s moan.

The whole construction for the shot’s flight is on the following picture. Add an element for turning off the visibility of Lucy behind it, and you can test the program.

If you want to make further improvements, you can equip Peter with a gun. You can also add a sound of the shot by using the play sound element. From the bank of sounds, drag e.g. [examples]\Weapon\Rifle and Pistol\Pistol sound into the Global Variables and Functions window, and use it in the play sound feature. You can also add a moan of the hit monster — e.g. the [examples]\Human\Shouts\Au 2 sound.