this,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,

1. Timer t1 = new Timer (500);
2. int i;
3. void setup() {
4.   i=0;
5. }
6. void draw() {
7.   t1.advance();
8.   if (t1.check()) {
9.     println( "wert " + i );
10.     t1.done=false;
11.     t1.a=0;
12.     i++;
13.   }
14. }
15. class Timer {
16.   int a; //Counter
17.   int b; //Counter limit
18.   boolean done;
19.   Timer(int c) {
20.     a = 0; //set counter
21.     b = c; //set limit
22.     done = false;
23.   }
24.   void advance() {
25.     a++;
26.     if (a > b) done = true;
27.   }
28.   boolean check() {
29.     return done;
30.   }
31.   void destroy() {
32.     // myTimer.remove(this);
33.   }
34. }
35. // Here is the code that gets called to create a bullet:
36. void fireBullet() {
37.   // projectileList.add(new Bullet(myPlayer.x, myPlayer.y, myPlayer.pAngle));
38. }

solution with millis() is better

https://forum.processing.org/topic/timer-in-processing#25080000001240530

Chrisir is right to suggest using the system timer when developing your timer class. Using a simple counter based on frame rate will mean that the program will vary from computer to computer.

Also the timer class should only be responsible for keeping track of time, in your code the timer class is initiating actions (e.g. advance, check and destroy) so this timer class can only be used in the current sketch. A timer class that just tracks time could be used in any sketch.

Below is the code for a high resolution timer class (StopWatch) that can be used in any sketch. To demonstrate its use I have created a sketch which has a tank that follows the mouse and fires a shell when the mouse button is clicked (after a short interval to reload).

CLICK HERE TO SEE THE SKETCH

The sketch is called TankDemo and has 3 classes (each on its own tab)

Shell       this is responsible for moving and drawing itself once it has been fired

Tank       this is responsible for moving the tank so that it follows the mouse, drawing the tank and firing a shell

StopWatch   this is the high resolution timer used to measure time intervals.

The final tab (TankDemo) is the main sketch code which has overall control.

Notice that each class has clearly defined responsibilities and that these are appropriate for the class. By appropriate I mean that the tank fires its gun not the timer so the Tank class has the fire gun method.

Also notice in the main draw method (in TankDemo) the first thing that happens is that the elapsed time is retrieved from the stop watch and this time is passed to the update method for the shell and tank. Once updated both the shell and the tank are told to draw themselves.

 Tank.pde

1. class Tank {
2.   final float SPEED = 50;
3.   final float RELOAD_TIME = 1.1;
4.   float px, py; // tank's position
5.   float vx, vy; // tank's velocity
6.   float angle;  // Angle tank is facing (radians)
7.   float timeToReload;
8. 
   
9.   Tank() {
10.     px = width/2;
11.     py = height/2;
12.   }
13.  
14.   void update(float eTime) {
15.     float distance = dist(mouseX, mouseY, px, py);
16.     if (distance > 4) {
17.       vx = SPEED * (mouseX - px) / distance;
18.       vy = SPEED * (mouseY - py) / distance;
19.       angle = atan2(vy, vx); // direction tank is facing
20.     }
21.     else {
22.       vx = 0;
23.       vy = 0;
24.     }
25.     px += vx * eTime;
26.     py += vy * eTime;
27.     timeToReload -= eTime;
28.   }
29. 
    
30.   void draw() {
31.     // Save current drawing style
32.     pushStyle();
33.     // Initialise drawing style
34.     ellipseMode(CENTER);
35.     rectMode(CORNER);
36.     stroke(0);
37.     strokeWeight(1.1);
38.     // Save current transformation matrix
39.     pushMatrix();
40.       translate(px, py);
41.       rotate(angle);
42.       fill(200, 64, 64);
43.       rect(-14, -14, 40, 28);
44.       fill(200, 100, 100);
45.       rect(14, -3, 30, 6);
46.       ellipse(0, 0, 32, 22);
47.     popMatrix();
48.     popStyle();
49.   }
50. 
    
51.   void fireGun() {
52.     if (timeToReload < 0) {
53.       timeToReload = RELOAD_TIME;
54.       shell.initShell(this);
55.     }
56.   }
57. }

StopWatch.pde

1. public class StopWatch {
2.   private long currTime;
3.   private long lastTime;
4.   private long lapTime;
5.   private long startTime;
6. 
   
7.   public StopWatch() {
8.     reset();
9.   }
10. 
    
11.   // Reset the timer to zero time
12.   public void reset() {
13.     currTime = lastTime = startTime = System.nanoTime();
14.     lapTime = 0;
15.   }
16. 
    
17.   // Get the time (seconds) since the stop watch was reset
18.   public double getRunTime() {
19.     double rt = 1.0E-9 * (System.nanoTime() - startTime);
20.     return rt;
21.   }
22. 
    
23.   // Get the time elapsed (seconds) since last call to
24.   // this method
25.   public double getElapsedTime() {
26.     currTime = System.nanoTime();
27.     lapTime = currTime - lastTime;
28.     lastTime = currTime;
29.     return 1.0E-9 * lapTime;
30.   }
31. }

 

the tank is amazing, thank you,
the link is http://www.lagers.org.uk/temp/timerdemo

I am looking for a timer class, but would like to have an event driven model that executes in a similar manner to mouse or keyboard functions.   I could write something that is an extension to code above but I would explicitly have to call code each loop through draw().

It would aldo be neat to have a function that would trigger at a specific time of day eg an "alarm()" function.

Maybe an idea for Processing 2.1

By event driven I assume you mean that the timer class will repeatbly execute some code on a given time interval. If that is the case then an easy solution to your problem is discuss in this thread