It would be easier for us to understand your code (by running and experimenting with it) if it didn't require images; however, it is possible to make some observations as it is:

Most people would create a class to hold the bullets; that way, you don't have to manage them from within your player class. But, then, if you want to make it closer to Portal, you could automatically change the wall that you are aiming at and skip bullets altogether.

A zip file would definitely be helpful...
Can you show us what you tried with the Bullet class?

can anyone help?

here is a new tab for your program named Bullet:

Bullet is used as a class by an ArrayList within player

1. // Bullet
2. // Simple class
3. // http://www.processing.org/learning/topics/arraylistclass.html
4. class Bullet {
5.   float x;
6.   float y;
7.   float speedX ; 
8.   float speedY;
9.   //float gravity;
10.   float w;
11.   float life = 255;
12.   Bullet(float tempX, float tempY, float tempW) {
13.     x = tempX;
14.     y = tempY;
15.     w = tempW;
16.     speedX = 4.2;
17.     speedY = 0;
18.     //gravity = 0.1;
19.   }
20.   void move() {
21.     // Add speed to location
22.     x = x + speedX;
23.     y = y + speedY;
24.     // collision
25.     if (get(int(x), int(y)) == color(60) ) {
26.       println("##########################################");
27.       life=-1;
28.     }
29.   }
30.   boolean finished() {
31.     // fade out
32.     // life--;
33.     // bullet dead?
34.     if (life < 0) {
35.       return true;
36.     }
37.     else {
38.       return false;
39.     }
40.   }
41.   void display() {
42.     // Display the circle
43.     fill(244, 2, 2);
44.     noStroke();
45.     //stroke(0,life);
46.     ellipse(x, y, w, w);
47.   }
48. } 

I also made some changes in tab player
You find changes by searching new1

