Building Multiple Blocks with a for Loop

To understand how a for loop works, use the Python Shell to try one out by following these steps:

1. Click the Python Shell window, just to the right of the last >>> prompt.
2. Type the following and press the Enter key on the keyboard:

   for a in range(10):

   Python won’t do anything yet because it is expecting the program statements that belong to the loop (these are often called the loop body).

3. The Python Shell automatically indents the next line for you by one level, so that Python knows that your print() statement belongs to the for loop. Now type this print() statement:

   print(a)

4. Press the Enter key twice. Your first press marks the end of the print() statement; your second tells the Python Shell that you have finished the loop.

You should now see the numbers 0 to 9 printed on the Python Shell screen.

Building a Huge Tower with a for Loop

How would you like to build an enormous tower out of blocks inside the Minecraft world? Now that you know all about for loops, you can. Just follow these steps:

1. Start writing a new program by choosing File ⇒ New File from the menu. Choose File ⇒ Save As from the menu, and name it tower.py.
2. As usual, import the modules you need:

   import mcpi.minecraft as minecraft
import mcpi.block as block

3. Connect to the Minecraft game:

   mc = minecraft.Minecraft.create()

4. If you build your tower where your player is standing it is easier to find, so your first job is to identify the position of your player by typing

   pos = mc.player.getTilePos()

5. Your tower is going to be 50 blocks high, so start building it with a for loop that counts 50 times. Don’t forget the colon (:) at the end of the line:

   for a in range(50):

6. The next line is indented because it belongs to the body of the for loop. The y coordinate controls height within the Minecraft world, so add the loop control variable a onto the player’s y position. This tells the program to build at an increasing height in the Minecraft world each time round the loop:

   mc.setBlock(pos.x+3, pos.y+a, pos.z, block.STONE.id)

7. Save the program and run it. Has it worked? Your for loop should have created a massive tower in front of your player, similar to the one in Figure 3-3. Start counting—is it 50 blocks high?

Using setBlocks to Build Even Faster

All the blocks in the Minecraft world have a block identity (id) number, and this includes the blank spaces that you see in front of you, called block.AIR.id. So, if you make sure every block in a large area is set to block.AIR.id, it clears a nice space ready for building other objects. The id number (which is the block type number discussed earlier) is listed in Appendix B for the most common blocks you use. For example, block.AIR.id is 0 and block.STONE.id is 1. Remember, the empty space you see in the Minecraft world is really just a block with a block id of block.AIR.id—it is a 1 metre cube space filled with air!

The Minecraft programming interface has a setBlocks() statement that you can use to give all the blocks inside a three-dimensional (3D) rectangular space the same block id. Because this is a single request to the Minecraft game, Minecraft can optimise how it does this work, meaning it runs much quicker than if you used a setBlock() inside a for loop like you did with the tower.

Because setBlocks() works on a 3D area, it needs two sets of coordinates—the coordinates of one corner of the 3D rectangle, and the coordinates of the opposite corner. Because each 3D coordinate has three numbers, you need six numbers to completely describe a 3D space to Minecraft.

You are now going to write a useful little utility program that you can use any time you want to clear a bit of space in front of you to do some building:

1. Start a new program by choosing File ⇒ New File from the menu.
2. Save the program using File ⇒ Save As and choose the name clearSpace.py.
3. Import the modules that you need:

   import mcpi.minecraft as minecraft
import mcpi.block as block

4. Connect to the Minecraft game:

   mc = minecraft.Minecraft.create()

5. You want to clear space in front of the player, and you use relative coordinates to do this. First get the player’s position:

   pos = mc.player.getTilePos()

6. Now clear a space that is 50 by 50 by 50 blocks. The bottom-left corner of your space is the position of your player, and the top-right corner will be 50 blocks away in the x, y and z dimensions:

   mc.setBlocks(pos.x, pos.y, pos.z, pos.x+50, pos.y+50, ↩
  pos.z+50, block.AIR.id)

7. Save your program.

The fantastic thing about the program you’ve just created is that it allows you to walk to any location inside Minecraft and clear a 50 by 50 by 50 area any time you like; just run the program by choosing Run ⇒ Run Module from the menu, and the trees and mountains and everything nearby magically vanish before your eyes!

Move around the Minecraft world and re-run your program to clear lots of space in front of your player.

Reading Input from the Keyboard

Another useful thing you can do to your clearSpace.py program is to make it easy to change the size of the space that is cleared. That way, if you are only going to build a small structure, you can clear a small space but if you know you are going to build lots of big structures, you can clear a huge space first.

