Java lernen durch Ausprobieren!

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== Plattform-Spiel ======
Das Plattform-Spiel ist ein Mario-artiges Jump'n Run-Spiel. 
<WRAP center round tip 60%>
**Nützliche Design-Patterns in diesem Spiel:**
  * Verwendung einer Basisklasse ''Level'' mit Methoden zur Gestaltung von Levels und Unterklassen für die einzelnen Level des Spiels
  * Spielfigur mit typischer, Jump'n Run-artiger Bewegung
  * interaktive Welt (bewegliche Plattformen, enemies, ...)
</WRAP>

<HTML>
<div class="java-online" style="height: 500px; width: 100%" data-java-online="{'withBottomPanel': true, 'id': 'BigPlatformer'}">

<script type="text/plain" title="Jump and Run.java">
SystemTools.setSpeed(-1);
new World(1280, 800);
new JumpAndRun();

class JumpAndRun extends Actor {

   String state;
   
   Hero hero;
   Level level;

   Text scoreText;
   int score;

   Text bigText;
   Text pressKeyText;

   Group heartsGroup = new Group();
   int lives = 3;

   Background background;

   int lastTimeSpacePressed = 0;

   JumpAndRun() {
       
      background = new Background();
      background.setPos(0, 0);

      scoreText = new Text(20, 20, 60, "");
      scoreText.setFillColor(Color.white);
      scoreText.setBorderColor(Color.black);
      scoreText.setBorderWidth(4);
      scoreText.setStatic(true);

      bigText = new Text(World.getWorld().getWidth() / 2, World.getWorld().getHeight() / 3, 80, "Deadly Platforms");
      bigText.setFillColor(0x4040ff);
      bigText.setBorderColor(0x303030);
      bigText.setAlignment(Alignment.center);
      bigText.setBorderWidth(4);
      bigText.setStatic(true);
      
      pressKeyText = new Text(World.getWorld().getWidth() / 2, World.getWorld().getHeight() / 3 + 100, 60, "Press space key to start");
      pressKeyText.setFillColor(0x4040ff);
      pressKeyText.setBorderColor(0x303030);
      pressKeyText.setAlignment(Alignment.center);
      pressKeyText.setBorderWidth(4);
      pressKeyText.setStatic(true);

      for(int i = 0; i < 10; i++) {
         heartsGroup.add(new Sprite(World.getWorld().getWidth() - 64 * i - 52, 54, SpriteLibrary.Plattforms, 198));
      }
      heartsGroup.setStatic(true);
      
      setState("startscreen");
   }

   public void act() {
      switch(state) {
         case "startscreen" : 
            if((isKeyDown(" ") || Gamepad.isButtonDown(0, 0)) && System.currentTimeMillis() - lastTimeSpacePressed > 300) {
               lastTimeSpacePressed = System.currentTimeMillis();
               setState("playing");
            }
            break;
         case "playing" : 
            World w = World.getWorld();
            w.follow(hero, 400, 0, 50000, -10000, 620);
            background.setPos(w.getLeft(), w.getTop());
            break;
         case "game over" : 
            if((isKeyDown(" ") || Gamepad.isButtonDown(0, 0)) && System.currentTimeMillis() - lastTimeSpacePressed > 300) {
               lastTimeSpacePressed = System.currentTimeMillis();
               setState("playing");
            }
            break;
      }
   }

   void addToScore(int points) {
      score += points;
      showScore();
   }

   void showScore() {
      scoreText.setText(score);
   }
   
   void showLives() {
      for(int i = 0; i < heartsGroup.size(); i++) {
         heartsGroup.get(i).setVisible(i < lives);
      }
   }

   void looseLive() {
      lives--;
      showLives();
      if(lives == 0) {
         setState("game over");
      } else {
         hero.spawnAtLastCheckpoint();
      }
   }

