public void mouseWheelMoved(
     ViewPanel v, short wheelDirection, int jpx, int jpy, MouseWheelEvent e) {
   Camera c = application.vsm.getActiveCamera();
   double a = (c.focal + Math.abs(c.altitude)) / c.focal;
   if (wheelDirection == WHEEL_UP) {
     c.altitudeOffset(-a * 5);
     application.vsm.repaint();
   } else {
     // wheelDirection == WHEEL_DOWN
     c.altitudeOffset(a * 5);
     application.vsm.repaint();
   }
 }
示例#2
0
  public void step() {
    Camera cam = cameras.get(0);
    cam.activate();

    cam.setColor(Color.black);
    tree.display(50, 90, cam, spread, levelHeight);
    // -------------------------------------------------

    cam = cameras.get(1);
    cam.activate();

    if (state.equals("add")) {
      cam.setColor(Color.black);
      cam.drawText(">>> " + stringToAdd, 5, 2);
    }
  }
示例#3
0
  public void keyPressed(KeyEvent e) {
    int code = e.getKeyCode();

    Camera cam = cameras.get(0);

    if (state.equals("regular")) {
      if (code == KeyEvent.VK_L) {
        cam.shiftRegion(0.25, 0);
      } else if (code == KeyEvent.VK_R) {
        cam.shiftRegion(-0.25, 0);
      } else if (code == KeyEvent.VK_U) {
        cam.shiftRegion(0, -0.25);
      } else if (code == KeyEvent.VK_D) {
        cam.shiftRegion(0, 0.25);
      } else if (code == KeyEvent.VK_S) {
        cam.scaleRegion(1.1, 1.1);
      } else if (code == KeyEvent.VK_B) {
        cam.scaleRegion(1 / 1.1, 1 / 1.1);
      } else if (code == KeyEvent.VK_W) {
        spread *= 1.1;
      } else if (code == KeyEvent.VK_N) {
        spread /= 1.1;
      } else if (code == KeyEvent.VK_H) {
        cam.setRegion(0, 100, 0, 100);
      }

    } // regular state
    else if (state.equals("add")) {
      if (code == KeyEvent.VK_ENTER) {
        state = "regular";
        if (!stringToAdd.equals("")) tree.add(stringToAdd);
      } else if (code == KeyEvent.VK_DELETE || code == KeyEvent.VK_BACK_SPACE) {
        if (stringToAdd.length() > 0)
          stringToAdd = stringToAdd.substring(0, stringToAdd.length() - 1);
      }
    } // add state
  }
示例#4
0
  public static void loadLevel(File levelFile) {

    // clean up old loads:
    loadedLevel.clean();

    if (levelFile != null) {
      GameObject[] go = new GameObject[0];

      try {
        loadedLevel = new Level(levelFile.getPath());
        camera = loadedLevel.getCamera();
        go = loadedLevel.getGameObjects();
      } catch (Exception e) {
        System.out.println(e);
      }

      // Reset numberOf ...
      numberOfBoxes = 0;
      numberOfSprites = 0;
      numberOfTiles = 0;

      for (int i = 0; i < actor.length; i++) {
        actor[i] = null;
      }

      backgroundImage = new Image[2];

      try {
        tileSheet = ImageIO.read(new File(loadedLevel.levelName + "/tilesheet.png"));
        backgroundImage[0] = ImageIO.read(new File(loadedLevel.levelName + "/bg0.png"));
        backgroundImage[1] = ImageIO.read(new File(loadedLevel.levelName + "/bg1.png"));
      } catch (Exception e) {
        System.out.println("ERROR loading images: " + e);
      }

      int MapWidth = loadedLevel.getWidth();
      int MapHeight = loadedLevel.getHeight();

      for (int y = 0; y < MapHeight; y++) {
        for (int x = 0; x < MapWidth; x++) {
          // Number entered in the position represents tileNumber;
          // position of the sprite x*16, y*16

          // get char at position X/Y in the levelLoaded string
          char CharAtXY =
              loadedLevel.level.substring(MapWidth * y, loadedLevel.level.length()).charAt(x);

          // Load objects into the engine/game
          for (int i = 0; i < go.length; i++) {
            if (CharAtXY == go[i].objectChar) {
              try {
                invoke(
                    "game.objects." + go[i].name,
                    "new" + go[i].name,
                    new Class[] {Point.class},
                    new Object[] {new Point(x * 16, y * 16)});
              } catch (Exception e) {
                System.out.println("ERROR trying to invoke method: " + e);
              }
            }
          }

          // Load tiles into engine/game
          // 48 = '0' , 57 = '9'
          if ((int) CharAtXY >= 48 && (int) CharAtXY <= 57) {
            tileObject[gameMain.numberOfTiles] = new WorldTile(Integer.parseInt(CharAtXY + ""));
            tileObject[gameMain.numberOfTiles - 1].sprite.setPosition(x * 16, y * 16);
          }
        }
      }

      // clean up:
      loadedLevel.clean();

      // additional game-specific loading options:
      camera.forceSetPosition(new Point(mario.spawn.x, camera.prefHeight));
      pCoin = new PopupCoin(new Point(-80, -80));

      levelLoaded = true;
    } else {
      System.out.println("Loading cancelled...");
    }
  }