1. class Player {
2.   ArrayList<Bullet> bullets;   // new1
3.   PVector position, velocity; //should contain x and y...
4.   Boolean isOnLand; // is player on the ground?
5.   Boolean isFacingRight; // is player facing right, used for flipping image
6.   Boolean shoot;
7.   int animationDelay;
8.   int animationFrame;
9.   int coinsCollected;
10.   //bullets = new ArrayList();
11.   static final float JUMP_POWER = 10.0; //how fast player goes up
12.   static final float RUN_SPEED = 5.0; //how fast player moves
13.   static final float AIR_SPEED = 1.5; //affects movement in air
14.   static final float SLOWDOWN_PREC = 0.4; //friction while on ground
15.   static final float AIR_SLOWDOWN_PREC = 0.7; //friction while in air, makes it so player doesn't move super fast
16.   static final float STAND_SPEED = 1.0; //this is the speed for when a player isn't moving, not sure if needed
17.   static final int RUN_ANIMATION_DELAY = 3; //frames till animation updates
18.   Player() {
19.     bullets=new ArrayList();   // new1
20.     shoot = true;
21.     isOnLand = false;
22.     isFacingRight = true;
23.     position = new PVector();
24.     velocity = new PVector();
25.     reset();
26.   }
27.   void reset() {
28.     coinsCollected = 0;
29.     animationDelay = 0;   
30.     animationFrame = 0;
31.     velocity.x = 0;
32.     velocity.y = 0;
33.   }
34.   void inputCheck() {
35.     float speedsHere = (isOnLand ? RUN_SPEED : AIR_SPEED);
36.     float frictionsHere = (isOnLand ? SLOWDOWN_PREC : AIR_SLOWDOWN_PREC);
37.     if (theKeyboard.holdS && theKeyboard.holdRight) {
38.       velocity.x += speedsHere*2;
39.     }
40.     if (theKeyboard.holdS && theKeyboard.holdLeft) {
41.       velocity.x -= speedsHere*2;
42.     }
43.     if (theKeyboard.holdSpace) {   // new1
44.       fire();
45.     }
46.     if (theKeyboard.holdLeft) {
47.       velocity.x -= speedsHere;
48.     }
49.     else if (theKeyboard.holdRight) {
50.       velocity.x += speedsHere;
51.     }
52.     velocity.x *= frictionsHere; // this should cause player to constantly be losing speed...
53.     if (isOnLand) { //player can only jump if on ground, change this for a double jump ability
54.       if (theKeyboard.holdUp) {
55.         velocity.y = -JUMP_POWER;
56.         isOnLand = false;
57.       }
58.     }
59.   }
60.   void checkForWalls() {
61.     int charWidth = character_stand.width; // image size
62.     int charHeight = character_stand.height;
63.     int wallDistance = int(charWidth * 0.5);
64.     int ceilingDistance = int(charHeight * 0.95);
65.     // detect wall/ceiling bumps
66.     PVector rightLow, rightHigh, leftLow, leftHigh, topSide;
67.     leftHigh = new PVector();
68.     rightHigh = new PVector();
69.     leftLow = new PVector();
70.     rightLow = new PVector();
71.     topSide = new PVector();
72.     //update
73.     leftHigh.x = leftLow.x = position.x - wallDistance; // left edge of player
74.     rightHigh.x = rightLow.x = position.x + wallDistance; // right edge of player
75.     leftLow.y = rightLow.y = position.y-0.3 * charHeight; // shin high
76.     leftHigh.y = rightHigh.y = position.y-0.8 * charHeight; // shoulder high
77.     topSide.x = position.x; // center of char
78.     topSide.y = position.y-ceilingDistance; // top of char
79.     //kill player and reset game
80.     if (theWorld.worldSquareAt(topSide) == World.TILE_KILLBLOCK ||
81.       theWorld.worldSquareAt(leftHigh) == World.TILE_KILLBLOCK ||
82.       theWorld.worldSquareAt(leftLow) == World.TILE_KILLBLOCK ||
83.       theWorld.worldSquareAt(rightHigh) == World.TILE_KILLBLOCK ||
84.       theWorld.worldSquareAt(rightLow) == World.TILE_KILLBLOCK ||
85.       theWorld.worldSquareAt(position) == World.TILE_KILLBLOCK)
86.     {
87.       gameover = true;
88.       return;
89.     }
90.     if (theWorld.worldSquareAt(topSide)==World.TILE_SOLID || theWorld.worldSquareAt(topSide)==World.TILE_SOLID1) {
91.       if (theWorld.worldSquareAt(position)==World.TILE_SOLID || theWorld.worldSquareAt(topSide)==World.TILE_SOLID1) {
92.         position.sub(velocity);
93.         velocity.x=0.0;
94.         velocity.y=0.0;
95.       }
96.       else {
97.         position.y = theWorld.bottomOfSquare(topSide)+ceilingDistance;
98.         if (velocity.y < 0) {
99.           velocity.y = 0.0;
100.         }
101.       }
102.     }
103.     if ( theWorld.worldSquareAt(leftLow)==World.TILE_SOLID || theWorld.worldSquareAt(leftLow)==World.TILE_SOLID1) {
104.       position.x = theWorld.rightOfSquare(leftLow)+wallDistance;
105.       if (velocity.x < 0) {
106.         velocity.x = 0.0;
107.       }
108.     }
109.     if ( theWorld.worldSquareAt(leftHigh)==World.TILE_SOLID || theWorld.worldSquareAt(leftHigh)==World.TILE_SOLID1) {
110.       position.x = theWorld.rightOfSquare(leftHigh)+wallDistance;
111.       if (velocity.x < 0) {
112.         velocity.x = 0.0;
113.       }
114.     }
115.     if ( theWorld.worldSquareAt(rightLow)==World.TILE_SOLID || theWorld.worldSquareAt(rightLow)==World.TILE_SOLID1) {
116.       position.x = theWorld.leftOfSquare(rightLow)-wallDistance;
117.       if (velocity.x > 0) {
118.         velocity.x = 0.0;
119.       }
120.     }
121.     if ( theWorld.worldSquareAt(rightHigh)==World.TILE_SOLID || theWorld.worldSquareAt(rightHigh)==World.TILE_SOLID1) {
122.       position.x = theWorld.leftOfSquare(rightHigh)-wallDistance;
123.       if (velocity.x > 0) {
124.         velocity.x = 0.0;
125.       }
126.     }
127.   }
128.   void checkForCoinCollect() {
129.     PVector centerOfPlayer;
130.     PVector topOfPlayer;
131.     centerOfPlayer = new PVector(position.x, position.y - character_stand.height/2);
132.     topOfPlayer = new PVector(position.x, position.y - character_stand.height);
133.     if (theWorld.worldSquareAt(centerOfPlayer) == World.TILE_COIN) {
134.       theWorld.setSquareAtToThis(centerOfPlayer, World.TILE_EMPTY);
135.       coinsCollected++;
136.     }
137.     if (theWorld.worldSquareAt(topOfPlayer) == World.TILE_COIN) {
138.       theWorld.setSquareAtToThis(topOfPlayer, World.TILE_EMPTY);
139.       coinsCollected++;
140.     }
141.   }
142.   void checkFalling() {
143.     if (theWorld.worldSquareAt(position)==World.TILE_EMPTY ||
144.       theWorld.worldSquareAt(position)==World.TILE_COIN) {
145.       isOnLand=false;
146.     }
147.     if (isOnLand == false) {   
148.       if (theWorld.worldSquareAt(position)==World.TILE_SOLID || theWorld.worldSquareAt(position)==World.TILE_SOLID1) { // landed on solid square?
149.         isOnLand = true;
150.         position.y = theWorld.topOfSquare(position);
151.         velocity.y = 0.0;
152.       }
153.       else { // fall
154.         velocity.y += GRAVITY_STRENGTH;
155.       }
156.     }
157.   }
158.   void move() {
159.     position.add(velocity);
160.     checkForWalls();
161.     checkForCoinCollect();
162.     checkFalling();
163.   }
164.   void fire() {     // new1
165.     println("++++++++++++++++++++++++++++++++++++++");
166.     // check for player facing direction
     
167.     bullets.add ( new Bullet( position.x, position.y-22, 5 ));
168.   }
169.   void draw() {
170.     int guyWidth = character_stand.width;
171.     int guyHeight = character_stand.height;
172.     if (velocity.x < -STAND_SPEED) {
173.       isFacingRight = false;
174.     }
175.     else if (velocity.x > STAND_SPEED) {
176.       isFacingRight = true;
177.     }
178.     pushMatrix();
179.     translate(position.x, position.y);
180.     if (isFacingRight == false) {
181.       scale(-1, 1);
182.     }
183.     translate(-guyWidth / 2, -guyHeight); // drawing images centered on character's feet
184.       if (isOnLand == false) {
185.       image(character_run1, 0, 0);
186.       if (theKeyboard.holdSpace) {
187.         image(character_jumpshoot, 0, 0);
188.       }
189.     }
190.     else if (abs(velocity.x) < STAND_SPEED) {
191.       image(character_stand, 0, 0);
192.     }
193.     else {
194.       if (animationDelay--<0) {
195.         animationDelay=RUN_ANIMATION_DELAY;
196.         if (animationFrame==0) {
197.           animationFrame=1;
198.         }
199.         else {
200.           animationFrame=0;
201.         }
202.       }
203.       if (animationFrame==0) {
204.         image(character_run1, 0, 0);
205.       }
206.       else {
207.         image(character_run2, 0, 0);
208.       }
209.     }
210.     if (isOnLand == true) {
211.       if (theKeyboard.holdSpace) {
212.         if (!theKeyboard.holdLeft) {
213.           if (!theKeyboard.holdRight) {
214.             image(character_shoot, 0, 0);
215.             //image(ammo_fired, 0, 0);
216.           }
217.         }
218.       }
219.     }
220.     popMatrix(); // undoes all
221.     for (Bullet currentBullet : bullets ) {     // new1
222.       println ("************************");
223.       currentBullet.move();
224.       currentBullet.display();
225.     }
226.     // With an array, we say length, with an ArrayList, we say size()
227.     // The length of an ArrayList is dynamic
228.     // Notice how we are looping through the ArrayList backwards
229.     // This is because we are deleting elements from the list 
230.     for (int i = bullets.size()-1; i >= 0; i--) {
231.       // An ArrayList
232.       Bullet currentBullet = bullets.get(i);
233.       if (currentBullet.finished()) {
234.         // Items can be deleted with remove()
235.         bullets.remove(i);
236.       }
237.     }
238.   }
239. }