   void setState(String newState) {
      switch(newState) {
         case "startscreen" : 
            bigText.setVisible(true);
            bigText.setText("Deadly Platforms");
            pressKeyText.setVisible(true);
            break;
         case "playing" : 
            bigText.setVisible(false);
            pressKeyText.setVisible(false);
            if(level != null) level.destroy();
            level = new Level1();
            level.init(World.getWorld());

            hero = new Hero(level, this);
            level.setHeroToStartPosition(hero);
            heartsGroup.bringToFront();
            scoreText.bringToFront();

            score = 0;
            showScore();
            lives = 3;
            showLives();
            break;
         case "game over" : 
            hero.destroy();
            bigText.setVisible(true);
            bigText.setText("Game over");
            pressKeyText.setVisible(true);
            bigText.bringToFront();
            pressKeyText.bringToFront();
            break;
         default : 
             
      }
      state = newState;
   }
}
</script>
<script type="text/plain" title="Background.java">
class Background {
   
   CyclicBackground cb1;
   CyclicBackground cb2;
   CyclicBackground cb3;

   int time = 0;

   Background() {

      cb1 = new CyclicBackground(new Sprite(0, 0, SpriteLibrary.Background, 2), 0xcfeffc, 0xeaf8df);
      cb2 = new CyclicBackground(new Sprite(0, 0, SpriteLibrary.Background, 1), -1, 0xd9d9d9);
      cb3 = new CyclicBackground(new Sprite(0, 0, SpriteLibrary.Background, 0), -1, 0x4abf23);

      cb1.getWorld().setBackgroundColor(0xb8dded);

   }

   public void setPos(double x, double y) {
      cb1.setPosition(x * 0.9, y * 0.9);
      cb2.setPosition(x * 0.3, y * 0.7 + 200);
      cb3.setPosition(x * 0.2, y * 0.4 + 450);
   }

}

</script>
<script type="text/plain" title="CyclicBackground.java">
class CyclicBackground extends Group {
   
   double spriteWidth;
   double spriteHeight;
   Rectangle rectangleAbove;  
   Rectangle rectangleBelow;

   CyclicBackground(Sprite image, int colorAbove, int colorBelow) {
      spriteWidth = image.getWidth();
      spriteHeight = image.getHeight();
      int count = Math.ceil(getWorld().getWidth() / spriteWidth) + 1;

      image.defineCenterRelative(0, 0);   // center of image at top left corner
      image.moveTo(0, 0);
      image.scale(1.005);
      add(image);

      for(int i = 1; i < count; i++) {
         Sprite imageNew = image.copy();
         imageNew.move(spriteWidth * i, 0);
         add(imageNew); 
      }
      if(colorAbove >= 0) {
         rectangleAbove = new Rectangle(0, 0, count * spriteWidth, getWorld().getHeight());
         rectangleAbove.defineCenterRelative(0, 1);
         rectangleAbove.setFillColor(colorAbove);
         rectangleAbove.moveTo(0, 0);
         add(rectangleAbove);
      }
      if(colorBelow >= 0) {
         rectangleBelow = new Rectangle(0, 0, count * spriteWidth, getWorld().getHeight());
         rectangleBelow.defineCenterRelative(0, 0);
         rectangleBelow.setFillColor(colorBelow);
         rectangleBelow.moveTo(0, spriteHeight);
         add(rectangleBelow);
      }
      defineCenter(0, 0);
   }

   void setPosition(double left, double top) {
      World w = getWorld();
      double worldLeft = getWorld().getLeft();
      left -= worldLeft;

      double x = left - Math.ceil(left / spriteWidth) * spriteWidth + worldLeft;
      moveTo(x, top);
   }

}

</script>
<script type="text/plain" title="Hero.java">
class Hero extends Sprite {
   
   Level level;
   JumpAndRun jumpAndRun;

   double vx;
   double vy;
   double gravity = 0.4;
   double jump = -10;
   double speed = 8;

   String animation = "";

   Shape standsOn;
   boolean headingRight = true;

   int lastCheckpointX;
   int lastCheckpointY;

   
   Hero(Level level, JumpAndRun jumpAndRun) {
      super(-10000, -10000, SpriteLibrary.Characters_1, 0);
      this.level = level;
      this.jumpAndRun = jumpAndRun;
   }