示例#5
0
  // -- Main Loop
  public void run() {

    // called only once:
    initialize();

    // create me a timer
    Timer t = new Timer();

    // start main loop:
    while (true) {

      if (levelLoaded == true) {

        camera.follow(mario.sprite);

        // act() all actors that are actable:
        int a = 0;
        while (actor[a] != null && actor[a] instanceof Actable) {
          Actable actable = (Actable) actor[a];
          actable.act();
          a++;
        }

        pCoin.fly();

        for (int i = 0; i < numberOfBoxes; i++) {
          try {
            box[i].open();
          } catch (Exception e) {
            System.out.println("ERROR: " + e);
          }
        }
        for (int i = 0; i < numberOfCoins; i++) {
          try {
            coin[i].collect();
          } catch (Exception e) {
            System.out.println("ERROR: " + e);
          }
        }

        // reset mario if fallen off from screen:
        if (mario.sprite.posy > loadedLevel.getHeight() * 16) {
          camera.position = new Point(width / 2, camera.prefHeight + camera.tolerance);
          mario.sprite.setPosition(new Point(gameMain.mario.spawn.x, gameMain.mario.spawn.y));
        }
      }

      try {

        // Draw to panel if not Fullscreen
        if (fullscreen == false) {

          t.start();

          render();
          repaint();

          System.out.println("FPS: " + (int) (((100 / (double) t.stop())) * 2));

        } else {

          t.start();

          long sleeptime = 5 - t.stop();

          // calculate sleep time (max fps)
          if (sleeptime < 0) {
            sleeptime = 0;
          }

          main.sleep(1L + sleeptime);

          fps = (int) (((100 / (double) t.stop())) * 2);

          System.out.println("FPS: " + fps);
        }
      } catch (Exception e) {

      }
    }
  }
  public void initTest(String vt) {
    eh = new TestDefaultHandler.EventHandlerTestDTH(this);
    vs = vsm.addVirtualSpace("src");
    cam = vs.addCamera();
    List<Camera> cameras = new ArrayList<Camera>();
    cameras.add(cam);
    cam.setZoomFloor(-90);
    testView = vsm.addFrameView(cameras, "Test", vt, 800, 600, true);
    testView.setBackgroundColor(Color.LIGHT_GRAY);
    testView.setListener(eh);
    final Glyph circle = new VCircle(100, 0, 0, 40, Color.WHITE);
    cam.setAltitude(50);
    vs.addGlyph(circle);
    vsm.repaint();

    AnimationManager am = vsm.getAnimationManager();

    for (int i = 0; i < 4; ++i) {
      Animation anim =
          am.getAnimationFactory()
              .createAnimation(
                  3000,
                  1.0,
                  Animation.RepeatBehavior.LOOP,
                  circle,
                  Animation.Dimension.POSITION,
                  new DefaultTimingHandler() {
                    public void timingEvent(
                        float fraction, Object subject, Animation.Dimension dim) {
                      Glyph g = (Glyph) subject;
                      g.moveTo(100 - (double) 600 * fraction, 0);
                    }
                  },
                  new SplineInterpolator(0.7f, 0.1f, 0.3f, 0.9f));
      am.startAnimation(anim, false);
    }

    Animation anim =
        am.getAnimationFactory()
            .createAnimation(
                8000,
                1.0,
                Animation.RepeatBehavior.LOOP,
                circle,
                Animation.Dimension.FILLCOLOR,
                new DefaultTimingHandler() {
                  public void timingEvent(float fraction, Object subject, Animation.Dimension dim) {
                    Glyph g = (Glyph) subject;
                    g.setColor(new Color(0, 0, Float.valueOf(255 * fraction).intValue()));
                  }
                });
    am.startAnimation(anim, false);

    Animation animSize =
        am.getAnimationFactory()
            .createAnimation(
                4000,
                1.0,
                Animation.RepeatBehavior.LOOP,
                circle,
                Animation.Dimension.SIZE,
                new DefaultTimingHandler() {
                  public void timingEvent(float fraction, Object subject, Animation.Dimension dim) {
                    Glyph g = (Glyph) subject;
                    g.sizeTo(40 + 60 * fraction);
                  }
                });
    am.startAnimation(animSize, false);
  }
示例#7
0
 public void actionPerformed(ActionEvent e) {
   if (e.getSource() == updateButton) {
     camera.zoom = Integer.parseInt(zoomField.getText());
   }
 }