thank you for this that was super helpful and very simple to implement, i'm still messing around with it a little trying to get it to work how I want it too. But again thank you!

yeah, you're welcome!


Suggestions:

• You can even use your bullet / fire ball / arrow image when you have one instead of ellipse().
• Shoot both ways, not only to the right...
• Have a decent wall detection.
• Count the ammo you are using and when it's 0 don't shoot anymore till he finds an ammo pack.
• Also maybe have a timer (millis()) to make sure there's a gap between bullets like with a automatic gun.

I just wanted to give you a general impression of how to shoot.

yeah this was really helpful, I've been able to get it to shoot both ways but it won't continue, if the player looks the other way the bullet changes direction and I can't figure out what I'm doing wrong. I also can't figure out a way to make the bullet change the color of the wall when it hits. Anyone have any suggestions on how to do this?

Regarding direction:

I have a similar question but I am not sure if should I posted it here or start a new thread..

Anyway, I 'll ask and if there is a problem, let me know! :D


I have a spaceship that can fire rockets(wow!)..
I have the rocket in its own class which has a method fire() with this code..

xpos_rocket=xpos_rocket+2;


In the draw() I have this code..

  if (keyCode==32) {
    rocket.fire();
  }

Probably many of you already saw what is the problem.. If I press once the space bar, the rocket is launched and looks that it works correctly BUT as soon as I press any other key, the rocket freezes! The only exception is if I press again space bar, freezes and continues..

I think the a part of the problem is located in that the keyCode stores the most recently key that was pressed.. so the way I have it (with the if statement) in every draw loop it checks if the last pressed key was the 32 (spacebar). If i press the up/down arrow (or any other key) the "if" statement is false so the rocket stays put.

How can I call the rocket.fire() and this method not get affected by any other key pressed right after that ?

Sorry about my poor English!

Thank you!

@gspot38

When you look at my Code above:

@ thez3r0312

to enlighten you further, I updated my Code a little :

It can shoot right and left now

here is again the tab for your program named Bullet:

Bullet is used as a class by an ArrayList within player

The trick is to extend the constructor with speedX and speedY in the class and in
tab player depending on   if (isFacingRight)    give speedX a value +4.2 or -4.2.

Also the barrel of the gun (where the bullet starts) has a small offset of +12 or -12.

