These are thoughts on how to create a Ghost Block for your project. 

For this problem, you need to add new/additional constructors to Block, Point, SetOfBlocks, and 
Tetromino. This so that you can create the ghost which is essentially a clone of the falling tetromino

  Block(Block block) {
    this(block.x, block.y, Color.LIGHT_GRAY);
  }

We mark the code above with // [1] in the final code. 

  Point (Point p) {
    this(p.x, p.y);
  }

We mark the code above with // [2] in the final code. 
  
  SetOfBlocks(SetOfBlocks blocks) {
    for (Block b : blocks)
      this.add(new Block(b));
  }

We mark the code above with // [3] in the final code. 

  SetOfBlocks() {
  
  }

We mark the code above with // [4] in the final code. 

This last one is necessary because we need it and it disappears when the cloning constructor is added. 

  Tetromino(Tetromino t) {
    this.center = new Point(t.center);
    this.blocks = new SetOfBlocks(t.blocks);
  }

We mark the code above with // [5] in the final code. 

This is the reason we started all of this: we needed a deep clone of the falling tetromino.

Now cloning *is* possible. What else do we do? 
  
In Tetris you have to define the Tetromino ghost

   Tetromino t, 
             ghost; // [6] notice this initializes ghost with null 

Earlier we didn't have [6]. 

In the draw method you have to draw the ghost but only when there is one:

    if (ghost != null)
        ghost.draw(g);

We mark the code above with // [7] in the final code. 

Notice the code occurs before drawing the falling tetromino so that the falling 
piece will overlap the ghost when the piece begins landing. Also notice some additional
debug code that was useful to us. 

In the update method you have to add:

    this.theGhostOf(this.t);

to the else statement so that you can get the ghost of the falling tetromino. This isn't
in fact necessary all the time, just the first time around, since falling down vertically 
does not have an effect on the shadow. But we can't do it otherwise and it's a good idea 
to recalculate the shadow after every movement (especially horizontal movement).

In the key event for pressing left, right, or r you must add:

    this.theGhostOf(this.t); // [oops!]

so that each time you press left, right, or r the ghost will be updated. 

We do this three times, and we mark this with // [8] each time. 

In the key event for pressing the space bar you must add:

    this.ghost = null;

so that the ghost piece will disappear and be replaced with the tetromino

We mark this as // [9]. 

You then finally need to add the definition of void method theGhostOf for calculating the 
ghost which is essentially a clone of the falling tetromino:

  void theGhostOf(Tetromino t) {   
    if (this.t == null) {
      this.ghost = null; 
      return; 
    }
    this.ghost = new Tetromino(t); // cloning it
    this.jumpDown(this.ghost); 
  }

We mark this with // [10] in the final code. 

In the touchdown() method you must first call:

    this.ghost = null; // [11] 

so that the ghost piece will be removed (same reasoning as when hitting space bar). 

The jumpDown(), landedOnBlocks(), landedOnFloor(), and landed() methods must also be updated
These methods are all now called on (Tetromino t) and rather than acting on this, they act on t. 
This allows for the updating of only the falling tetromino, rather than the world

Hope this helps. 

--