   public void act() {
      move(vx, vy);
      if(standsOn != null && !collidesWith(standsOn)) {
         standsOn = null;
      }

      Shape[] collidingShapes = level.staticTilesWithCollision.getCollidingShapes(this);
      for(Shape shape : collidingShapes) {
         if(shape == standsOn) continue;
         reactToCollisionWithShape(shape);
      }

      double gamePadAxisValue = Gamepad.getAxisValue(0, 0);
      
      if(isKeyDown(Key.ArrowLeft) || gamePadAxisValue < -0.2) {
         if(animation != "walk" && standsOn != null) { 
            playAnimation(9, 10, RepeatType.loop, 5);
            animation = "walk";
         }
         vx = Math.min(vx, speed * (isKeyDown(Key.ArrowLeft) ? -1 : gamePadAxisValue));
         if(headingRight) {
            mirrorX();
            headingRight = false;
         }
      } else if((isKeyDown(Key.ArrowRight) || gamePadAxisValue > 0.2)) {
         if(animation != "walk" && standsOn != null) { 
            playAnimation(9, 10, RepeatType.loop, 5);
            animation = "walk";
         }
         vx = Math.max(vx, speed * (isKeyDown(Key.ArrowRight) ? 1 : gamePadAxisValue));
         if(!headingRight) {
            mirrorX();
            headingRight = true;
         }
      } else {
         animation = "";
         if(standsOn != null) {
            vx = vx * 0.8;
            stopAnimation();
            setImageIndex(0);
         }
      }
      if((isKeyDown(Key.ArrowUp) || Gamepad.isButtonDown(0, 0)) && standsOn != null) {
         stopAnimation();
         animation = "";
         setImageIndex(1);
         vy = jump;
         if(standsOn instanceof MovingPlatform) {
            vx += ((MovingPlatform)standsOn).vx;
            vy += ((MovingPlatform)standsOn).vy;
         }
         move(0, vy);
         standsOn = null;
      }

      if(vy > 1) {
         stopAnimation();
         animation = "";
         setImageIndex(2);
      }
      
      if(standsOn == null) {
         vy += gravity;
      }

      Shape[] interactiveTiles = level.interactiveTiles.getCollidingShapes(this);
      for(Shape shape : interactiveTiles) {
         InteractiveElement it = (InteractiveElement)shape;
         it.onCollisionWithPlayer(this, level, jumpAndRun);
      }

   }

   void reactToCollisionWithShape(Shape shape) {
      // shape.tint("#ff0000");
      Direction direction = directionRelativeTo(shape);
      switch(direction) {
         case top : 
            moveBackFrom(shape, true);
            standsOn = shape;
            if(vy >= 18) {
               jumpAndRun.looseLive();
            }
            vy = 0;
            break;
         case left : 
            vx = -2; 
            moveBackFrom(shape, false); 
            move(0, vy);
            break;
         case right : 
            vx = 2;
            moveBackFrom(shape, false); 
            move(0, vy);
            break;
         case bottom : 
            // shape.tint("#0000ff");
            move(0, -1);
            moveBackFrom(shape, false); 
            vy = Math.abs(vy);
            break;
      }

   }
   
   void spawn(int x, int y) {
      vx = 0;
      vy = 0;
      moveTo(jumpAndRun.level.xToScreenX(x), jumpAndRun.level.yToScreenY(y) + 20);
   }

   void spawnAtLastCheckpoint() {
      spawn(lastCheckpointX, lastCheckpointY - 1);
   }

}

</script>
<script type="text/plain" title="Interactive Elements.java">
class FallingWheelFactory extends Actor {
   
   Sprite outlet;
   int counter;
   Level level;
   double yBottom;

   FallingWheelFactory(Level level, double xOutlet, double yOutlet, double yBottom) {
      outlet = new Sprite(xOutlet, yOutlet, SpriteLibrary.Plattforms, 95);
      outlet.mirrorY();
      level.staticTilesWithoutCollision.add(outlet);
      this.level = level;
      this.yBottom = yBottom;
   }

