//Main class
    int AlienRow = 4;
    int AlienCol = 8;
    int AfirstNullBullet = 0;
    Alien[][] alien = new Alien[AlienCol][AlienRow];
    BulletAlien[] bulletAlien = new BulletAlien[5];

    void setup()
    {
      size(700, 600);
      gameStart();
      setAlien();
    }

    void draw()
    {
      background(255);
    }

    void setAlien()
    {
      /* Set up the position of the image and how many rows and cols */
      for (int i = 0; i < AlienCol; i++) 
      {
        for (int j = 0; j < AlienRow; j++) 
        {
          alien[i][j] = new Alien(30 * (2*(i+1)), 30 * (1*(j+1)));
        }
      }//end for loop
    }

    void displayBullets() 
    {
      for (int a = 0; a < bulletAlien.length; a++)
      {
        if (bulletAlien[a] != null)
        {
          bulletAlien[a].Adisplay();
          bulletAlien[a].Amove();

          if (bulletAlien[a].ay < height || bulletAlien[a].ay > 0)
          {
            bulletAlien[a] = null;
          } else
          {
            AfirstNullBullet = a;
        }
      }
    }

    //Alien class
    class Alien
    {
      float x, y;
      float ximg = 0;
      float speed = 2;

      Boolean moveLeft = false;

      Alien(float x, float y)
      {
        this.x = x;
        this.y = y;
      }

      void display()
      {
        eclipse(x, y, 40, 40);
      }

      void move() 
      { 
        if (!moveLeft)
        {
          x += speed;
        }
        if (moveLeft)
        {
          x -= speed;
        }
        if (x <= 0)
        {
          moveLeft = false;
          y += 90;
        }
        if (x >= width - 30)
        {
          moveLeft = true;
          y += 90;
        }
        if (y >= 550)//When the alien go out of the button the game wiil end
        {
          gameEnd = true;
        }
      }

      void update() 
      {
        display();
        move();
      }

      void Alienshoot() 
      {
        if (int (random(100)) > 0) 
        {
          bulletAlien[AfirstNullBullet] = new BulletAlien(x, y, 20);
        }
      }
    }

    //Bullet class
    class BulletAlien 
    {
      float ax, ay;
      float aspeed;

      BulletAlien(float ax, float ay, float aspeed) 
      {
        this.ax = ax;
        this.ay = ay;
        this.aspeed = aspeed;
      }

      void Adisplay()
      {
        fill(255, 255, 255);
        rect(ax, ay, 4, 15);
      }

      void Amove()
      {
        ay -= aspeed;
      }
    }

float cannonX, cannonY; float cannonLength = 40; // How long the cannon on the tank extends float cannonAngle = PI*3/4; float cannonAngleStep = 0.005; // step to change cannonAngle float cannonPower = 0;

float gravity = 0; // Strength of gravity float gravitySpeed = 0.00981; float time; // calculate time for the gravity component float wind = 0; // Strength of wind float explodePositionX; float explodePositionY; boolean explode = false; float explosionStrength = 1;

float bulletSpeedX = 0; float bulletSpeedY = 0; float bulletX = 0; float bulletY = 0; Boolean renderBullet = false;

float chargeAngle = PI*3/4.; Boolean charging = false;

boolean objectInMotion = false; float targetDistance = 50; // distance from left boundary the target is positioned boolean targetHit = false; int score = 0; int total = 0;

float[] groundLevel; // Y coordinate of the ground for each X coordinate float x,y; // position of the projectile float r = 10; // radius of the projectile float speed =20.0; // speed of projectile

void setup (){ size (1000,600); cannonX = width-20; cannonY = height/2;

// Initialize the ground level // Implement random surface of the ground groundLevel = new float[width]; for(float i = 0; i < width; i++) { groundLevel[(int)i] = height/3; }

// Load font

}

void draw(){ background(200); drawGround(); drawTarget(); drawCannon(); aimCannon(); shootCannon(); drawProjectile(); drawScore(); }

void drawGround(){ // See the groundLevel[] variable to know where to draw the ground // Ground should be drawn in a dark gray stroke(118,57,40); // set dark brown for(int x = 0; x < width; x++) { line (x,height, x,height-groundLevel[x]); // draw in loop a vertikal line at lokation x } }

void drawTarget(){ ellipseMode(RADIUS); for (int i = 10; i >0; i--){ if (i<4) { fill(0); stroke(255); } else{ fill(255); stroke(0); } ellipse(targetDistance,height/2, 10i, height/2/11i);

} stroke(2555,0,0); line(targetDistance,height/11/2, targetDistance,height-height/11/2); }

void drawCannon(){ stroke(85,107,47); // set darkolivegreen color to draw the cannon fill(85,107,47); smooth(); strokeWeight(8); // invert the sign of the angle in order to point the cannon upwards (and not downwards) line(cannonX, cannonY, cannonX+cannonLengthcos(-cannonAngle), cannonY+cannonLengthsin(-cannonAngle)); strokeWeight(1); // reset to default widht arc(cannonX, cannonY, cannonLength*3/4, cannonLength/2, -PI-PI/6, PI/6); }

void aimCannon(){ fill(100); ellipse(mouseX, mouseY,1, 1); }

void shootCannon(){ if(mousePressed){ charging = true;

//increase power cannonPower++;

//draw power charge strokeWeight(2); stroke(255,0,0); line(cannonX,cannonY,cannonX + cos(cannonAngle - chargeAngle) * cannonPower,cannonY + sin(cannonAngle-chargeAngle)cannonPower); line(cannonX,cannonY,cannonX + cos(cannonAngle + chargeAngle) * cannonPower,cannonY + sin(cannonAngle+chargeAngle)cannonPower); // invert the sign of the angle in order to point the cannon upwards (and not downwards) }else{ if(charging){

//find the correct speed from angle & power bulletSpeedX = cos(cannonAngle) * cannonPower; bulletSpeedY = sin(cannonAngle) * cannonPower;

//set the start position of the bullet at the position of the user bulletX = cannonX; bulletY = cannonY;

//tell the program to render the bullet renderBullet = true;

charging = false; cannonPower = 0; } }

if(renderBullet){ //apply gravity gravity += gravity; bulletSpeedY += gravity; //apply speed bulletX += bulletSpeedX; bulletY += bulletSpeedY;

//render the bullet fill(255,0,0); ellipse(bulletX,bulletY,5,5);

//check if we still need to render the bullet if(bulletY > 600) renderBullet = false; }

}

void drawProjectile(){ // Implementation // drawExplosion(); }

void drawScore(){ // Display score // Implementation }

// Draw esplosion, if collision with target is detected void drawExplosion() { if(explode){ noStroke(); fill(255, explosionStrength*2, 0); ellipse(explodePositionX, explodePositionY, explosionStrength, explosionStrength); explosionStrength+=5; // delay(2); if (explosionStrength>100){ explode=false; explosionStrength=1; } } }

i did something like that but this is one time bullet. It has to continuously shoot.

  noCursor();
  background(0);

  image(s1, mouseX,650);
  image(p1, 20, 30);

  if (keyPressed) {
    if (keyPressed == true && key ==' ') {
      image(n1, mouseX, bo);
    }
  }
  bo = bo -10;
}

I'm just learning processing and trying to create a very simple shooting game. I need to know how to fire bullets from the location of a mouse click to random positions, and limit the number of bullets to 10. What is the best way to approach this?

class Shot {
  PVector loc;
  PVector vel;  
  int r,g,b; 
  Shot (PVector loc, PVector direction, int r, int g, int b) {
    this.loc=new PVector ();
    vel=new PVector();
    this.loc = loc.get();
    vel= direction.get();
    vel.normalize();
    vel.mult(9);
    this.r=r;
    this.g=g;
    this.b=b;
  }
  void displayShot() {    
    loc.add(vel);
    noStroke();
    fill(r,g,b);
    ellipse(loc.x, loc.y, 4, 4);    
  }  
}

and i want to shoot them by ckicking. How could i make it work without shooting too many of those(by to many i mean one each draw). because my game works perfect but it shoots a lot, its nice but THERE ARE TO MANY GOING OUT.