To do this, you use a new Python statement called input() to read a number from the keyboard first. You can then go to any part of the Minecraft world, run your program and simply type in a number representing the size of the space you want to clear; your program clears all that space for you. This means you don’t have to keep modifying your program every time you want to clear a different size of area in the Minecraft world.

Now that you understand what input() does, it’s time to add it to your program. To do this, you have to make only two small modifications to your clearSpace.py program. Follow these steps:

1. Use input() to ask the user to type a number that represents the size of the space to clear, and store that number inside a variable called size. Just like in Adventure 2, where you used str() to convert something to a string, here you use int() to convert the string from input() into a number that you can perform calculations with. Try this line without the int() to see what happens! Type only the new lines that are marked in bold:

   pos = mc.player.getTilePos()
size = int(input("size of area to clear? "))

2. Modify the setBlocks() line so that instead of using the number 50, it uses your new variable size:

   mc.setBlocks(pos.x, pos.y, pos.z,
pos.x + size, pos.y + size, pos.z + size,
block.AIR.id)

3. Save your program and run it by choosing Run ⇒ Run Module from the menu.

Now move to somewhere in the Minecraft world where there are lots of trees or mountains. Type a number into the Python Shell Window when prompted—perhaps choose 100 or something like that—and press the Enter key on the keyboard. All the trees and mountains near your player should magically disappear and, as in Figure 3-4, you will have a nice space to build other structures!

Keep this little utility program, as it will be useful later when you need to clear a bit of space in the Minecraft world.

Using Python Functions

One of the things you might want to do later is build a whole town with houses of many different designs. The program for a whole town could become quite big and complex, but fortunately there is feature inside the Python programming language that helps you package up that complexity into little chunks of reusable program code. It is called a function.

Before you change your working buildHouse.py program to use a function for the house, try out some functions at the Python Shell to make sure you understand the idea:

1. Click the Python Shell window to bring it to the front.
2. Type the following into the Shell window, which defines a new function called myname:

   def myname():

   The def means ‘define a new function and here is its name'. Just like earlier with the while, if and for statements, you must put a colon (:) at the end of the line so that Python knows to expect you to provide other program statements as part of the body of this function.

3. The Python Shell automatically indents the next line for you, so that Python knows they are part of the function. Type a few lines of print statements that print your name and information about yourself. Don’t be surprised that nothing happens as you type each line; that is correct. Be patient, all will become clear in a moment!

   print("my name is David")
print("I am a computer programmer")
print("I love Minecraft programming")

4. Press the Enter key on the keyboard twice, and the Python Shell recognises that you have finished typing in indented statements.
5. Ask the Python Shell to run this function by typing its name with brackets after it:

   myname()

6. Try typing myname() a few more times to see what happens.

At first it might seem a little strange that you typed instructions into the Python Shell but nothing happened. Normally when you type at the Python Shell, things happen as soon as you press the Enter key, so why didn’t it work this time? This time, you did something different, however: You “defined” a new function called myname and asked Python to remember the three print statements as belonging to that function. Python has stored those print statements in the computer memory, rather than running them straight away. Now, whenever you type myname() it runs those stored statements, and you get your three lines of text printed on the screen.

Let’s put this to good use by defining a function that draws your house. Then, whenever you want a house made from cobblestone, all you have to do is type house(), and it is built automatically for you!

1. So that you don’t break your already working buildHouse.py, choose File ⇒ Save As from the Editor menu, and call the new file buildHouse2.py.
2. At the top of the program after the import statements, define a new function called house:

   def house():

3. Move the midx, midy and all of your setBlocks() statements so that they are indented under the def house(): line. Here is what your program should now look like. Be careful to get the indents correct:

   import mcpi.minecraft as minecraft
import mcpi.block as block
mc = minecraft.Minecraft.create()
SIZE = 20
def house():
midx = x + SIZE/2
midy = y + SIZE/2
mc.setBlocks(x, y, z, x+SIZE, y+SIZE, z+SIZE, ↩
block.COBBLESTONE.id)
mc.setBlocks(x+1, y+1, z+1, x+SIZE-1, y+SIZE-1, ↩
z+SIZE-1, block.AIR.id)
mc.setBlocks(x+3, y+SIZE-3, z, midx-3, midy+3, z, ↩
block.GLASS.id)
mc.setBlocks(midx+3, y+SIZE-3, z, x+SIZE-3, midy-3, z, ↩
block.GLASS.id)
mc.setBlocks(x, y+SIZE, z, x+SIZE, y+SIZE, z+SIZE, ↩
block.SLATE.id)
mc.setBlocks(x+1, y+1, z+1, x+SIZE-1, y+1, z+SIZE-1, ↩
block.WOOL.id, 7)
pos = mc.player.getTilePos()
x = pos.x
y = pos.y
z = pos.z
house()

