private void setCurrent(int index, TrackEntry entry) {
    TrackEntry current = expandToIndex(index);
    if (current != null) {
      TrackEntry previous = current.previous;
      current.previous = null;

      if (current.listener != null) current.listener.end(index);
      for (int i = 0, n = listeners.size; i < n; i++) listeners.get(i).end(index);

      entry.mixDuration = data.getMix(current.animation, entry.animation);
      if (entry.mixDuration > 0) {
        entry.mixTime = 0;
        // If a mix is in progress, mix from the closest animation.
        if (previous != null && current.mixTime / current.mixDuration < 0.5f) {
          entry.previous = previous;
          previous = current;
        } else entry.previous = current;
      } else trackEntryPool.free(current);

      if (previous != null) trackEntryPool.free(previous);
    }

    tracks.set(index, entry);

    if (entry.listener != null) entry.listener.start(index);
    for (int i = 0, n = listeners.size; i < n; i++) listeners.get(i).start(index);
  }
 public void defineSnapperViews() {
   if (logic.level == null) return;
   SnapperView view;
   int i;
   int j;
   int state;
   synchronized (activeSnappers) {
     for (i = 0; i < activeSnappers.size; i++) removeActor(activeSnappers.get(i));
     snapperViewPool.free(activeSnappers);
     activeSnappers.clear();
     int w = logic.width;
     int h = logic.height;
     for (i = 0; i < Snappers.WIDTH; i++)
       for (j = 0; j < Snappers.HEIGHT; j++)
         if ((state = logic.snappers.getSnapper(i, j)) > 0) {
           view = snapperViewPool.obtain();
           view.set(i, j, state);
           view.setRandomStart(0, 0, w, h, SNAPPER_WARM_TIME);
           activeSnappers.add(view);
           addActor(view);
           view.setListener(snapperAnimationListener);
           view.setAnimFn(snapperAnimFn);
         }
   }
 }
Exemple #3
0
 public boolean remove() {
   if (super.remove()) {
     pool.free(this);
     return true;
   }
   return false;
 }
  /** @param last May be null. */
  private TrackEntry trackEntry(
      int trackIndex, Animation animation, boolean loop, TrackEntry last) {
    TrackEntry entry = trackEntryPool.obtain();
    entry.trackIndex = trackIndex;
    entry.animation = animation;
    entry.loop = loop;

    entry.eventThreshold = 0;
    entry.attachmentThreshold = 0;
    entry.drawOrderThreshold = 0;

    entry.animationStart = 0;
    entry.animationEnd = animation.getDuration();
    entry.animationLast = -1;
    entry.nextAnimationLast = -1;

    entry.delay = 0;
    entry.trackTime = 0;
    entry.trackLast = -1;
    entry.nextTrackLast = -1;
    entry.trackEnd = Float.MAX_VALUE;
    entry.timeScale = 1;

    entry.alpha = 1;
    entry.mixAlpha = 1;
    entry.mixTime = 0;
    entry.mixDuration = last == null ? 0 : data.getMix(last.animation, animation);
    return entry;
  }
  @Override
  public void draw(SpriteBatch spriteBatch) {
    delta = Math.min(0.06f, Gdx.graphics.getDeltaTime());

    this.setOrigin(0, 0);
    for (int i = particles.size - 1; i >= 0; i--) {
      Particle particle = particles.get(i);
      if (particle.life > 0) {
        updateParticle(particle);
        float dx = this.getWidth() / 2 * particle.scale;
        float dy = this.getHeight() / 2 * particle.scale;
        this.setColor(1, 1, 1, Math.max(particle.life / this.life, 0));
        this.setScale(particle.scale);
        this.setPosition(particle.position.x - dx, particle.position.y - dy);
        if (!(particle.position.y - dy >= -10 && particle.position.y - dy <= 10)
            && !(particle.position.x - dx >= -10 && particle.position.x - dx <= 10)) {
          super.draw(spriteBatch);
        } else {
          particle.life = 0;
        }
      } else {
        particles.removeIndex(i);
        freeParticles.free(particle);
      }
    }
  }
 private void freeAll(TrackEntry entry) {
   while (entry != null) {
     TrackEntry next = entry.next;
     trackEntryPool.free(entry);
     entry = next;
   }
 }