The other tabs stay unchanged.

See bold parts / search new2 for changes
in the constructor

1. // Bullet
2. // Simple class
3. // http://www.processing.org/learning/topics/arraylistclass.html
4. class Bullet {
5.   float x;
6.   float y;
7.   float speedX ; 
8.   float speedY;
9.   //float gravity;
10.   float w;
11.   float life = 255;
12. 
    
13.   Bullet(float tempX, float tempY,             // new2
14.   float tempSpeedX, float tempSpeedY,
15.   float tempW) {
16.     x = tempX;
17.     y = tempY;
18.     w = tempW;
19.     speedX = tempSpeedX; // 4.2;                // new2
20.     speedY = tempSpeedY; // 0;
21.     //gravity = 0.1;
22.   }
23. 
    
24.   void move() {
25.     // Add speed to location
26.     x = x + speedX;
27.     y = y + speedY;
28.     // collision
29.     if (get(int(x), int(y)) == color(60) ) {
30.       println("##########################################");
31.       life=-1;
32.     }
33.   }
34.   boolean finished() {
35.     // fade out
36.     // life--;
37.     // bullet dead?
38.     if (life < 0) {
39.       return true;
40.     }
41.     else {
42.       return false;
43.     }
44.   }
45.   void display() {
46.     // Display the circle
47.     fill(244, 2, 2);
48.     noStroke();
49.     //stroke(0,life);
50.     ellipse(x, y, w, w);
51.     // image( ammo_fired, x, y );
52.   }
53. } 

___________________________________________________________________________________________

and the tab player :

