Build it step by step

Every step below leaves a scenario that compiles and runs. If you stop halfway you will have something that works, not something broken. Follow along in Greenfoot rather than reading straight through.

1. Step 1

   On your screen A map array with a legend comment above it, using several different tile codes.

   // 0 floor, 1 wall, 2 coin, 3 player start
   private int[][] map = {
       {1, 1, 1, 1, 1, 1},
       {1, 3, 0, 2, 0, 1},
       {1, 0, 1, 1, 0, 1},
       {1, 2, 0, 0, 0, 1},
       {1, 1, 1, 1, 1, 1}
   };

   The legend comment is not decoration. Come back in a week and `2` means nothing without it.

   Keep it directly above the map, always. If the two ever drift apart, the map becomes unreadable and the only way to work out what a number means is to run it.

   You can already see the level: a walled room, a couple of coins, an interior wall, and the player at top left.

2. Step 2

   On your screen The renderer method with an if chain creating a different actor for each code.

   public void buildMap()
   {
       for (int row = 0; row < map.length; row++)
       {
           for (int col = 0; col < map[row].length; col++)
           {
               int code = map[row][col];
               if (code == 1)      { addObject(new Wall(),   col, row); }
               else if (code == 2) { addObject(new Coin(),   col, row); }
               else if (code == 3) { addObject(new Player(), col, row); }
           }
       }
   }

   The whole renderer. Look at what is in it and where it came from:

   Nested loops from 6.3. The index swap from 6.4. An else if chain from 2.5. addObject from 3.7. A method from 3.2.

   Nothing here is new. This lesson is the assembly, and that is worth noticing: the hardest-looking thing in the course is five familiar pieces stacked up.

3. Step 3

   On your screen The rendered level in the world, matching the array laid out in the code beside it.

   Notice there is no branch for code 0. Floor adds nothing.

   That is deliberate. A 30 by 20 map is 600 cells, and adding a floor actor for every empty one would put 600 actors in a world that needs about 80. On a 1 GB box that matters, and it makes getObjects slower for no benefit.

   If you want a visible floor, use a background image on the world instead.

4. Step 4

   On your screen The constructor calling buildMap, and the world sized from the map.

   public MazeWorld()
   {
       super(map[0].length, map.length, 32);
       buildMap();
   }

   And the constructor ties it together, exactly as prepare() did in 3.7.

   The world is sized from the map, then the map is rendered. Press Reset and the whole level rebuilds itself, because the constructor runs again.

   To design a new level, edit the numbers. That is the payoff for the entire unit, and it is how real tile-based games are built.