Exemple #7
0
  private void drawRecursive(Actor actor) {
    if (!invisibleActors && !actor.isVisible()) return;

    if (allActors) actor.debug();

    if (actor.getDebug()) {
      actor.getDebugRects(debugRects);
      for (DebugRect debugRect : debugRects) drawRect(actor, debugRect);
      debugRects.clear();
      debugRectPool.freeAll(usedRects);
      usedRects.clear();
    }

    boolean draw = true;
    Rectangle scissorBounds = null;
    if (actor instanceof Group) scissorBounds = ((Group) actor).getScissorBounds();
    if (scissorBounds != null) {
      shapes.flush();
      draw = ScissorStack.pushScissors(scissorBounds);
    }
    if (draw) {
      // Children are still rendered, even if the group has no debugging enabled.
      if (actor instanceof Group) {
        Group group = (Group) actor;
        for (Actor child : group.getChildren()) drawRecursive(child);
      }

      if (scissorBounds != null) {
        shapes.flush();
        ScissorStack.popScissors();
      }
    }
  }
 @Override
 public boolean handleMessage(Telegram telegram) {
   switch (telegram.message) {
     case PF_RESPONSE: // PathFinderQueue will call us directly, no need to register for this
       // message
       if (PathFinderRequestControl.DEBUG) {
         @SuppressWarnings("unchecked")
         PathFinderQueue<HierarchicalTiledNode> pfQueue =
             (PathFinderQueue<HierarchicalTiledNode>) telegram.sender;
         System.out.println("pfQueue.size = " + pfQueue.size());
       }
       MyPathFinderRequest pfr = (MyPathFinderRequest) telegram.extraInfo;
       TiledSmoothableGraphPath<HierarchicalTiledNode> path = paths[pfr.pathIndex];
       int n = path.getCount();
       if (n > 0 && pfr.pathFound && pfr.endNode != path.get(n - 1)) {
         pfr.startNode = path.get(n - 1);
         if (pfr.pathIndex + 1 < paths.length) {
           pfr.pathIndex++;
         }
         pfr.resultPath = paths[pfr.pathIndex];
         pfr.changeStatus(PathFinderRequest.SEARCH_NEW);
         numPaths = pfr.pathIndex;
       } else {
         requestPool.free(pfr);
         numPaths = pfr.pathIndex + 1;
       }
       break;
   }
   return true;
 }
Exemple #9
0
 /**
  * Obtain a {@link btCollisionShape} based on the specified nodes, which can be used for a static
  * body but not for a dynamic body. Depending on the specified nodes the result will be either a
  * {@link btBvhTriangleMeshShape} or a {@link btCompoundShape} of multiple
  * btBvhTriangleMeshShape's. Where possible, the same btBvhTriangleMeshShape will be reused if
  * multiple nodes use the same (mesh) part. The node transformation (translation and rotation)
  * will be included, but scaling will be ignored.
  *
  * @param nodes The nodes for which to obtain a node, typically this would be: `model.nodes`.
  * @return The obtained shape, if you're using reference counting then you can release the shape
  *     when no longer needed.
  */
 public static btCollisionShape obtainStaticNodeShape(final Array<Node> nodes) {
   getShapeParts(nodes, shapePartArray, 0, shapePartPool);
   btCollisionShape result = obtainStaticShape(shapePartArray);
   shapePartPool.freeAll(shapePartArray);
   shapePartArray.clear();
   return result;
 }
 public void addParticle(Vector2 position, Vector2 velocity, float life, float scale) {
   if (particles.size > maxParticle) return;
   if (Gdx.graphics.getFramesPerSecond() < 25 && !(this instanceof ExplosionParticleEmitter))
     return;
   Particle particle = freeParticles.obtain();
   particle.setup(position, velocity, life, scale);
   particles.add(particle);
 }
Exemple #11
0
 public static btCollisionShape obtainStaticNodeShape(
     final Node node, final boolean applyTransform) {
   getShapeParts(node, applyTransform, shapePartArray, 0, shapePartPool);
   btCollisionShape result = obtainStaticShape(shapePartArray);
   shapePartPool.freeAll(shapePartArray);
   shapePartArray.clear();
   return result;
 }
Exemple #12
0
 /** End applying multiple animations to the instance and update it to reflect the changes. */
 protected void end() {
   if (!applying) throw new GdxRuntimeException("You must call begin() first");
   for (Entry<Node, Transform> entry : transforms.entries()) {
     entry.value.toMatrix4(entry.key.localTransform);
     transformPool.free(entry.value);
   }
   transforms.clear();
   target.calculateTransforms();
   applying = false;
 }
