The Robot

• How your robot will move?
• How you will control it?
• How you can do that?

What do you think if we answer to these questions?

Robot design

• The robot always falls, except when he is in collision with a tile.
• The robot doesn't manage any collision.
• When the robot walks its animation is played, otherwise its animation is stopped.
• Control keys:
  • UP: the robot goes up and its reacteurs burn.
  • LEFT: the robot goes left, but:
    • If the robot is on a tile, it walks.
    • If it isn't laid on a tile, its left reactors burn.
  • RIGHT: the robot goes left, but:
    • If the robot is on a tile, it walks.
    • If it isn't laid on a tile, its left reactors burn.

It's enough, we need nothing else for this example, and this simple enumeration of behaviours gives us a complete comportment of the robot.

Now, we can build our robot. For this, we will create 3 objects:

• RobotSprite: A MovingSpriteWrapper which know how the robot moves in one direction (to the left or to the right)
• RobotDummy: a SpriteWrapper which chooses which RobotSprite to use between the left or the right direction.
• RobotControler: A SpriteWrapper used to control the robot with arrow keys.

These 3 objects are assembled in class DisplayRobot.java in the following order:

RobotSprite

• How does the robot fly?
• How does the robot walk?

But the first thing, we don't have to forget to set the pre-collision mode to true in the constructor of the class.

How does the robot fly?

	Left Direction	Right Direction
Upstairs flames
Horizontal flames

To avoid collision with tiles, these sprites are set to background sprites, and there are displayed only when needed.
But, we don't have to forget to do elementary actions:

• Add these sprites to the parent playfield of the RobotSprite, and to remove them when needed.
• To move flames when the robot moves.

These 2 actions are done in the following code:

...
  /**
   * Sets the parent playfield for flames sprites.
   */
  protected void setParent(PlayField parent) {
    if (getParent() != null) {
      getParent().removeSprite(horizontalJet);
      getParent().removeSprite(upJet);
    }
    super.setParent(parent);
    if (parent != null) {
      int index = getParent().getSpriteIndex(getFinalWrapper());
      getParent().addSprite(horizontalJet, index);
      getParent().addSprite(upJet, index);
    }
  }

  /**
   * Sets position of flames sprites too.
   */
  public boolean setPosition(int x, int y) {
    if (super.setPosition(x, y)) {
      horizontalJet.setPosition(x + hjDx, y + hjDy);
      upJet.setPosition(x + ujDx, y + ujDy);
      return true;
    } else {
      return false;
    }
  }
...

Now, we have to decide when to burn reactors. For the upstairs, it's easier, when the robot go upstairs, upstairs flames must be shown. For horizontal flames, it's a little bit different; they must be shown when the robot must walk and it isn't on a tile. We will see how to that in the moving engine section.

How does the robot walk?

By default, the robot is always falling, except when:

• It flies.
• It's in collision with a tile. Only a tile can tell that.

When an order to walk is given to the RobotSprite, before it will really walk, it will check different cases:

• If it's flying; burns horizontal flames and moves.
• If it's falling: burns horizontal flames and moves.
• Otherwise; walk really.

When the robot walks really, we use an AnimatedSprite (the ActionSprite of the RobotSprite), with the following sequences of pictures:

Left sequence:
Right sequence:

When the robot walks, we must activate the animation of the AnimatedSprite, and stop it when the robot stops walking.

Moving engine

...
  /**
   * Moving engine of the robot.
   */
  public void move(int ticks) {
    if (isFlying()) {
      ((AnimatedSprite) getActionSprite()).setPause(true);
      if (!upJet.isVisible()) {
	upJet.setVisible(true);
      }
      setPosition(getX(), getY() - getVerticalSpeed());
      if (isWalking() && !horizontalJet.isVisible()) {
	horizontalJet.setVisible(true);
      }
    } else {
      if (upJet.isVisible()) {
	upJet.setVisible(false);
      }
      if (setPosition(getX(), getY() + getVerticalSpeed())) {
	((AnimatedSprite) getActionSprite()).setPause(true);
	if (isWalking() && !horizontalJet.isVisible()) {
	  horizontalJet.setVisible(true);
	}
      } else if (isWalking()) {
	((AnimatedSprite) getActionSprite()).setPause(false);
	if (horizontalJet.isVisible()) {
	  horizontalJet.setVisible(false);
	}
      }
    }

    if (isWalking()) {
      setPosition(getX() + getHorizontalSpeed(), getY());
    } else {
      ((AnimatedSprite) getActionSprite()).setPause(true);
      if (horizontalJet.isVisible()) {
	horizontalJet.setVisible(false);
      }
    }
  }
...

The secret is to check if setPosition(int, int) are done or not. You can notice than the displacement is done only on one axis at a time; that allows to know exactly on which direction the movement can be done.

RobotDummy

• Vertically: 2 pixels
• Horizontally: -3 pixels for the left sprite, 3 pixels for the right pixel

This class transmit order from the controller (we will see it later) for movements. But for horizontal displacements, before to transmit the order, the wrapper checks if the right action sprite will receive it.
To make that, we only have to check if the current action sprite is the expected one. If not we have to change it, but we have to copy the states from the previous to the new one. This is done by the following code:

...
  /**
   * Changes direction of the robot
   */
  protected void changeDirection(RobotSprite fromSprite, RobotSprite toSprite) {
    PlayField parent = getParent();
    Sprite finalWrapper = getFinalWrapper();
    Point p = getPosition();
    toSprite.setCurrentPictureNumber(fromSprite.getCurrentPictureNumber());
    parent.removeSprite(finalWrapper);
    setActionSprite(toSprite);
    setPosition(p.x, p.y);
    toSprite.fly(fromSprite.isFlying());
    parent.addSprite(finalWrapper);
  }

  /**
   * Order to go the to left
   */
  public void goLeft() {
    if (getActionSprite() != robotLeft) {
      changeDirection(robotRight, robotLeft);
    }
    robotLeft.walk(true);
  }

  /**
   * Order to go the to right
   */
  public void goRight() {
    if (getActionSprite() != robotRight) {
      changeDirection(robotLeft, robotRight);
    }
    robotRight.walk(true);
  }
...

You can notice that we completely remove the sprite from the playfield before we change the action sprite of the wrapper.

RobotControler

...
  /**
   * Adds this KeyListener to the playfield
   */
  protected void setParent(PlayField parent) {
    if (getParent() != null) {
      getParent().removeKeyListener(this);
    }
    super.setParent(parent);
    if (parent != null) {
      parent.addKeyListener(this);
    }
  }
...

Nothing special to explain…

A little hint

Now, the robot is completely explained, and you have all you need to move it. But don't you find the robot walks a long time before it falls?
In the next chapter, we will see how to avoid these unattractive collisions.