1. //
2. //
3. class Player {
4.   ArrayList<Bullet> bullets;   // new1
5.   PVector position, velocity; //should contain x and y...
6.   Boolean isOnLand; // is player on the ground?
7.   Boolean isFacingRight; // is player facing right, used for flipping image
8.   Boolean shoot;
9.   int animationDelay;
10.   int animationFrame;
11.   int coinsCollected;
12.   //bullets = new ArrayList();
13.   static final float JUMP_POWER = 10.0; //how fast player goes up
14.   static final float RUN_SPEED = 5.0; //how fast player moves
15.   static final float AIR_SPEED = 1.5; //affects movement in air
16.   static final float SLOWDOWN_PREC = 0.4; //friction while on ground
17.   static final float AIR_SLOWDOWN_PREC = 0.7; //friction while in air, makes it so player doesn't move super fast
18.   static final float STAND_SPEED = 1.0; //this is the speed for when a player isn't moving, not sure if needed
19.   static final int RUN_ANIMATION_DELAY = 3; //frames till animation updates
20.   Player() {
21.     bullets=new ArrayList();   // new1
22.     shoot = true;
23.     isOnLand = false;
24.     isFacingRight = true;
25.     position = new PVector();
26.     velocity = new PVector();
27.     reset();
28.   }
29.   void reset() {
30.     coinsCollected = 0;
31.     animationDelay = 0;   
32.     animationFrame = 0;
33.     velocity.x = 0;
34.     velocity.y = 0;
35.   }
36.   void inputCheck() {
37.     float speedsHere = (isOnLand ? RUN_SPEED : AIR_SPEED);
38.     float frictionsHere = (isOnLand ? SLOWDOWN_PREC : AIR_SLOWDOWN_PREC);
39.     if (theKeyboard.holdS && theKeyboard.holdRight) {
40.       velocity.x += speedsHere*2;
41.     }
42.     if (theKeyboard.holdS && theKeyboard.holdLeft) {
43.       velocity.x -= speedsHere*2;
44.     }
45.     if (theKeyboard.holdSpace) {   // new1
46.       fire();
47.     }
48.     if (theKeyboard.holdLeft) {
49.       velocity.x -= speedsHere;
50.     }
51.     else if (theKeyboard.holdRight) {
52.       velocity.x += speedsHere;
53.     }
54.     velocity.x *= frictionsHere; // this should cause player to constantly be losing speed...
55.     if (isOnLand) { //player can only jump if on ground, change this for a double jump ability
56.       if (theKeyboard.holdUp) {
57.         velocity.y = -JUMP_POWER;
58.         isOnLand = false;
59.       }
60.     }
61.   }
62.   void checkForWalls() {
63.     int charWidth = character_stand.width; // image size
64.     int charHeight = character_stand.height;
65.     int wallDistance = int(charWidth * 0.5);
66.     int ceilingDistance = int(charHeight * 0.95);
67.     // detect wall/ceiling bumps
68.     PVector rightLow, rightHigh, leftLow, leftHigh, topSide;
69.     leftHigh = new PVector();
70.     rightHigh = new PVector();
71.     leftLow = new PVector();
72.     rightLow = new PVector();
73.     topSide = new PVector();
74.     //update
75.     leftHigh.x = leftLow.x = position.x - wallDistance; // left edge of player
76.     rightHigh.x = rightLow.x = position.x + wallDistance; // right edge of player
77.     leftLow.y = rightLow.y = position.y-0.3 * charHeight; // shin high
78.     leftHigh.y = rightHigh.y = position.y-0.8 * charHeight; // shoulder high
79.     topSide.x = position.x; // center of char
80.     topSide.y = position.y-ceilingDistance; // top of char
81.     //kill player and reset game
82.     if (theWorld.worldSquareAt(topSide) == World.TILE_KILLBLOCK ||
83.       theWorld.worldSquareAt(leftHigh) == World.TILE_KILLBLOCK ||
84.       theWorld.worldSquareAt(leftLow) == World.TILE_KILLBLOCK ||
85.       theWorld.worldSquareAt(rightHigh) == World.TILE_KILLBLOCK ||
86.       theWorld.worldSquareAt(rightLow) == World.TILE_KILLBLOCK ||
87.       theWorld.worldSquareAt(position) == World.TILE_KILLBLOCK)
88.     {
89.       gameover = true;
90.       return;
91.     }
92.     if (theWorld.worldSquareAt(topSide)==World.TILE_SOLID || theWorld.worldSquareAt(topSide)==World.TILE_SOLID1) {
93.       if (theWorld.worldSquareAt(position)==World.TILE_SOLID || theWorld.worldSquareAt(topSide)==World.TILE_SOLID1) {
94.         position.sub(velocity);
95.         velocity.x=0.0;
96.         velocity.y=0.0;
97.       }
98.       else {
99.         position.y = theWorld.bottomOfSquare(topSide)+ceilingDistance;
100.         if (velocity.y < 0) {
101.           velocity.y = 0.0;
102.         }
103.       }
104.     }
105.     if ( theWorld.worldSquareAt(leftLow)==World.TILE_SOLID || theWorld.worldSquareAt(leftLow)==World.TILE_SOLID1) {
106.       position.x = theWorld.rightOfSquare(leftLow)+wallDistance;
107.       if (velocity.x < 0) {
108.         velocity.x = 0.0;
109.       }
110.     }
111.     if ( theWorld.worldSquareAt(leftHigh)==World.TILE_SOLID || theWorld.worldSquareAt(leftHigh)==World.TILE_SOLID1) {
112.       position.x = theWorld.rightOfSquare(leftHigh)+wallDistance;
113.       if (velocity.x < 0) {
114.         velocity.x = 0.0;
115.       }
116.     }
117.     if ( theWorld.worldSquareAt(rightLow)==World.TILE_SOLID || theWorld.worldSquareAt(rightLow)==World.TILE_SOLID1) {
118.       position.x = theWorld.leftOfSquare(rightLow)-wallDistance;
119.       if (velocity.x > 0) {
120.         velocity.x = 0.0;
121.       }
122.     }
123.     if ( theWorld.worldSquareAt(rightHigh)==World.TILE_SOLID || theWorld.worldSquareAt(rightHigh)==World.TILE_SOLID1) {
124.       position.x = theWorld.leftOfSquare(rightHigh)-wallDistance;
125.       if (velocity.x > 0) {
126.         velocity.x = 0.0;
127.       }
128.     }
129.   }
130.   void checkForCoinCollect() {
131.     PVector centerOfPlayer;
132.     PVector topOfPlayer;
133.     centerOfPlayer = new PVector(position.x, position.y - character_stand.height/2);
134.     topOfPlayer = new PVector(position.x, position.y - character_stand.height);
135.     if (theWorld.worldSquareAt(centerOfPlayer) == World.TILE_COIN) {
136.       theWorld.setSquareAtToThis(centerOfPlayer, World.TILE_EMPTY);
137.       coinsCollected++;
138.     }
139.     if (theWorld.worldSquareAt(topOfPlayer) == World.TILE_COIN) {
140.       theWorld.setSquareAtToThis(topOfPlayer, World.TILE_EMPTY);
141.       coinsCollected++;
142.     }
143.   }
144.   void checkFalling() {
145.     if (theWorld.worldSquareAt(position)==World.TILE_EMPTY ||
146.       theWorld.worldSquareAt(position)==World.TILE_COIN) {
147.       isOnLand=false;
148.     }
149.     if (isOnLand == false) {   
150.       if (theWorld.worldSquareAt(position)==World.TILE_SOLID || theWorld.worldSquareAt(position)==World.TILE_SOLID1) { // landed on solid square?
151.         isOnLand = true;
152.         position.y = theWorld.topOfSquare(position);
153.         velocity.y = 0.0;
154.       }
155.       else { // fall
156.         velocity.y += GRAVITY_STRENGTH;
157.       }
158.     }
159.   }
160.   void move() {
161.     position.add(velocity);
162.     checkForWalls();
163.     checkForCoinCollect();
164.     checkFalling();
165.   }
166.   void fire() {     // new2
167.     println("++++++++++++++++++++++++++++++++++++++");
168.     if (isFacingRight)
169.     {
170.       bullets.add ( new Bullet( position.x+12, position.y-24, 4.2, 0.0, 5 ));
171.     }
172.     else
173.     {
174.       bullets.add ( new Bullet( position.x-12, position.y-24, -4.2, 0.0, 5 ));
175.     }
176.   }
177.   void draw() {
178.     int guyWidth = character_stand.width;
179.     int guyHeight = character_stand.height;
180.     if (velocity.x < -STAND_SPEED) {
181.       isFacingRight = false;
182.     }
183.     else if (velocity.x > STAND_SPEED) {
184.       isFacingRight = true;
185.     }
186.     pushMatrix();
187.     translate(position.x, position.y);
188.     if (isFacingRight == false) {
189.       scale(-1, 1);
190.     }
191.     translate(-guyWidth / 2, -guyHeight); // drawing images centered on character's feet
192.       if (isOnLand == false) {
193.       image(character_run1, 0, 0);
194.       if (theKeyboard.holdSpace) {
195.         image(character_jumpshoot, 0, 0);
196.       }
197.     }
198.     else if (abs(velocity.x) < STAND_SPEED) {
199.       image(character_stand, 0, 0);
200.     }
201.     else {
202.       if (animationDelay--<0) {
203.         animationDelay=RUN_ANIMATION_DELAY;
204.         if (animationFrame==0) {
205.           animationFrame=1;
206.         }
207.         else {
208.           animationFrame=0;
209.         }
210.       }
211.       if (animationFrame==0) {
212.         image(character_run1, 0, 0);
213.       }
214.       else {
215.         image(character_run2, 0, 0);
216.       }
217.     }
218.     if (isOnLand == true) {
219.       if (theKeyboard.holdSpace) {
220.         if (!theKeyboard.holdLeft) {
221.           if (!theKeyboard.holdRight) {
222.             image(character_shoot, 0, 0);
223.             //image(ammo_fired, 0, 0);
224.           }
225.         }
226.       }
227.     }
228.     popMatrix(); // undoes all
229.     for (Bullet currentBullet : bullets ) {     // new1
230.       println ("************************");
231.       currentBullet.move();
232.       currentBullet.display();
233.     }
234.     // With an array, we say length, with an ArrayList, we say size()
235.     // The length of an ArrayList is dynamic
236.     // Notice how we are looping through the ArrayList backwards
237.     // This is because we are deleting elements from the list 
238.     for (int i = bullets.size()-1; i >= 0; i--) {
239.       // An ArrayList
240.       Bullet currentBullet = bullets.get(i);
241.       if (currentBullet.finished()) {
242.         // Items can be deleted with remove()
243.         bullets.remove(i);
244.       }
245.     }
246.   }
247. }

