what do you want to happen in our sketch?

What doesn't work?

Where can we help?

Do you want to make the arrow fly with the speed depending on the length of the line you dragged with the mouse?

Does this help you? It does shoot at an angle, but speed is always the same.
http://www.openprocessing.org/sketch/77863

Greetings, Chrisir  

just updated the question. thanks for being awesome!

It's a little more complicated than this.

My advice is that you have a global var

1. boolean arrowFlies = false;

When you release the mouse, set it to true.
When arrow later hits a wall / target set it to false again.

Now in draw():
make an if-clause in draw:
When arrowFlies == false
all the stuff happens that is in your draw at the moment.
else (arrowFlies == true)
paint the arrow and set its pos according its direction
until it hits a target. Since draw is done 60 times per second,
you'll see the arrow fly.

(not tested)

There should be an example on gravity in the examples...

Something like y = y + .2;

Cheers!

like this....


compare:
http://www.processing.org/learning/topics/reflection2.html

1. // drag the mouse to 'fire' the arrow
2. 
   
3. // the whole process is controlled mainly by var "arrowFlies":
4. // If "arrowFlies" is false you drag the mouse to shoot the arrow.
5. // When you release the mouse, "arrowFlies" gets true and the arrow
6. // is shown.
7. // When arrow lands, arrow stops.
8. // When you press the mouse again, "arrowFlies" gets false again.
9. 
   
10. // To Do: Arrow points up and down. Better formula instead of ymag=5
11. 
    
12. void setup() {
13.   size(900, 500);
14.   colorMode(HSB, 100);
15. }
16. 
    
17. // global vars
18. boolean arrowFlies = false;
19. int s = 60;
20. int x, y;
21. int x_start, x_end = mouseX;
22. int y_start, y_end = mouseY;
23. float xmag; // this is the velocity of horizontal motion
24. float ymag; // vertical
25. float gravity;
26. // float damping = 0.8;
27. 
    
28. void mousePressed() {
29.   // a new shooting
30.   x_start = mouseX;
31.   y_start = mouseY;
32.   // for restart:
33.   arrowFlies = false;
34.   gravity = .095;
35. }
36. 
    
37. void mouseDragged() {
38.   strokeWeight(3);
39.   stroke(30-(dist(x_start, y_start, mouseX, mouseY))/10, 255, 255); //
40.   line(x_start, y_start, mouseX, mouseY);
41.   strokeWeight(1);
42. }
43. 
    
44. void mouseReleased() {
45.   // now calculate arrow speed and fire arrow
46.   x_end = mouseX;
47.   y_end = mouseY;
48.   //horizontal component of velocity
49.   xmag = (dist(x_start, y_start, mouseX, mouseY))*cos(atan((y_end-y_start)/(x_end-x_start)));
50.   ymag=5; // should be better formula here!
51.   arrowFlies = true;
52.   x=x_start;
53.   y=y_start;
54. }
55. 
    
56. void arrow(int x, int y, int s) {
57.   fill(255, 99, 0);
58.   stroke(0);
59.   strokeWeight(2);
60.   rect(x, y, s, s/20);
61.   strokeWeight(1);
62.   triangle(x+s, y+s/10, x+s, y-6*s/100, x+11*s/10, y+2*s/100 );
63.   //x = x + floor(xmag);
64. }
65. 
    
66. void draw() {
67. 
    
68.   if (arrowFlies == false) {
69.     background(255, 0, 99);
70.     if (mousePressed)
71.     {
72.       strokeWeight(3);
73.       stroke(30-(dist(x_start, y_start, mouseX, mouseY))/10, 255, 255); //color of line
74.       line(x_start, y_start, mouseX, mouseY);
75.     }
76.     else
77.     {
78.       line(x_start, y_start, x_end, y_end);
79.     }
80.   }
81.   else
82.   {
83.     // paint arrow and change pos
84.     background(255, 0, 99);
85.     arrow(x, y, s);
86.     x = x + round(xmag/20);
87.     ymag = ymag - gravity;  // the velocity is diminished by gravity
88.     y = int(y - ymag);
89.     // if arrow hits ground (=where the mouse was pressed in the first place) stop
90.     if (y>=y_start) {
91.       y=y_start;
92.       xmag=0;
93.       ymag=0;
94.       gravity=0;
95.     } // if
96.     //
97.   } // else
98. } // func
99. // --------------------------------------------

interesting. next step I'll fix the problem with shooting downward. don't post the correction, but is it along the lines of that the y velocity currently is always initially positive? The first attempt was to change ymag=5; with 

Shooting downward?!

Do you mean upward?

Dunno.

How do you want your game?

A perspective from the side with the lower border of the screen being the ground where the arrow lands?

Or do you think of looking downward from the sky onto a plane and the arrow can fly in all directions?

I was thinking more of the former. That's why I made gravity the way I did. But then it makes less sense to shoot in the ground?

Greetings, Chrisir

Hey guys. My try!

Code Example

1. float arrowLength = 50;
2. PVector gravity = new PVector(0, 0.4);
3. ArrayList <Arrow> arrows = new ArrayList <Arrow> ();
4. PVector start = new PVector();
5. PVector end = new PVector();
6.  
7. void setup() {
8.   size(1000, 600);
9.   strokeWeight(2);
10.   smooth();
11.   fill(0);
12. }
13.  
14. void draw() {
15.   background(255);
16.   if (mousePressed) {
17.     stroke(255,0,0);
18.     line(start.x, start.y, end.x, end.y);
19.   }
20.   for (Arrow a : arrows) {
21.     a.update();
22.     a.display();
23.   }
24. }
25.  
26. void mousePressed() {
27.   start.set(mouseX, mouseY, 0);
28.   end.set(mouseX, mouseY, 0);
29. }
30.  
31. void mouseDragged() {
32.   end.set(mouseX, mouseY, 0);
33. }
34.  
35. void mouseReleased() {
36.   end.sub(start);
37.   end.mult(-1);
38.   arrows.add(new Arrow(start, end));
39. }
40.  
41. class Arrow {
42.   PVector pos, dir;
43.   boolean stuck;
44.  
45.   Arrow(PVector p, PVector d) {
46.     pos = p.get();
47.     dir = d.get();
48.     dir.mult(0.05);
49.   }
50.  
51.   void update() {
52.     if (!stuck) {
53.       PVector aDir = dir.get();
54.       PVector aTip = pos.get();
55.       aDir.normalize();
56.       aDir.mult(arrowLength);
57.       aTip.add(aDir);
58.       if (aTip.x >= 0 && aTip.x <= width && aTip.y >= 0 && aTip.y <= height) {
59.         dir.add(gravity);
60.         pos.add(dir);
61.       } else {
62.         stuck = true;
63.       }
64.     }
65.   }
66.  
67.   void display() {
68.     pushMatrix();
69.     translate(pos.x, pos.y);
70.     rotate(atan2(dir.y, dir.x));
71.     stroke(0);
72.     line(0, 0, arrowLength, 0);
73.     line(0, 0, -6, -4);
74.     line(0, 0, -6,  4);
75.     translate(arrowLength, 0);
76.     noStroke();
77.     beginShape();
78.     vertex(10,0);
79.     vertex(-6,-6);
80.     vertex(0,0);
81.     vertex(-6,6);
82.     endShape();
83.     popMatrix();
84.   }
85. }