Exemple #13
0
  @Override
  public void onGamepadUpdated(int index) {
    Gamepad gamepad = Gamepad.getGamepad(index);
    GwtController controller = controllerMap.get(index);
    if (gamepad != null && controller != null) {
      // Determine what changed
      JsArrayNumber axes = gamepad.getAxes();
      JsArrayNumber buttons = gamepad.getButtons();
      synchronized (eventQueue) {
        for (int i = 0, j = axes.length(); i < j; i++) {
          float oldAxis = controller.getAxis(i);
          float newAxis = (float) axes.get(i);
          if (oldAxis != newAxis) {
            GwtControllerEvent event = eventPool.obtain();
            event.type = GwtControllerEvent.AXIS;
            event.controller = controller;
            event.code = i;
            event.amount = newAxis;
            eventQueue.add(event);
          }
        }
        for (int i = 0, j = buttons.length(); i < j; i++) {
          float oldButton = controller.getButtonAmount(i);
          float newButton = (float) buttons.get(i);
          if (oldButton != newButton) {
            if ((oldButton < 0.5f && newButton < 0.5f)
                || (oldButton >= 0.5f && newButton >= 0.5f)) {
              controller.buttons.put(i, newButton);
              continue;
            }

            GwtControllerEvent event = eventPool.obtain();
            event.type =
                newButton >= 0.5f ? GwtControllerEvent.BUTTON_DOWN : GwtControllerEvent.BUTTON_UP;
            event.controller = controller;
            event.code = i;
            event.amount = newButton;
            eventQueue.add(event);
          }
        }
      }
    }
  }
  /** Set the current animation. Any queued animations are cleared. */
  public TrackEntry setAnimation(int trackIndex, Animation animation, boolean loop) {
    TrackEntry current = expandToIndex(trackIndex);
    if (current != null) freeAll(current.next);

    TrackEntry entry = trackEntryPool.obtain();
    entry.animation = animation;
    entry.loop = loop;
    entry.endTime = animation.getDuration();
    setCurrent(trackIndex, entry);
    return entry;
  }
Exemple #15
0
  protected void postTap(int x, int y) {
    synchronized (this) {
      TouchEvent event = usedTouchEvents.obtain();
      event.timeStamp = System.nanoTime();
      event.pointer = 0;
      event.x = x;
      event.y = y;
      event.type = TouchEvent.TOUCH_DOWN;
      touchEvents.add(event);

      event = usedTouchEvents.obtain();
      event.timeStamp = System.nanoTime();
      event.pointer = 0;
      event.x = x;
      event.y = y;
      event.type = TouchEvent.TOUCH_UP;
      touchEvents.add(event);
    }
    Gdx.app.getGraphics().requestRendering();
  }
Exemple #16
0
 @Override
 public void onGamepadDisconnected(int index) {
   GwtController controller = controllerMap.remove(index);
   if (controller != null) {
     synchronized (eventQueue) {
       GwtControllerEvent event = eventPool.obtain();
       event.type = GwtControllerEvent.DISCONNECTED;
       event.controller = controller;
       eventQueue.add(event);
     }
   }
 }