4. Notice how, in the last statement of your program, you have just put the name house(). This line runs the code that is now stored in the computer’s memory, which was set up by the def house(): statement.
5. Save your program, move to a new location and run your program. You should see a house get built in front of you.

Building a Street of Houses with a for Loop

You are now ready to put together all the things you have learned in this chapter and build a huge street of houses. If you were building all of these houses manually by choosing items from the inventory, it might take you hours to build them, and you might make mistakes in building them or make some of them slightly smaller or larger by accident. By automating the building of houses and other structures with Minecraft programming, you can speed things up and make sure that they are perfectly built to a very precise size!

To build lots of houses, you need to add a for loop to your program as follows:

1. So that you don’t break your existing buildHouse2.py program, use File ⇒ Save As from the menu and save a new file called buildStreet.py.
2. At the end of the program, add a for loop above the final house()along with a line that changes the x position where the house is built. Each house is built SIZE blocks away from the previous house. The new lines are marked in bold:

   for h in range(5):
house()
x = x + SIZE

Save your program, then move to a place in the Minecraft world where there is a bit of space, and run the program. As shown in Figure 3-7, you should get a huge street of five houses as far as the eye can see! Walk your player into each of the houses and make sure that they have been built properly.

Generating Random Numbers

Computers are very precise machines. In many aspects of everyday life, we all rely on computers to be predictable and to do the same thing every time a program is run. When you pay £10 into your bank account, you want to make sure that exactly £10 makes it into the part of the computer’s memory that holds your balance, every time, without fail. So the concept of randomness might seem quite unusual to such a precise system.

However, one area where randomness is really important is in game design. If games did everything exactly the same every time, they would be too easy to play—not fun or challenging at all. Almost every computer game you play has some kind of randomness in it to make things slightly different each time and hold your interest.

Fortunately for your Python programming, the Python language has a built-in module that generates random numbers for you so you don’t have to write the code for this yourself; just use this built-in random number generator instead.

To make sure you know what these random numbers look like, try this out at the Python Shell:

1. Click the Python Shell window to bring it to the front.
2. Import the random module so that you can use the built-in random function, by typing:

   import random

3. Ask the program to generate a random number between 1 and 100 and print it to the screen:

   print(random.randint(1,100))

   You should see a number between 1 and 100 appear on the screen. Type the print statement again. What number do you get this time?

4. Now use a for loop to print lots of random numbers. Make sure you indent the second line so that Python knows that the print statement is part of the for loop:

   for n in range(50):
print(random.randint(1,100))

The two numbers inside the brackets of the randint() function tell it the range of numbers you want it to generate; 1 is the smallest number you should expect it to generate, and 100 the largest.

Laying the Carpets

Earlier in this adventure you used an extra number in the setBlocks() function to make the colour of the woollen carpet red, using the extra data of WOOL. The allowed range of extra data numbers for WOOL is between 0 and 15—in other words, there are 16 colours you can choose from. Now use the following steps to change your house-building program to generate a random number and use that as the colour of WOOL for the carpet in the house:

1. Save your buildStreet.py with File ⇒ Save As from the menu, and call it buildStreet2.py.
2. Add this import statement at the top of the program to gain access to the random number generator:

   import random

3. Change your house() function so that it generates a random carpet colour each time it is used. As WOOL can have an extra data value ranging between 0 and 15, that is the range of random numbers you need to generate. Store the random number in a variable called c so that the carpet-building line doesn’t become too long and hard to read, and make sure that both of these lines are indented correctly, as they are both part of the house() function:

   c = random.randint(0, 15)
mc.setBlocks(x+1, y+1, z+1, x+SIZE-1, y+1, z+SIZE-1, ↩
block.WOOL.id, c)

4. Save your program.

Now you need to find somewhere in your Minecraft world that has plenty of space to build more houses! Move around the world and find somewhere to build, and then run your new program. It should generate another street of houses, but this time, when your player explores inside the houses, the carpet in each house should be a different, random colour. See Figure 3-8 to see what these new houses look like, but your player needs to actually go into each house and look at the carpets so that you can check they are indeed all different!

All of the new Python and Minecraft statements you learned in this chapter are listed in the reference section in Appendix B.

You can find a complete list of block id numbers on the Minecraft wiki: http://minecraft.gamepedia.com/Blocks. Minecraft extra data values are taken from https://minecraft.gamepedia.com/Data_values.

Wool is a very useful block type to build with, as you discovered when laying the random carpets in your street of houses. Here is a reference to the different colours that can be used with the block.WOOL.id block type. Look back at your buildStreet2.py program to see how to provide this extra data to the Minecraft API.