   public void act() {
      counter++;
      switch(counter) {
         case 40 : 
            outlet.setImageIndex(94);
            break;
         case 80 : 
            outlet.setImageIndex(95);
            FallingWheel fw = new FallingWheel(level, outlet.getCenterX(), outlet.getCenterY(), yBottom);
            counter = 0;
            break;
         default : 
      }
   }

}

class FallingWheel implements InteractiveElement extends Sprite {
 
   double yBottom;
   
   FallingWheel(Level level, double outletX, double outletY, double yBottom) {
      super(outletX, outletY, SpriteLibrary.Plattforms, 270);
      scale(0.6);
      tint("#f37828");
      this.yBottom = yBottom;
      level.interactiveTiles.add(this);
   }

   public void act() {
      move(0, 10);
      rotate(8);
      if(getCenterY() > yBottom) {
         destroy();
      }
   }

   void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun) {
   
      destroy();
      jumpAndRun.looseLive();

   }
}


class Checkpoint implements InteractiveElement extends Sprite {

   int spriteIndex;
   boolean reached = false;
   int x;
   int y;

   Checkpoint(Level level, int x, int y, int spriteIndex) {
      super(level.xToScreenX(x), level.yToScreenY(y), SpriteLibrary.Plattforms, spriteIndex);
      this.x = x;
      this.y = y;
      this.spriteIndex = spriteIndex;
      level.interactiveTiles.add(this);
   }

   void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun) {
      if(!reached) {
         playAnimation(spriteIndex - 2, spriteIndex - 1, RepeatType.loop, 2);
         hero.lastCheckpointX = x;
         hero.lastCheckpointY = y;
         reached = true;
      }
  	} 
}


class BackAndForthEnemy implements InteractiveElement extends Sprite {

   double xFrom;
   double xTo;
   double v;
   double x;
   int spriteIndex;
   boolean isDead = false;
   double alpha = 1;

   BackAndForthEnemy(Level level, double x, double y, 
      double xFrom, double xTo, double v,
      int spriteIndex) {
      
      super(x, y, SpriteLibrary.Plattforms, spriteIndex);
      this.v = v;
      this.xFrom = xFrom;
      this.xTo = xTo;
      this.x = x;
      this.spriteIndex = spriteIndex;
      playAnimation(spriteIndex, spriteIndex + 1, RepeatType.backAndForth, 3);
      if(v > 0) this.mirrorX();
      level.interactiveTiles.add(this);
   }

   public void act() {
      if(!isDead) {
         move(v, 0);
         x += v;
         if(x < xFrom || x > xTo) {
            v = -v;
            mirrorX();
         }
      } else {
         alpha -= 0.05;
         if(alpha < 0) {
            destroy();
         } else {
            setAlpha(alpha);
         }
      }
   }

   void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun) {
      if(isDead) return;
      if(hero.getCenterY() < getCenterY() - getHeight() / 2 && hero.vy > 2) {
         defineCenterRelative(0.5, 0.8);
         rotate(-180);
         stopAnimation();
         isDead = true;
         setImageIndex(spriteIndex + 2);
         new AnimatedScore(50, this.centerX, this.centerY, jumpAndRun);
      } else {
         jumpAndRun.looseLive();
      }
  	}

}


class Spikes implements InteractiveElement extends Group {

   Spikes(Level level, int x, int y, int length) {
      level.interactiveTiles.add(this);
      double xd = level.xToScreenX(x);
      double yd = level.yToScreenY(y);
      for(int i = 0; i < length; i++) {
         Sprite s = new Sprite(xd + 64 * i, yd, SpriteLibrary.Plattforms, 74);
         this.add(s); 
      }
      
   }