Exemple #17
0
 @Override
 public void onGamepadConnected(int index) {
   Gamepad gamepad = Gamepad.getGamepad(index);
   GwtController controller = new GwtController(gamepad.getIndex(), gamepad.getId());
   controllerMap.put(index, controller);
   synchronized (eventQueue) {
     GwtControllerEvent event = eventPool.obtain();
     event.type = GwtControllerEvent.CONNECTED;
     event.controller = controller;
     eventQueue.add(event);
   }
 }
  private void requestNewPathFinding(
      HierarchicalTiledNode startNode, HierarchicalTiledNode endNode, int pathIndex) {
    TiledSmoothableGraphPath<HierarchicalTiledNode> path = paths[pathIndex];

    MyPathFinderRequest pfRequest = requestPool.obtain();
    pfRequest.startNode = startNode;
    pfRequest.endNode = endNode;
    pfRequest.heuristic = heuristic;
    pfRequest.resultPath = path;
    pfRequest.pathIndex = pathIndex;
    pfRequest.responseMessageCode = PF_RESPONSE;
    MessageManager.getInstance().dispatchMessage(this, PF_REQUEST, pfRequest);
  }
  public void clearTrack(int trackIndex) {
    if (trackIndex >= tracks.size) return;
    TrackEntry current = tracks.get(trackIndex);
    if (current == null) return;

    if (current.listener != null) current.listener.end(trackIndex);
    for (int i = 0, n = listeners.size; i < n; i++) listeners.get(i).end(trackIndex);

    tracks.set(trackIndex, null);

    freeAll(current);
    if (current.previous != null) trackEntryPool.free(current.previous);
  }
  public void apply(Skeleton skeleton) {
    Array<Event> events = this.events;
    int listenerCount = listeners.size;

    for (int i = 0; i < tracks.size; i++) {
      TrackEntry current = tracks.get(i);
      if (current == null) continue;

      events.size = 0;

      float time = current.time;
      float lastTime = current.lastTime;
      float endTime = current.endTime;
      boolean loop = current.loop;
      if (!loop && time > endTime) time = endTime;

      TrackEntry previous = current.previous;
      if (previous == null)
        current.animation.mix(skeleton, lastTime, time, loop, events, current.mix);
      else {
        float previousTime = previous.time;
        if (!previous.loop && previousTime > previous.endTime) previousTime = previous.endTime;
        previous.animation.apply(skeleton, previousTime, previousTime, previous.loop, null);

        float alpha = current.mixTime / current.mixDuration * current.mix;
        if (alpha >= 1) {
          alpha = 1;
          trackEntryPool.free(previous);
          current.previous = null;
        }
        current.animation.mix(skeleton, lastTime, time, loop, events, alpha);
      }

      for (int ii = 0, nn = events.size; ii < nn; ii++) {
        Event event = events.get(ii);
        if (current.listener != null) current.listener.event(i, event);
        for (int iii = 0; iii < listenerCount; iii++) listeners.get(iii).event(i, event);
      }

      // Check if completed the animation or a loop iteration.
      if (loop ? (lastTime % endTime > time % endTime) : (lastTime < endTime && time >= endTime)) {
        int count = (int) (time / endTime);
        if (current.listener != null) current.listener.complete(i, count);
        for (int ii = 0, nn = listeners.size; ii < nn; ii++) listeners.get(ii).complete(i, count);
      }

      current.lastTime = current.time;
    }
  }
 public static <T extends GameObject> void removeOutOfBounds(
     Pool<T> pool, Array<T> gos, Rectangle bounds) {
   float minX = bounds.x;
   float maxX = minX + bounds.width;
   float minY = bounds.y;
   float maxY = minY + bounds.height;
   for (int i = gos.size - 1; i >= 0; i--) {
     T go = gos.get(i);
     if (go.getX() >= maxX
         || go.getX() + go.width <= minX
         || go.getY() >= maxY
         || go.getY() + go.getHeight() <= minY) {
       gos.removeIndex(i);
       pool.free(go);
     }
   }
 }
Exemple #22
0
  public void remove(Array<RobotNinjas> robotNinjases) {
    if (body.getUserData() == Constants.deadID) {
      robotNinjases.removeValue(this, true);
      robotNinjasPool.free(this);
    }

    if (body.getPosition().x < 0 - width) {
      body.setUserData(Constants.deadID);
      if (!dead) {
        Constants.currentScoreValue++;
        Constants.standardVelocity.x += Constants.globalAcceleration;
        Constants.ninjaVelocity.x += Constants.globalAcceleration;
        Constants.globalAcceleration -= Constants.globalAccelerationDecline;
      }

      dead = true;
    }
  }
