Erstellen Sie einen einfachen countdown in der Bearbeitung

Eine einfache Möglichkeit ist, um manuell verfolgen, von der Zeit mit millis().

Verwenden Sie zwei Variablen:

1. eine zum speichern verstrichene Zeit
2. eine zum speichern der wait/delay-Zeit, die Sie brauchen

In der draw () - Methode, die Sie würde überprüfen, ob die Differenz zwischen der aktuellen Zeit (in millis.) und die vorher gespeicherte Zeit größer(oder gleich) der Verzögerung.

Wenn ja, wäre das Sie cue zu tun, was für die Verzögerung gegeben und aktualisieren die gespeicherte Zeit:

int time;
int wait = 1000;

void setup(){
  time = millis();//store the current time
}
void draw(){
  //check the difference between now and the previously stored time is greater than the wait interval
  if(millis() - time >= wait){
    println("tick");//if it is, do something
    time = millis();//also update the stored time
  }
}

Hier ist eine leichte variation des updates eine 'Nadel' auf dem Bildschirm:

int time;
int wait = 1000;

boolean tick;

void setup(){
  time = millis();//store the current time
  smooth();
  strokeWeight(3);
}
void draw(){
  //check the difference between now and the previously stored time is greater than the wait interval
  if(millis() - time >= wait){
    tick = !tick;//if it is, do something
    time = millis();//also update the stored time
  }
  //draw a visual cue
  background(255);
  line(50,10,tick ? 10 : 90,90);
}

Je nach setup/Bedürfnissen können Sie wählen, um zu wickeln, so etwas in einer Klasse, die wiederverwendet werden können. Dies ist ein einfaches Verfahren, und sollte mit der Android-und JavaScript-Versionen als gut (auch wenn in javascript-Sie haben setInterval()).

Wenn Sie Interesse an der Verwendung von Java-Dienstprogramme, wie FrankieTheKneeMan suggeriert, es ist ein TimerTask Klasse zur Verfügung und ich bin sicher, es gibt viele Quellen/Beispiele gibt.

Können Sie ein demo-Gebrüll:

JS:

var time;
var wait = 1000;

var tick = false;

function setup(){
  time = millis();//store the current time
  smooth();
  strokeWeight(3);
}
function draw(){
  //check the difference between now and the previously stored time is greater than the wait interval
  if(millis() - time >= wait){
    tick = !tick;//if it is, do something
    time = millis();//also update the stored time
  }
  //draw a visual cue
  background(255);
  line(50,10,tick ? 10 : 90,90);
}

HTML:

<script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/0.4.4/p5.min.js"></script>

Update gibt Es viele Möglichkeiten, um Timer. Hier ist eine version, die verwendet einen Thread und fordert eine funktionierte definiert, die in der Skizze mit Namen. Dies ist nicht einen einfachen countdown. Gerade millis() wie oben erklärt, ist einfach genug, nur nicht sehr flexibel:

Timer timer;

void setup(){
  noStroke();

  //textSize(12);
  timer = new Timer(this,"onTimerTick","onTimerComplete");
  //start a timer for 10 seconds (10 * 1000 ms) with a tick every second (1000 ms) 
  timer.reset(10 * 1000,1000);
}

void draw(){
  background(0);
  drawTimer();
  //rect(0,0,timer.progress * width,height);
  //blendMode(DIFFERENCE);
  text("'1' = reset"+
     "\n'2' = cancel"+
     "\n'3' = pause"+
     "\n'4' = resume"+
     "\n"+(int)(timer.progress * 100)+"%",10,15);
}

void drawTimer(){
  pushStyle();
  noFill();
  stroke(255);
  strokeWeight(3);
  ellipse(450, 54,90,90);
  fill(192,0,0);
  noStroke();
  pushMatrix();
  translate(50,50);
  rotate(radians(-90));
  arc(0, 0, 90, 90, 0, timer.progress * TWO_PI, PIE);
  popMatrix();
  popStyle();
}

void keyPressed(){
  if(key == '1'){
    timer.reset(3000,10);
  }
  if(key == '2'){
    timer.cancel();
  }
  if(key == '3'){
    timer.pause();
  }
  if(key == '4'){
    timer.resume();
  }
}

public void onTimerTick(){
  println("tick",(int)(timer.progress * 100),"%");
}

public void onTimerComplete(){
  println("complete");
}

import java.lang.reflect.Method;
//utility timer class
class Timer implements Runnable{
  //is the timer still ticking or on hold ?
  boolean isPaused = false;
  //is the thread still running ?
  boolean isRunning = true;

  //how close are we to completion (0.0 = 0 %, 1.0 = 100%)
  float progress = 0.0;
  //a reference to the time in ms since the start of the timer or reset
  long now;
  //default duration
  long duration = 10000;
  //default tick interval
  long tickInterval = 1000;
  //time at pause
  long pauseTime;

  //reference to the main sketch
  PApplet parent;
  //function to call on each tick
  Method onTick;
  //function to call when timer has completed
  Method onComplete;

  Timer(PApplet parent,String onTickFunctionName,String onCompleteFunctionName){
    this.parent = parent;
    //try to store a reference to the tick function based on its name
    try{
      onTick = parent.getClass().getMethod(onTickFunctionName);
    }catch(Exception e){
      e.printStackTrace();
    }

    //try to store a reference to the complete function based on its name
    try{
      onComplete = parent.getClass().getMethod(onCompleteFunctionName);
    }catch(Exception e){
      e.printStackTrace();
    }
    //auto-pause
    isPaused = true;
    //get millis since the start of the program
    now = System.currentTimeMillis();
    //start the thread (processes run())
    new Thread(this).start();
  }

  //start a new stop watch with new settings
  void reset(long newDuration,long newInterval){
    duration = newDuration;
    tickInterval = newInterval;
    now = System.currentTimeMillis();
    progress = 0;
    isPaused = false;
    println("resetting for ",newDuration,"ticking every",newInterval);
  } 

  //cancel an existing timer
  void cancel(){
    isPaused = true;
    progress = 0.0;
  }

  //stop this thread
  void stop(){
    isRunning = false;
  }

  void pause(){
    isPaused = true;
    pauseTime = (System.currentTimeMillis() - now); 
  }
  void resume(){
    now = System.currentTimeMillis() - pauseTime;
    isPaused = false;
  }

  public void run(){
    while(isRunning){

      try{
          //sleep per tick interval
          Thread.sleep(tickInterval);
          //if we're still going
          if(!isPaused){
            //get the current millis
            final long millis = System.currentTimeMillis();
            //update how far we're into this duration
            progress = ((millis - now) /(float)duration);
            //call the tick function
            if(onTick != null){
              try{
                onTick.invoke(parent);
              }catch(Exception e){
                e.printStackTrace();
              }
            }
            //if we've made, pause the timer and call on complete
            if(progress >= 1.0){
              isPaused = true;
              //call on complete
              if(onComplete != null){
              try{
                  onComplete.invoke(parent);
                }catch(Exception e){
                  e.printStackTrace();
                }
              }
            }
          }
        }catch(InterruptedException e){
          println(e.getMessage());
        }
      }
    }

}

Zusätzlich können Sie mit der Java -TimerTask Klasse.