Greetings, Chrisir  

@ thez3r0312

you also asked:

I also can't figure out a way to make the bullet change the color of the wall when it hits. Anyone have any suggestions on how to do this?

umh.......

Do you want to change the color of the wall or of the bullet?

In theory you have to check the bullet for collision like you do with the player. Treat the bullet (every bullet) like a player. When they collide, kill the bullet and change the wall color.

Greetings, Chrisir  

Thanks for the shooting both directions, I recently got it figured out but your code is for sure more efficient. As for changing the color of the wall. Basically what I want to do is when a bullet hits the wall it change the walls color. Basically im trying to make a portal like replica. Eventually I want the player to be able to teleport. Basically I'm trying to just change the wall color. Right now though I have the walls in a switch, can a boolean change a wall color in a switch with a if statement?

for instance

switch:
if(boolean) {
      color == 600
}
else {....}

I worked on the wall thing

this is tab bullet

I think the rest stays as it is...

1. // Bullet
2. // Simple class
3. // http://www.processing.org/learning/topics/arraylistclass.html
4. class Bullet {
5.   float x;
6.   float y;
7.   float speedX ; 
8.   float speedY;
9.   float w;
10.   float life = 255;
11.   Bullet(float tempX, float tempY, // new2
12.   float tempSpeedX, float tempSpeedY,
13.   float tempW) {
14.     x = tempX;
15.     y = tempY;
16.     w = tempW;
17.     speedX = tempSpeedX; // 4.2; // new2
18.     speedY = tempSpeedY; // 0;
19.   }
20.   void move() {
21.     // Add speed to location
22.     /*
23.     x = x + speedX;
24.      y = y + speedY;
25.      */
26.     // collision
27.     /*
28.     if (get(int(x), int(y)) == color(60) ) {
29.      // println("##########################################");
30.      life=-1;
31.      }
32.      */
33.     if (life>0) {
34.       PVector bulletPos = new PVector ( x, y );
35.       if (theWorld.worldSquareAt(bulletPos)==World.TILE_SOLID) {
36.         // hit
37.         println ("hit");
38.         theWorld.setSquareAtToThis(bulletPos, World.TILE_SOLIDhit);
39.         life=-1;
40.       }
41.       else if (theWorld.worldSquareAt(bulletPos)==World.TILE_SOLID1) {
42.         // hit
43.         println ("hit1");
44.         theWorld.setSquareAtToThis(bulletPos, World.TILE_SOLID1hit);
45.         life=-1;
46.       }
47.       else if (theWorld.worldSquareAt(bulletPos)==World.TILE_SOLIDhit) {
48.         // hit
49.         life=-1;
50.       }
51.       else if (theWorld.worldSquareAt(bulletPos)==World.TILE_SOLID1hit) {
52.         // hit
53.         life=-1;
54.       }
55.       else {
56.         // Add speed to location
57.         x = x + speedX;
58.         y = y + speedY;
59.       }
60.     }
61.   } // method
62.   boolean finished() {
63.     // bullet dead?
64.     if (life < 0) {
65.       return true;
66.     }
67.     else {
68.       return false;
69.     }
70.   }
71.   void display() {
72.     // Display the circle
73.     fill(244, 2, 2);
74.     noStroke();
75.     //stroke(0,life);
76.     ellipse(x, y, w, w);
77.     // image( ammo_fired, x, y );
78.   }
79. } // class
80. //

