예제 #1
0
 /**
  * This method will do the actual removing and adding of GameObjects at the end of a gameloop
  * pass.
  */
 private void cleanupObjectlists() {
   Iterator<GameObject> it = items.iterator();
   while (it.hasNext()) {
     GameObject go = it.next();
     if (!go.isActive()) {
       deleteObjectAlarms(go);
       it.remove();
     }
   }
   for (int i = 0; i < newItems.size(); i++) {
     // note: always moving the first element of newItems ensures same
     // order
     GameObject item = newItems.remove(0);
     if (item.getDepth() > 0) {
       float d = item.getDepth();
       // move index to position of first element having smaller depth
       int index = 0;
       while (index < items.size()) {
         if (items.get(index).getDepth() < d) {
           break;
         }
         index++;
       }
       items.add(index, item);
     } else {
       // just add to the back of the list
       items.add(item);
     }
   }
 }
예제 #2
0
 /**
  * Remove all GameObject instances of given class type.
  *
  * @param type De class type of the instances to be removed
  */
 public <T> void deleteAllGameObjectsOfType(Class<T> type) {
   for (int i = 0; i < items.size(); i++) {
     GameObject go = items.get(i);
     if (go.getClass() == type) {
       go.clearActive();
     }
   }
 }
예제 #3
0
  /**
   * Use this function to get the angle between you and another object. For example: You can use
   * this function to check if you approaching another object from the left or right. Direction 0
   * points up, directions go clockwise, so 90 is right, etc.
   *
   * @param object an instance of another object to calculate the angle for.
   * @return the angle of the object or 0 if the object is null.
   */
  public final double getAngle(GameObject object) {

    double deltaX = object.getFullX() - getFullX();
    double deltaY = object.getFullY() - getFullY();

    if (deltaX >= 0 || deltaY >= 0) {
      return Math.toDegrees(Math.atan2(deltaX, deltaX)) + 90;
    } else {
      return Math.toDegrees((Math.atan2(deltaY, deltaX))) + 450;
    }
  }
예제 #4
0
  /**
   * This method is like a 'postponed constructor'. It is called automatically by the GameEngine
   * when all necessary Android resources are ready. At that point you can set up your game.<br>
   * Don't call this method yourself (or everything will be done twice!)<br>
   * You can perform any initialization the game needs to before starting to run, like:
   *
   * <p>
   *
   * <ul>
   *   <li>Create instances of GameObjects.
   *   <li>Create a tile environment
   *   <li>Set viewport options
   *   <li>Configure background image, background color, OnScreenButtons, TouchInput
   *   <li>etc.
   * </ul>
   *
   * <p>Override this method inside your game class that extends GameEngine. Call super.initialize()
   * at the very start.
   */
  protected void initialize() {
    printDebugInfo("GameEngine", "Intializing...");

    if (Sprite.loadDelayedSprites != null) {
      for (Sprite sprite : Sprite.loadDelayedSprites) {
        sprite.initialize();
      }
    }
    Sprite.loadDelayedSprites = null;

    for (GameObject item : items) {
      item.intializeGameObject();
    }
  }
예제 #5
0
 /** Calculates if a GameObject is outside the world or not. */
 private void calculateOutsideWorld(GameObject go) {
   if (go instanceof MoveableGameObject) {
     if (!go.isActive()) {
       return;
     }
     if (go.getX() - go.getFrameWidth() < 0
         || go.getX() > mapWidth
         || go.getY() - go.getFrameHeight() < 0
         || go.getY() > mapHeight) {
       ((MoveableGameObject) go).outsideWorld();
     }
   }
 }
예제 #6
0
 /**
  * Add a GameObject to the game. New GameObjects will become active in the next pass of the
  * gameloop. <br>
  * Layerposition may not work very well as yet, still under construction.<br>
  *
  * @param gameObject The GameObject that will be added to the game. Should have either GameObject
  *     or MovableGameObject as it's parent.
  * @param layerposition The layerposition when this object is drawed. <b>Between 0 and 1 (float).
  *     </b> 1 front, 0 back
  */
 public final void addGameObject(GameObject gameObject, float layerposition) {
   gameObject.setDepth(layerposition);
   newItems.add(gameObject);
 }
예제 #7
0
 /**
  * Add a GameObject to the game. New GameObjects will become active in the next pass of the
  * gameloop. <br>
  * Layerposition may not work very well as yet, still under construction.<br>
  *
  * @param gameObject The GameObject that will be added to the game. Should have either GameObject
  *     or MovableGameObject as it's parent.
  * @param x The X spawnlocation when this object is created
  * @param y The Y spawnlocation when this object is created
  * @param layerposition The layerposition when this object is drawed. <b>Between 0 and 1 (float).
  *     </b> 1 front, 0 back
  */
 public final void addGameObject(GameObject gameObject, int x, int y, float layerposition) {
   gameObject.setStartPosition(x, y);
   gameObject.jumpToStartPosition();
   gameObject.setDepth(layerposition);
   newItems.add(gameObject);
 }
예제 #8
0
 /**
  * Add a GameObject to the game. New GameObjects will become active in the next pass of the
  * gameloop.<br>
  *
  * @param gameObject The GameObject that will be added to the game. Should have either GameObject
  *     or MovableGameObject as it's parent.
  * @param x The X spawnlocation when this object is created
  * @param y The Y spawnlocation when this object is created
  */
 public final void addGameObject(GameObject gameObject, int x, int y) {
   gameObject.setStartPosition(x, y);
   gameObject.jumpToStartPosition();
   newItems.add(gameObject);
 }
예제 #9
0
 /**
  * * Delete a GameObject from the game.
  *
  * @param gameObject The GameObject instance to be removed
  */
 public final void deleteGameObject(GameObject gameObject) {
   gameObject.clearActive();
 }