  	void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun) {
      jumpAndRun.looseLive();
  	}

}
class Frog implements InteractiveElement extends Sprite {
   double jumpCounter = 0;
   boolean ziel = false;
   boolean onFloor;
   double floory;
   double vx = 0;
   double vy = 0;
   Level level;
   Frog(Level level, int x, int y) {
      super(level.xToScreenX(x), level.yToScreenY(y) - 1, SpriteLibrary.Plattforms, 126);
      level.interactiveTiles.add(this);
      this.level = level;
      level.interactiveTiles.add(this);
      floory = getCenterY();
   }

   public void act() {
      // Shape[] collidingShapes = level.staticTilesWithCollision.getCollidingShapes(this);
      if(getCenterY() > floory) {
         vx = 0;
         vy = 0;
         onFloor = true;
         setImageIndex(126);
      }else{
         onFloor = false;
         setImageIndex(127);
      }
      if(onFloor) {
         jumpCounter++;
         if(jumpCounter >= 30) {
            jumpCounter = 0;
            vy = -10;
            vx = 10;
            mirrorX();
            if(ziel) {
               vx = -vx;
            }
            move(vx, vy);
            ziel = !ziel;
         }
      }else{
         move(vx, vy);
         vy += 1;
      }
   }
   
  	void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun) {
      jumpAndRun.looseLive();
  	}

}
</script>
<script type="text/plain" title="Level.java">
abstract class Level {
   Group staticTilesWithoutCollision = new Group();
   Group staticTilesWithCollision = new Group();
   Group interactiveTiles = new Group();

   int currentX;
   int currentY;
   Group currentGroup;
   
   double movePixelX;
   double movePixelY;

   abstract void init(World world);
   abstract void setHeroToStartPosition(Hero hero);

   void destroy() {
      staticTilesWithCollision.destroyAllChildren();
      staticTilesWithoutCollision.destroyAllChildren();
      interactiveTiles.destroyAllChildren();
   }

   void startBlocks(int x, int y, boolean withCollision) {
      currentX = x;
      currentY = y;
      currentGroup = new Group();
      if(withCollision) {
         staticTilesWithCollision.add(currentGroup);
      } else {
         staticTilesWithoutCollision.add(currentGroup);
      }
      movePixelX = 0;
      movePixelY = 0;
      return;
   }

   void moveByPixels(double movePixelX, double movePixelY) {
      this.movePixelX = movePixelX;
      this.movePixelY = movePixelY;
      return;
   }

   void addBlocks(int... indices) {
      for(int i = 0; i < indices.length; i++) {
         int index = indices[i];
         if(index >= 0) {
            Sprite s = new Sprite(xToScreenX(currentX), yToScreenY(currentY), SpriteLibrary.Plattforms, indices[i]);
            s.scale(1.01);
            currentGroup.add(s);
         }
         currentX++;
      }
      return;
   }

   
   void addBlocksXY(int left, int top, int... indices) {
      for(int i = 0; i < indices.length; i++) {
         int index = indices[i];
         if(index >= 0) {
            Sprite s = new Sprite(xToScreenX(left), yToScreenY(top), SpriteLibrary.Plattforms, indices[i]);
            s.scale(1.01);
            currentGroup.add(s);
         }
         left++;
      }
      return;
   }



   void addHorizontalLine(int leftIndex, int centerIndex, int rightIndex, int length) {
      addBlocks(leftIndex);
      for(int i = 0; i < length - 2; i++) {
         addBlocks(centerIndex);
      }
      addBlocks(rightIndex);
      return;
   }

   void addVerticalLine(int topIndex, int centerIndex, int bottomIndex, int length) {
      int x = currentX;
      addBlocks(topIndex);
      for(int i = 0; i < length - 2; i++) {
         currentX = x;
         currentY++;
         addBlocks(centerIndex);
      }
      currentX = x;
      currentY++;
      addBlocks(bottomIndex);
      return;
   }

   void addTilingSprite(int x, int y, int width, int height, int index) {
      Sprite s = new Sprite(xToScreenX(x)-0.05, yToScreenY(y)-0.05, SpriteLibrary.Plattforms, index);
      s.makeTiling(64 * width + 0.1, 64 * height + 0.1);
      currentGroup.add(s);
   }