Exemple #23
0
 /**
  * Helper method to apply one animation to either an objectmap for blending or directly to the
  * bones.
  */
 protected static void applyAnimation(
     final ObjectMap<Node, Transform> out,
     final Pool<Transform> pool,
     final float alpha,
     final Animation animation,
     final float time) {
   for (final NodeAnimation nodeAnim : animation.nodeAnimations) {
     final Node node = nodeAnim.node;
     node.isAnimated = true;
     // Find the keyframe(s)
     final int n = nodeAnim.keyframes.size - 1;
     int first = 0, second = -1;
     for (int i = 0; i < n; i++) {
       if (time >= nodeAnim.keyframes.get(i).keytime
           && time <= nodeAnim.keyframes.get(i + 1).keytime) {
         first = i;
         second = i + 1;
         break;
       }
     }
     // Apply the first keyframe:
     final Transform transform = tmpT;
     final NodeKeyframe firstKeyframe = nodeAnim.keyframes.get(first);
     transform.set(firstKeyframe.translation, firstKeyframe.rotation, firstKeyframe.scale);
     // Lerp the second keyframe
     if (second > first) {
       final NodeKeyframe secondKeyframe = nodeAnim.keyframes.get(second);
       final float t =
           (time - firstKeyframe.keytime) / (secondKeyframe.keytime - firstKeyframe.keytime);
       transform.lerp(
           secondKeyframe.translation, secondKeyframe.rotation, secondKeyframe.scale, t);
     }
     // Apply the transform, either directly to the bone or to out when blending
     if (out == null) transform.toMatrix4(node.localTransform);
     else {
       if (out.containsKey(node)) {
         if (alpha == 1.f) out.get(node).set(transform);
         else out.get(node).lerp(transform, alpha);
       } else {
         out.put(node, pool.obtain().set(transform));
       }
     }
   }
 }
  /**
   * Adds an animation to be played delay seconds after the current or last queued animation.
   *
   * @param delay May be <= 0 to use duration of previous animation minus any mix duration plus the
   *     negative delay.
   */
  public TrackEntry addAnimation(int trackIndex, Animation animation, boolean loop, float delay) {
    TrackEntry entry = trackEntryPool.obtain();
    entry.animation = animation;
    entry.loop = loop;
    entry.endTime = animation.getDuration();

    TrackEntry last = expandToIndex(trackIndex);
    if (last != null) {
      while (last.next != null) last = last.next;
      last.next = entry;
    } else tracks.set(trackIndex, entry);

    if (delay <= 0) {
      if (last != null) delay += last.endTime - data.getMix(last.animation, animation);
      else delay = 0;
    }
    entry.delay = delay;

    return entry;
  }
Exemple #25
0
 public void end() {
   sorter.sort(camera, renderables);
   context.begin();
   Shader currentShader = null;
   for (int i = 0; i < renderables.size; i++) {
     final Renderable renderable = renderables.get(i);
     if (currentShader != renderable.shader) {
       if (currentShader != null) currentShader.end();
       currentShader = renderable.shader;
       currentShader.begin(camera, context);
     }
     currentShader.render(renderable);
   }
   if (currentShader != null) currentShader.end();
   context.end();
   renderablesPool.freeAll(reuseableRenderables);
   reuseableRenderables.clear();
   renderables.clear();
   camera = null;
 }
Exemple #26
0
 public static void getShapeParts(
     final Node node,
     final boolean applyTransform,
     final Array<ShapePart> out,
     final int offset,
     final Pool<ShapePart> pool) {
   final Matrix4 transform = applyTransform ? node.localTransform : idt;
   if (node.parts.size > 0) {
     ShapePart part = null;
     for (int i = offset, n = out.size; i < n; i++) {
       final ShapePart p = out.get(i);
       if (Arrays.equals(p.transform.val, transform.val)) {
         part = p;
         break;
       }
     }
     if (part == null) {
       part = pool.obtain();
       part.parts.clear();
       part.transform.set(transform);
       out.add(part);
     }
     for (int i = 0, n = node.parts.size; i < n; i++) part.parts.add(node.parts.get(i).meshPart);
   }
   if (node.hasChildren()) {
     final boolean transformed = applyTransform && !Arrays.equals(transform.val, idt.val);
     final int o = transformed ? out.size : offset;
     getShapeParts(node.getChildren(), out, o, pool);
     if (transformed) {
       for (int i = o, n = out.size; i < n; i++) {
         final ShapePart part = out.get(i);
         tmpM.set(part.transform);
         part.transform.set(transform).mul(tmpM);
       }
     }
   }
 }
