How to use

tick

method

in

ch.logixisland.anuto.engine.logic.loop.TickTimer

public boolean tick() {
  boolean ret = false;
  if (mTimer.tick()) {
    if (mSequenceIndex >= mSequence.length - 1) {
      mSequenceIndex = 0;
      ret = true;
    } else {
      mSequenceIndex++;
    }
  }
  return ret;
}

@Override
public void tick() {
  super.tick();
  if (mBuilt && !mReloaded && mReloadTimer.tick()) {
    mReloaded = true;
  }
}

public void tick() {
  if (mFinished) {
    return;
  }
  if (!mUpdateTimer.tick()) {
    return;
  }
  checkForExitedEnemies();
  checkForEnteredEnemies();
}

public void tick() {
  if (mUpdateTimer.tick()) {
    if (mTarget != null && mTower.getDistanceTo(mTarget) > mTower.getRange()) {
      setTarget(null);
    }
    if (mTarget == null || !mLockTarget) {
      nextTarget();
    }
  }
}

@Override
public void tick() {
  super.tick();
  if (mState == State.NotStarted) {
    mState = State.Active;
    effectBegin();
  }
  if (mTimer != null && mTimer.tick()) {
    mState = State.Ended;
    effectEnd();
    remove();
  }
}

@Override
protected void tick() {
  if (mSimulationTickTimer.tick()) {
    tryUpgradeTower();
    tryEnhanceTower();
    tryBuildTower();
    tryStartNextWave();
  }
  if (mSaveAndLoadTimer.tick()) {
    saveAndLoad();
  }
}

  @Override
  public void tick() {
    mReferenceSprite.tick();
    if (mHealTimer.tick()) {
      mHealing = true;
    }
    if (mHealing) {
      mRotateFunction.step();
      mScaleFunction.step();
      mAngle += mRotateFunction.getValue();
      mScale = mScaleFunction.getValue();
      if (mScaleFunction.getPosition() >= GameEngine.TARGET_FRAME_RATE * mHealDuration) {
        mHealedEnemies.clear();
        mDropEffect = true;
        mHealing = false;
        mAngle = 0;
        mScale = 1f;
        mRotateFunction.reset();
        mScaleFunction.reset();
      }
    } else {
      mDropEffect = false;
    }
  }
}

@Override
public void tick() {
  super.tick();
  if (isReloaded() && mUpdateTimer.tick() && !getPossibleTargets().isEmpty()) {
    mShooting = true;
    setReloaded(false);
  }
  if (mShooting) {
    mCanonOffset += CANON_OFFSET_STEP;
    if (mCanonOffset >= CANON_OFFSET_MAX) {
      mShooting = false;
      for (Vector2 target : mTargets) {
        Vector2 position = getPosition().add(Vector2.polar(SHOT_SPAWN_OFFSET, getAngleTo(target)));
        getGameEngine().add(new GlueShot(this, position, target, mGlueIntensity, mSettings.getFloat("glueDuration")));
      }
    }
  } else if (mCanonOffset > 0f) {
    mCanonOffset -= CANON_OFFSET_STEP;
  }
}

@Override
public void tick() {
  super.tick();
  mAimer.tick();
  if (mRocket == null && mRocketLoadTimer.tick()) {
    mRocket = new Rocket(this, getPosition(), getDamage(), mExplosionRadius);
    mRocket.setAngle(mAngle);
    getGameEngine().add(mRocket);
  }
  if (mAimer.getTarget() != null) {
    mAngle = getAngleTo(mAimer.getTarget());
    if (mRocket != null) {
      mRocket.setAngle(mAngle);
      if (isReloaded()) {
        mRocket.setTarget(mAimer.getTarget());
        mRocket.setEnabled(true);
        mRocket = null;
        mSound.play();
        setReloaded(false);
      }
    }
  }
}

@Override
public void tick() {
  super.tick();
  if (mFlying) {
    mAngle += mRotationStep;
    mHeightScalingFunction.step();
    if (mHeightScalingFunction.getPosition() >= GameEngine.TARGET_FRAME_RATE * TIME_TO_TARGET) {
      getGameEngine().remove(mSpriteFlying);
      getGameEngine().add(mSpriteMine);
      mFlying = false;
      setSpeed(0f);
    }
  } else if (mUpdateTimer.tick()) {
    StreamIterator<Enemy> enemiesInRange = getGameEngine().getEntitiesByType(Types.ENEMY)
        .filter(inRange(getPosition(), TRIGGER_RADIUS))
        .cast(Enemy.class)
        .filter(new Predicate<Enemy>() {
          @Override
          public boolean apply(Enemy value) {
            return !(value instanceof Flyer);
          }
        });
    if (!enemiesInRange.isEmpty()) {
      getGameEngine().add(new Explosion(getOrigin(), getPosition(), mDamage, mRadius));
      this.remove();
    }
  }
}