   void addBlockSquareWithTiles(int topLeftIndex, int topIndex, int topRightIndex, int rightIndex, 
      int bottomRightIndex, int bottomIndex, int bottomLeftIndex, int leftIndex, 
      int centerIndex, int width, int height) {
      int left = currentX;
      int top = currentY;
      addBlocksXY(left, top, topLeftIndex);
      addBlocksXY(left + width - 1, top, topRightIndex);
      addBlocksXY(left + width - 1, top + height - 1, bottomRightIndex);
      addBlocksXY(left, top + height - 1, bottomLeftIndex);

      addTilingSprite(left + 1, top, width - 2, 1, topIndex);
      addTilingSprite(left + 1, top + height - 1, width - 2, 1, bottomIndex);
      addTilingSprite(left, top + 1, 1, height - 2, leftIndex);
      addTilingSprite(left + width - 1, top + 1, 1, height - 2, rightIndex);

      addTilingSprite(left + 1, top + 1, width - 2, height - 2, centerIndex);
   }

   void addBlockSquare(int topLeftIndex, int topIndex, int topRightIndex, int rightIndex, 
      int bottomRightIndex, int bottomIndex, int bottomLeftIndex, int leftIndex, 
      int centerIndex, int width, int height) {
      int left = currentX;
      addHorizontalLine(topLeftIndex, topIndex, topRightIndex, width);
      for(int i = 0; i < height - 2; i++) {
         currentX = left;
         currentY++;
         addHorizontalLine(leftIndex, centerIndex, rightIndex, width);
      }
      currentY++;
      currentX = left;
      addHorizontalLine(bottomLeftIndex, bottomIndex, bottomRightIndex, width);
   }

   void setPos(int x, int y) {
      currentX = x;
      currentY = y;
   }

   void setPos(int x, int y, double movePixelX, double movePixelY) {
      currentX = x;
      currentY = y;
      this.movePixelX = movePixelX;
      this.movePixelY = movePixelY;
   }

   double xToScreenX(int x) {
      return 32 + x * 64 + movePixelX;
   }

   double yToScreenY(int y) {
      return 32 + y * 64 + movePixelY;
   }

   

   Sprite addTile(int x, int y, int index, boolean withCollision) {
      Sprite tile = new Sprite(xToScreenX(x), yToScreenY(y), SpriteLibrary.Plattforms, index);
      if(withCollision) {
         staticTilesWithCollision.add(tile);
      } else {
         staticTilesWithoutCollision.add(tile);
      }
      return tile;
   }

}
</script>
<script type="text/plain" title="Level 1.java">
// SystemTools.setSpeed(-1);
// World w = new World(7000, 1600);

// w.move(0, 420);
// new Level1().init(w);

class Level1 extends Level {

   void setHeroToStartPosition(Hero hero) {

      // hero.lastCheckpointX = 46;
      // hero.lastCheckpointY = -10;

      hero.lastCheckpointX = 3;
      hero.lastCheckpointY = 2;
      hero.spawnAtLastCheckpoint();
   }
 