Exemple #27
0
  @Override
  public boolean onKey(View v, int keyCode, android.view.KeyEvent e) {
    for (int i = 0, n = keyListeners.size(); i < n; i++)
      if (keyListeners.get(i).onKey(v, keyCode, e)) return true;

    synchronized (this) {
      KeyEvent event = null;

      if (e.getKeyCode() == android.view.KeyEvent.KEYCODE_UNKNOWN
          && e.getAction() == android.view.KeyEvent.ACTION_MULTIPLE) {
        String chars = e.getCharacters();
        for (int i = 0; i < chars.length(); i++) {
          event = usedKeyEvents.obtain();
          event.keyCode = 0;
          event.keyChar = chars.charAt(i);
          event.type = KeyEvent.KEY_TYPED;
          keyEvents.add(event);
        }
        return false;
      }

      char character = (char) e.getUnicodeChar();
      // Android doesn't report a unicode char for back space. hrm...
      if (keyCode == 67) character = '\b';

      switch (e.getAction()) {
        case android.view.KeyEvent.ACTION_DOWN:
          event = usedKeyEvents.obtain();
          event.keyChar = 0;
          event.keyCode = e.getKeyCode();
          event.type = KeyEvent.KEY_DOWN;

          // Xperia hack for circle key. gah...
          if (keyCode == android.view.KeyEvent.KEYCODE_BACK && e.isAltPressed()) {
            keyCode = Keys.BUTTON_CIRCLE;
            event.keyCode = keyCode;
          }

          keyEvents.add(event);
          keys.put(event.keyCode, null);
          break;
        case android.view.KeyEvent.ACTION_UP:
          event = usedKeyEvents.obtain();
          event.keyChar = 0;
          event.keyCode = e.getKeyCode();
          event.type = KeyEvent.KEY_UP;
          // Xperia hack for circle key. gah...
          if (keyCode == android.view.KeyEvent.KEYCODE_BACK && e.isAltPressed()) {
            keyCode = Keys.BUTTON_CIRCLE;
            event.keyCode = keyCode;
          }
          keyEvents.add(event);

          event = usedKeyEvents.obtain();
          event.keyChar = character;
          event.keyCode = 0;
          event.type = KeyEvent.KEY_TYPED;
          keyEvents.add(event);

          if (keyCode == Keys.BUTTON_CIRCLE) keys.remove(Keys.BUTTON_CIRCLE);
          else keys.remove(e.getKeyCode());
      }
      app.getGraphics().requestRendering();
    }

    // circle button on Xperia Play shouldn't need catchBack == true
    if (keyCode == Keys.BUTTON_CIRCLE) return true;
    if (catchBack && keyCode == android.view.KeyEvent.KEYCODE_BACK) return true;
    if (catchMenu && keyCode == android.view.KeyEvent.KEYCODE_MENU) return true;
    return false;
  }
Exemple #28
0
  void processEvents() {
    synchronized (this) {
      justTouched = false;

      if (processor != null) {
        final InputProcessor processor = this.processor;

        int len = keyEvents.size();
        for (int i = 0; i < len; i++) {
          KeyEvent e = keyEvents.get(i);
          currentEventTimeStamp = e.timeStamp;
          switch (e.type) {
            case KeyEvent.KEY_DOWN:
              processor.keyDown(e.keyCode);
              break;
            case KeyEvent.KEY_UP:
              processor.keyUp(e.keyCode);
              break;
            case KeyEvent.KEY_TYPED:
              processor.keyTyped(e.keyChar);
          }
          usedKeyEvents.free(e);
        }

        len = touchEvents.size();
        for (int i = 0; i < len; i++) {
          TouchEvent e = touchEvents.get(i);
          currentEventTimeStamp = e.timeStamp;
          switch (e.type) {
            case TouchEvent.TOUCH_DOWN:
              processor.touchDown(e.x, e.y, e.pointer, Buttons.LEFT);
              justTouched = true;
              break;
            case TouchEvent.TOUCH_UP:
              processor.touchUp(e.x, e.y, e.pointer, Buttons.LEFT);
              break;
            case TouchEvent.TOUCH_DRAGGED:
              processor.touchDragged(e.x, e.y, e.pointer);
          }
          usedTouchEvents.free(e);
        }
      } else {
        int len = touchEvents.size();
        for (int i = 0; i < len; i++) {
          TouchEvent e = touchEvents.get(i);
          if (e.type == TouchEvent.TOUCH_DOWN) justTouched = true;
          usedTouchEvents.free(e);
        }

        len = keyEvents.size();
        for (int i = 0; i < len; i++) {
          usedKeyEvents.free(keyEvents.get(i));
        }
      }

      if (touchEvents.size() == 0) {
        for (int i = 0; i < deltaX.length; i++) {
          deltaX[0] = 0;
          deltaY[0] = 0;
        }
      }

      keyEvents.clear();
      touchEvents.clear();
    }
  }
 public void dispose() {
   particles.clear();
   freeParticles.clear();
 }
Exemple #30
0
 public static SmallFish obtainSmallFish(TextureRegion region) {
   SmallFish fish = pool.obtain();
   fish.setRegion(region);
   fish.setPosition(0, 0);
   return fish;
 }