Hi again.

It's not working. KeyReleased() does not work as a trigger by itself.

Maybe I was not clear in describing the event. It's a typical shooting-like system as old as you can imagine.

When I key-press, a particle should fall from the top of the screen. Then the particle bounces there for a long time while the keys (any) are again ready to shoot another particle. What I have instead is a particle that appears on stage just while key is pressed, never allowing me to shoot another one.

KeyReleased, as guy_yitzhaki suggested me, was not a solution. It gives me the particle for a frame-long time.

I searched quite much, and the closest I got is this at http://processing.org/discourse/yabb2/YaBB.pl?num=1260016179/1  where it's recommended this piece of code.

1. // onPress:
     if(space) {
       // note that '!jumped' is equivalent to 'jumped == false' 
       if(!jumped) { // if jump hasn't already happened this keypress
         jump(); // jump! 
         jump = true; // Make sure jump won't happen again until key is released
       }
     }
   
   // onKeyRelease:
   if(space) {
     jump = false;  // jump is false so the next key press will allow a jump
   } 
   

Now, I just don't understand. What's "space"? (Would he meant "key== ' '"?)
And... there are two booleans: 'jump' and 'jumped'; and the whole idea seems to have been thought as a closed circuit. So, how does the event on keyReleased affect the one on keyPressed with boolean 'jump' if events on keyPressed depend on boolean 'jumped'.

Could anyone confirm to me if I this code may work for the case?

Thank very much.
Marcelo.



My sketch is down here

sketchName

1. int num = 27;
   boolean jump;
   boolean jumped;
   LimitedParticle[] p = new LimitedParticle[num];
   LimitedParticle[] p2 = new LimitedParticle[p.length];
   
   
   float radius = 1.2;
   
   void setup() {
     size(400,400);
     noStroke();
     smooth();
     for (int i = 0; i < p.length; i++) {
       float velX = random(-2, 2);
       float velY = -i;
       //Inputs: x, y, x-velocity, y-velocity, radius
       p[i] = new LimitedParticle(width/2, 0,random (1.0,velX), velY, 2.2);
       p2[i] = new LimitedParticle(width/3, 0,velX, random (0,velY), 2.2);
     }
   }
   
   void draw() {
     fill(0, 24);
     rect(0, 0, width, height);
     fill(255);
   }      
   
   
   
   /////// THIS IS THE WHAT I'M TRYING TO IMPLEMENT (DOESN'T WORK)
   
   void keyPressed (){
     if(key== ' ') { //what does it actually go here?
       // note that '!jumped' is equivalent to 'jumped == false'
       if(!jumped) { // if jump hasn't already happened this keypress
         for (int i = 0; i <=0 ;i++) {
           p[i].update();
           p[i].display1(); // jump!
           jump = true; // Make sure jump won't happen again until key is released
         }
       }
     }
   }
   
   
   void keyReleased () {
     if(key== ' ') { //what does it actually go here?
       jump = false;  // jump is false so the next key press will allow a jump
     }
   }
   

TAG LimitedParticle

1. class LimitedParticle extends Particle {
     float friction = 0.99;
     LimitedParticle(int ix, int iy, float ivx, float ivy, float ir) {
       super(ix, iy, ivx, ivy, ir);
     }
     void update() {
       vy *= friction;
       vx *= friction;
       super.update();
       limit();
     }
     void limit() {
       if (y > height-radius) {
         vy = -vy;
         y = constrain(y, -height*height, height-radius);
       }
       if ((x < radius) || (x > width-radius)) {
         vx = -vx;
         x = constrain(x, radius, width-radius);
       }
     }
   }

TAG Particle

1. class Particle {
     float x, y; // The x- and y-coordinates
     float vx, vy; // The x- and y-velocities
     float radius; // Particle radius
     float gravity = 0.1;
    
     Particle(int xpos, int ypos, float velx, float vely, float r) {
       x = xpos;
       y = ypos;
       vx = velx;
       vy = vely;
       radius = r;
     }
     void update() {
       vy = vy + gravity;
       y += vy;
       x += vx;
     }
     void display1() {
       ellipse(x, y, radius*2, radius*2);
     }
     void display2() {
       rect(x, y, 10, 10);
     }
   }
   

You're making things far too complicated for yourself and unfortunately found an example of keyboard handling that, out of context, might not make a lot of sense...

Anyway, the main problem with your code is that you place the routine that does all the drawing (i.e. the display and update calls) in the keypressed method: that's obviously why it only happens when the key is held down.

Second the for loop you're using to call the display and update methods on your objects only ever hits the first object:

for (int i = 0; i <=0 ;i++) {

what you really need is this for loop to be in draw() and to iterate over the number of activated particles.  You could do something along the lines of this (you'll need to fill in the blanks):

1. int counter = 0;
2. 
   
3. void setup() {
4.   // create your particles
   
5. }
6. 
   
7. void draw() {
8.   // etc...
9.   for (int i = 0; i < counter;i++) {
10.     p[i].update();
11.     p[i].draw();
12.   }
13. }
14. 
    
15. void keyReleased() {
16.   // make sure counter doesn't increase beyond array length
    
17.   if(counter<p.length){
    
18.         counter ++;
19.   }
    
20. }

When you start counter is 0: no particles are active.  Each time you press and release a key 'counter' increases by one and the for loop iterates over an additional particle and calls the update and display methods for that particle...  I haven't tested this with your code; but it's an approach that should work...

However, when working with objects like this I'd be tempted to switch from an Array to an ArrayList.  For one thing you don't have to set the length of an ArrayList when you create it and can just keep adding objects to it.  There's some extra compexity in terms of syntax and a couple of potential gotchas, but ultimately they're worth figuring out ;)

See if you can figure out the above method.  I can post some example code with an ArrayList later (as in tomorrow).

Have you noticed that particle shooting is not inmediate to key pressing?

This is why:

float velY = -i;

-i means the initial direction is up (away from the screen) and since i gets bigger each iteration the particle travels further up before it falls back down; hence the delay.

Here's the main sketch code implemented with an ArrayList (class code remains unchanged):

1. ArrayList particles;
2. float radius = 1.2;
3. void setup() {
4.   size(400,400);
5.   noStroke();
6.   smooth();
7.   particles = new ArrayList();
8. }
9. void draw() {
10.   fill(0, 24);
11.   rect(0, 0, width, height);
12.   fill(255);
13.   for (int i = 0; i < particles.size();i++) {
14.     LimitedParticle particle = (LimitedParticle) particles.get(i);
15.     particle.update();
16.     particle.display1();
17.   }
18. }     
19. void keyPressed (){
20. }
21. void keyReleased () {
22.   if(key== ' ') {
23.     float velX = random(-2, 2);
24.     LimitedParticle particle = new LimitedParticle(width/2, 0,velX, 0, 2.2);
25.     particles.add(particle);
26.   }
27. }

Now since the length of the ArrayList is never longer than the number of particles you can just iterate over its length (which you ge with size() ), so don't need to use a counter variable and you aren't limited by the length set for the array.  When creating a new particle I first set it to a variable for clarity but you could simply write:

particles.add(new LimitedParticle(width/2, 0,velX, 0, 2.2));