   void init(World world) {
      world.move(-world.getLeft(), 180 - world.getTop());
      world.setBackgroundColor("#5050ff");
      // Boden
      startBlocks(0, 8, true);
      addBlockSquareWithTiles(1, 2, 3, 4, 22, 4, 21, 4, 4, 101, 2);
      //Weltgrenze links
      startBlocks(0, 2, true); 
      addVerticalLine(35, 35, 35, 6);
      // Weltgrenze rechts
      startBlocks(100, 2, true); 
      addVerticalLine(35, 35, 35, 6);

      // Plattformen
      startBlocks(10, 6, true); moveByPixels(0, -5);
      addHorizontalLine(15, 16, 17, 5);

      new LeftRightMovingPlatform(this, 16, 4, 4, 64 * 7, 4);

      startBlocks(29, 2, true);
      addHorizontalLine(15, 16, 17, 5);

      new UpDownMovingPlatform(this, 38, 3, 4, 11 * 64, -4);

      for(int i = 0; i < 40; i++) {
         int index = Random.randint(83, 93);
         int x = Random.randint(1, 45);
         Sprite tile = addTile(x, 7, index, false);
         double factor = Math.random() * 1.5 + 0.5;
         tile.defineCenterRelative(0.5, 1);
         tile.scale(factor); 
      }
      
      // black background
      // Rectangle r = new Rectangle(xToScreenX(46) - 32, yToScreenY(-15), 54 * 54, 64 * 30);
      // r.setFillColor(Color.black);
      // this.staticTilesWithoutCollision.add(r);

      Sprite darkBackground = new Sprite(xToScreenX(46) - 16, yToScreenY(-15), SpriteLibrary.Boulders, 0);
      darkBackground.makeTiling(54 * 54, 64 * 30);
      darkBackground.tint(0x303030);
      this.staticTilesWithoutCollision.add(darkBackground);

      addStoneBlock(46, -15, 44, 4, true, true);
      addStoneBlock(90, -15, 2, 20, false, false);
      addStoneBlock(46, -8, 5, 4, false, false); addStoneBlock(54, -11, 6, 5, false, false);
      addStoneBlock(46, -4, 9, 4, false, false); addStoneBlock(58, -6, 2, 8, false, false);
      startBlocks(50, 2, true);
      addHorizontalLine(59, 60, 61, 12);
      addStoneBlock(46, 0, 1, 8, false, false);

      for(int i = 0; i < 4; i++) {
         startBlocks(48 + 5 * i, 6 - (i == 3 ? 2 : 0), true);
         addBlocks(59, 61); 
      } 
      new Spikes(this, 48, 7, 17);

      addStoneBlock(65, -9, 2, 17, false, false);

      // addStoneBlock(60, 2, 2, 2, false, false); 
      
      startBlocks(63, 0, true); addBlocks(59, 60);
      startBlocks(60, -2, true); addBlocks(60, 61);
      startBlocks(63, -4, true); addBlocks(59, 60);
      startBlocks(60, -6, true); addBlocks(60, 61);
      startBlocks(63, -8, true); addBlocks(59, 60);

      addStoneBlock(67, -5, 20, 2, false, false);
      addStoneBlock(70, 4, 20, 2, false, false);

      int[] posX = { 4, 10, 20, 40 };
      int[] posY = { 5, 3, 0, -6 };
      for(int i = 0; i < posX.length; i++) {
         new Star(this, posX[i], posY[i]);
      }

      new BackAndForthEnemy(this, xToScreenX(12), yToScreenY(5), 
         xToScreenX(10), xToScreenX(14), 5, 
         120);

      new BackAndForthEnemy(this, xToScreenX(52), yToScreenY(1), 
         xToScreenX(50), xToScreenX(57), 6, 
         123);

      new Frog(this, 71, -6);

      new Checkpoint(this, 48, -9, 156);
      new Checkpoint(this, 30, 1, 156);

      for(int i = 0; i < 2; i++) {
         new Torch(xToScreenX(48 + 3 * i), yToScreenY(-10));
      }

      for(int i = 0; i < 4; i++) {
         new Torch(xToScreenX(50 + 3 * i), yToScreenY(4));
      }

      new FallingWheelFactory(this, xToScreenX(62), yToScreenY(-11), yToScreenY(8));

   }

   void addStoneBlock(int left, int top, int width, int height, boolean topDark, boolean bottomRound) {
      startBlocks(left, top, true);
      if(height > 2) { 
         if(topDark) {
            addBlockSquare(62, 46, 63, 48, bottomRound ? 65 : 48, 48, bottomRound ? 64 : 48, 48, 48, width, height); 
         } else {
            addBlockSquare(48, 48, 48, 48, bottomRound ? 65 : 48, 48, bottomRound ? 64 : 48, 48, 48, width, height); 
         }
      } else {
         addHorizontalLine(45, 46, 47, width);
      }
   }



}