ah, and world of course

1. PImage grass;
2. class World {
3.   int coinsInGame;
4.   int coinsUpdateTimer;
5.   static final int TILE_EMPTY = 0;
6.   static final int TILE_SOLID = 1;
7.   static final int TILE_SOLID1 = 2;
8.   static final int TILE_COIN = 3;
9.   static final int TILE_KILLBLOCK = 4;
10.   static final int TILE_START = 7;
11.   static final int   TILE_SOLIDhit = 8;
12.   static final int   TILE_SOLID1hit = 9;
13.   static final int GRID_UNIT_SIZE = 30;
14.   static final int GRID_UNIT_WIDE = 56;
15.   static final int GRID_UNIT_TALL = 17;
16.   int[][] worldGrid = new int[GRID_UNIT_TALL][GRID_UNIT_WIDE];
17.   int[][] start_Grid = {
18.     {
19.       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
20.     }
21.     ,
22.     {
23.       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
24.     }
25.     ,
26.     {
27.       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
28.     }
29.     ,
30.     {
31.       2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
32.     }
33.     ,
34.     {
35.       2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
36.     }
37.     ,
38.     {
39.       1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
40.     }
41.     ,
42.     {
43.       1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
44.     }
45.     ,
46.     {
47.       1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
48.     }
49.     ,
50.     {
51.       1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
52.     }
53.     ,
54.     {
55.       1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
56.     }
57.     ,
58.     {
59.       1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
60.     }
61.     ,
62.     {
63.       1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
64.     }
65.     ,
66.     {
67.       2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
68.     }
69.     ,
70.     {
71.       2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
72.     }
73.     ,
74.     {
75.       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
76.     }
77.     ,
78.     {
79.       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
80.     }
81.     ,
82.     {
83.       4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4
84.     }
85.     ,
86.   };
87.   World() {
88.     coinsUpdateTimer = 0;
89.   }
90.   int worldSquareAt(PVector thisPosition) {
91.     float gridSpotX = thisPosition.x / GRID_UNIT_SIZE;
92.     float gridSpotY = thisPosition.y / GRID_UNIT_SIZE;
93.     if (gridSpotX<0) {
94.       return TILE_SOLID;
95.     }
96.     if (gridSpotX >= GRID_UNIT_WIDE) {
97.       return TILE_SOLID;
98.     }
99.     if (gridSpotY < 0) {
100.       return TILE_SOLID;
101.     }
102.     if (gridSpotY >= GRID_UNIT_TALL) {
103.       return TILE_SOLID;
104.     }
105.     return worldGrid[int(gridSpotY)][int(gridSpotX)];
106.   }
107.   void setSquareAtToThis(PVector thisPosition, int newTile) {
108.     int gridSpotX = int(thisPosition.x / GRID_UNIT_SIZE);
109.     int gridSpotY = int(thisPosition.y / GRID_UNIT_SIZE);
110.     if (gridSpotX < 0 || gridSpotX >= GRID_UNIT_WIDE ||
111.       gridSpotY < 0 || gridSpotY >= GRID_UNIT_TALL) {
112.       return;
113.     }
114.     worldGrid[gridSpotY][gridSpotX] = newTile;
115.   }
116.   float topOfSquare(PVector thisPosition) {
117.     int thisY = int(thisPosition.y);
118.     thisY /= GRID_UNIT_SIZE;
119.     return float(thisY*GRID_UNIT_SIZE);
120.   }
121.   float bottomOfSquare(PVector thisPosition) {
122.     if (thisPosition.y<0) {
123.       return 0;
124.     }
125.     return topOfSquare(thisPosition)+GRID_UNIT_SIZE;
126.   }
127.   float leftOfSquare(PVector thisPosition) {
128.     int thisX = int(thisPosition.x);
129.     thisX /= GRID_UNIT_SIZE;
130.     return float(thisX*GRID_UNIT_SIZE);
131.   }
132.   float rightOfSquare(PVector thisPosition) {
133.     if (thisPosition.x<0) {
134.       return 0;
135.     }
136.     return leftOfSquare(thisPosition)+GRID_UNIT_SIZE;
137.   }
138.   void reload() {
139.     coinsInGame = 0; // we count them while copying in level data
140.     for (int i=0; i < GRID_UNIT_WIDE; i++) {
141.       for (int ii=0; ii < GRID_UNIT_TALL; ii++) {
142.         if (start_Grid[ii][i] == TILE_START) { // player start position
143.           worldGrid[ii][i] = TILE_EMPTY; // put an empty tile in that spot
144.           // then update the player spot to the center of that tile
145.           thePlayer.position.x = i * GRID_UNIT_SIZE + (GRID_UNIT_SIZE/2);
146.           thePlayer.position.y = ii * GRID_UNIT_SIZE + (GRID_UNIT_SIZE/2);
147.         }
148.         else {
149.           if (start_Grid[ii][i]==TILE_COIN) {
150.             coinsInGame++;
151.           }
152.           worldGrid[ii][i] = start_Grid[ii][i];
153.         }
154.       }
155.     }
156.   }
157.   void render() { // draw the world
158.     // these next few lines cycle a number we use to make it look like coins are spinning
159.     coinsUpdateTimer--;
160.     if (coinsUpdateTimer<-GRID_UNIT_SIZE/3) {
161.       coinsUpdateTimer = GRID_UNIT_SIZE/3;
162.     }
163.     for (int i=0; i < GRID_UNIT_WIDE; i++) { // for each column
164.       for (int ii=0; ii < GRID_UNIT_TALL; ii++) { // for each tile in that column
165.         switch(worldGrid[ii][i]) { // check which tile type it is
166.         case TILE_SOLID:
167.           stroke(70);
168.           fill(60);
169.           break;
170.         case TILE_KILLBLOCK:
171.           stroke(0, 198, 198);
172.           fill(0, 198, 198);
173.           break;
174.         case TILE_SOLID1:
175.           stroke(200);
176.           fill(220);
177.           break;
178.         case TILE_SOLIDhit:
179.           stroke(70);
180.           fill(60, 22, 211);
181.           break;
182.         case TILE_SOLID1hit:
183.           stroke(200);
184.           fill(220, 20, 111);
185.           break;
186.         default:
187.           stroke(150);
188.           fill(150);
189.           break;
190.         }
191.         // then draw a rectangle
192.         rect(i * GRID_UNIT_SIZE, ii * GRID_UNIT_SIZE, // x,y of top left corner to draw rectangle
193.         GRID_UNIT_SIZE - 1, GRID_UNIT_SIZE - 1); // width, height of rectangle
194.         if (worldGrid[ii][i]==TILE_COIN) {
195.           stroke(224, 89, 0);
196.           fill(12, 161, 255);
197.           ellipse(i * GRID_UNIT_SIZE + (GRID_UNIT_SIZE/2), ii * GRID_UNIT_SIZE + (GRID_UNIT_SIZE/2), // center of grid spot
198.           abs(coinsUpdateTimer), GRID_UNIT_SIZE/2); // spin size wide, 1/2 height of box tall
199.         }
200.       }
201.     }
202.   }
203. } // class