</script>
<script type="text/plain" title="MovingPlatforms.java">
interface InteractiveElement {
   
   abstract void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun);

}

abstract class MovingPlatform implements InteractiveElement extends Group {

   double vx;
   double vy;
   Hero hero;  

   abstract void movePlayerAndPlattform();
     
   public void act() {

      if(hero != null && hero.standsOn != this) {
         hero = null;
      }

      movePlayerAndPlattform();
   }

   void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun) {
      if(hero.standsOn != this) {
         hero.reactToCollisionWithShape(this); 
         this.hero = hero;
      } 
   }

}

class LeftRightMovingPlatform extends MovingPlatform {
     
   double v;
   double movingDistance; 
   double position = 0;
   
   LeftRightMovingPlatform(Level level, int x, int y, int length, double movingDistance, double v) {
      level.interactiveTiles.add(this);
      this.v = v;
      this.movingDistance = movingDistance;
      vx = v;

      level.currentGroup = this;
      level.setPos(x, y); 
      level.addHorizontalLine(15, 16, 17, length);
   }


  	void movePlayerAndPlattform() {
      
      move(vx, 0);
      
      if(hero != null) {
         hero.move(vx, 0);
      }

      position += vx;
      if(position >= movingDistance || position < 0) {
         vx *= -1;
      }

  	}

}

class UpDownMovingPlatform extends MovingPlatform {
     
   double v;
   double movingDistance; 
   double position = 0;
   
   UpDownMovingPlatform(Level level, int x, int y, int length, double movingDistance, double v) {
      level.interactiveTiles.add(this);
      this.v = v;
      this.movingDistance = movingDistance;
      vy = v;

      if(v < 0) {
         position = movingDistance - 1;
      }

      level.currentGroup = this;
      level.setPos(x, y); 
      level.addHorizontalLine(15, 16, 17, length);
   }


  	void movePlayerAndPlattform() {
      
      move(0, vy);
      
      if(hero != null) {
         hero.move(0, vy);
      }

      position += vy;
      if(position >= movingDistance || position < 0) {
         vy *= -1;
      }

  	}

}



</script>
<script type="text/plain" title="Star.java">
class Torch extends Sprite {
   
   Torch(double x, double y) {
      super(x, y, SpriteLibrary.Plattforms, 168);
      playAnimation(168, 169, RepeatType.loop, 3);
   }

}

class Star implements InteractiveElement extends Sprite {
 
   int time = 0;

   Star(Level level, int x, int y) {
      super(level.xToScreenX(x), level.yToScreenY(y), SpriteLibrary.Plattforms, 176);
      level.interactiveTiles.add(this);
   }

  	void onCollisionWithPlayer(Hero hero, Level level, JumpAndRun jumpAndRun) {
      Sound.playSound(Sound.short_bell);
      new AnimatedScore(10, getCenterX(), getCenterY(), jumpAndRun);
      destroy();
   }
     
   public void act() {
      rotate(3);
      time++;
      if(time % 16 <= 7) {
         scale(0.97);
      } else {
         scale(1 / 0.97);
      }
   }

}

class AnimatedScore extends Text {
   Vector2 v;
   int counter = 50;
   JumpAndRun jumpAndRun;
   int points;
   double alpha = 1;

   AnimatedScore(int points, double x, double y, JumpAndRun jumpAndRun) {
      super(x, y, 60, "+ " + points);
      setFillColor(Color.yellow);
      setBorderColor(Color.gray);
      setBorderWidth(3);
      v = new Vector2(getWorld().getLeft() + 20 - x, getWorld().getTop() + 20 - y).scaledBy(1.0 / counter);
      this.jumpAndRun = jumpAndRun;
      setStatic(true);
      this.points = points;
   }

   public void act() {
      counter--;
      alpha -= 0.01;
      if(counter > 0) {
         move(v.x, v.y);
         setAlpha(alpha);
      } else {
         jumpAndRun.addToScore(points);
         destroy();
      }
   }

}
</script>

</div>

</HTML>