I would just like to thank you!

In my game I had the problem like I could not shoot more than one bullets at the same time and I finally fixed it!

At first I should wait for the bullet to disappear from the screen before the new one appears! Now I can have as many bullets as the times the space bar is pressed!


Thanks guys!

Good Job!

That's absolutely good to hear!

Thank you for your feedback!

I appreciate it.

Chrisir

Any ideas on how to play an mp3 sound when you fire a bullet?

I tried a bit to search on the forum but I am not sure that is the "simple" thing I want to do..

For example I saw someone trying to create an AudioPlayer object?

Thanks!

hello,
it's like this. I think you need to download a lib.
Greetings! 


at the beginning

import ddf.minim.*;
Minim minim;
AudioPlayer groove;

AudioPlayer hitting1;

......................

in setup()

  minim = new Minim(this);
  groove = minim.loadFile("M:Eigene DateienProcessing4TestsMarbleMarble3datagroove.mp3");
  hitting1 = minim.loadFile("M:Eigene DateienProcessing4TestsMarbleMarble3datahitting.mp3");

in draw()

  if (IsAllowedSoundRolling) {
    if (hitting1.isPlaying() == false) {
      if (groove.isPlaying() == false) {
        groove.loop(1);
        // groove.play();
      }
    }

  }

to pause

....

    groove.pause(); // pause

 

One function you need


//
void stop()
{
  // always close Minim audio classes when you are done with them
  track.close();
  minim.stop();
  super.stop();
}
//

see e.g.
http://forum.processing.org/topic/visualising-sound#25080000001673037