Processing Forum

Screen name:
gbautista89

gbautista89's Profile

2 Posts

0 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

Multiple key pressed Problem for shooting game

[1 Reply]
- 09-Dec-2010 11:09 AM
- Forum: Programming Questions
Hello!
I made this simple game for a class. I am running into a few problems. First of all, the shooter at the bottom cannot move and shoot at the same time, which is a big downfall in terms of the interactivity. The other problem I have is with the swinging line at the top. The moving target is supposed to bounce off the line, which it does for the most part, but sometimes it does not. Maybe there is an error that I cannot catch?
For the game, you choose a color, then shoot the opposite color, using the left and right arrow keys to move and the space bar to shoot.

Any advice helps, thanks!
1. int page=1;
2. PFont font;
3. //CIRCLE
4. float circleX=240;
5. float circleY=160;
6. float circleR=25;
7. float speedX = 2.5;
8. float lastStart;
9. float m;
10. int start;
11. float time=.01;
12. float speedY = 1.0;
13. int directionX = 1;
14. int directionY = -1;
16. //RECTANGLE SHOOTER
17. float rectX=240;
18. float rectY=300;
20. //RECTANGLE PENDULUM
21. float rectPx=22.5;
22. float rectPy=-30;
23. //float rectPh=200;
24. //float rectPw=45;
25. float rectR=0;
26. float speedP=1;
27. float directionP=radians(1);
28. float pendX=240;
29. float pendY=-10;
30. float pendX2;
31. float pendY2;
32. float angle;
34. //CIRCLE COLOR CHANGE
35. float pinkR=252;
36. float pinkG=71;
37. float pinkB=145;
38. float blueR=33;
39. float blueG=146;
40. float blueB=249;
41. float currentR;
42. float currentG;
43. float currentB;
44. float r=252;
45. float g=71;
46. float b=145;
47. float speedC=1;
48. float colorCr=1.5;
49. float colorCg=1.5;
50. float colorCb=1.5;
52. //BULLET
53. float bullX=240;
54. float bullY=300;
55. float bullR=3;
57. // BOOLEANS
58. boolean Blue=false;
59. boolean Pink=false;
60. boolean shoot=false;
61. boolean move= true;
62. boolean right=false;
63. boolean left=false;
64. boolean hitting=false;
66. //score
67. int score=0;
69. PImage instruct;
71. void setup() {
72. size(480,320);
73. smooth();
74. rectMode(CENTER);
75. ellipseMode(RADIUS);
76. font=loadFont("AndaleMono-40.vlw");
77. start=millis();
78. instruct= loadImage("instruct.jpg");
79. lastStart=0;
80. }
82. void draw() {
84. if(page==1) {
85. intro();
86. }
88. if (page==2) {
89. gameStartPINK();
90. }
91. if (page==3){
92. restart();}
93. if (page==4){
94. gameStartBLUE();
95. }
96. }
99. void intro() {
100. noStroke();
101. background(0);
102. fill(75);
103. textSize(24);
104. text("CHOOSE A COLOR.",133,220);
105. ///ADD INTRO PAGE---------------------------------------------------
106. fill(252,71,145);
107. rect(160,120,100,100);
108. fill(33,146,249);
109. rect(320,120,100,100);
110. lastStart=millis();
112. if(mousePressed && move) {
113. float d=dist(mouseX,mouseY,210,170);
114. if(d<100){
115. page=2;
116. move=false;
117. }}
118. if(mousePressed && move) {
119. float d=dist(mouseX,mouseY,370,170);
120. if(d<100){
121. page=4;
122. move=false;
123. }}
124. }
126. //BEGIN GAME CHOOSE PINK==========================================
128. void gameStartPINK() {
129. background(0);
130. m=millis()-lastStart;
131. println("m equals"+ m);
132. textSize(10);
133. text("SCORE:"+ score,410,15);
134. //BOTTOM RECTANGLE SHOOTER================================
135. fill(75);
136. noStroke();
137. float Rx=constrain(rectX,30,width-30);
138. rect(Rx,rectY,20,20);
141. //CIRCLE TARGET COLOR START PINK============================================
142. currentR=r;
143. currentG=g;
144. currentB=b;
145. println(currentR + " " + currentG + " " + currentB);
147. fill(currentR,currentG,currentB);
149. r-=speedC*colorCr;
150. if((r>=252) || (r<=33)) {
151. colorCr=-colorCr;
152. }
153. g+=speedC*colorCg;
154. if((g<=71) || (g>=146)) {
155. colorCg=-colorCg;
156. }
158. b+=speedC*colorCb;
159. if((b<=145) || (b>=249)) {
160. colorCb=-colorCb;
161. }
162. // CIRCLE TARGET=========================================
163. noStroke();
164. ellipse(circleX,circleY,circleR,circleR);
165. circleX += (speedX+m/10000) * directionX;
167. if ((circleX > width-circleR) || (circleX < circleR)) {
168. directionX = -directionX;
169. }
170. circleY += speedY * directionY;
171. if ((circleY > 252) || (circleY < circleR)) {
172. directionY = -directionY;
173. }
176. if (key == CODED) {
177. if (keyCode == LEFT) {
178. if (keyPressed == true) {
179. rectX-=6;
180. }
181. }
182. }
184. if (key == CODED) {
185. if (keyCode == RIGHT) {
186. if (keyPressed == true) {
187. rectX+=6;
188. }
189. }
190. }
192. // COLOR BOOLEAN===================================
194. if(currentR<=114 && currentR>=33) {
196. Blue=true;
197. }
198. else {
199. Blue=false;
200. }
201. if(Blue) {
202. println("BLUE");
203. }
204. // PENDULUM================================
206. float pendX2=((cos(angle))*250)+width/2;
207. float pendY2=(sin(angle))*250;
208. angle+=speedP*directionP;
209. stroke(75);
210. strokeWeight(5);
211. strokeCap(SQUARE);
212. line(pendX,pendY,pendX2,pendY2);
214. if((angle>PI) || (angle<0)) {
215. directionP=-directionP;
216. }
218. if (side(pendX,pendY,pendX2,pendY2,circleX,circleY)<0){
219. left=true;
220. }
222. if (side(pendX,pendY,pendX2,pendY2,circleX,circleY)>0){
223. right=true;
224. }
226. //TARGET HIT PENDLULUM LEFT SIDE
227. if (circleLineIntersect(pendX, pendY,pendX2,pendY2, circleX, circleY, circleR) == true){
228. hitting=true;}
229. if (hitting ==true && left==true){
230. directionX=-directionX;
231. speedX=4.5;
232. hitting=false;
233. circleR=random(7,25);
234. }
236. //TARGET HIT PENDULUM RIGHT SIDE
237. if (hitting ==true && right==true){
238. directionX=-directionX;
239. speedX=4.5;
240. hitting=false;
241. circleR=random(7,25);
242. }
244. // SHOOT BOOLEAN=======================
245. fill(75);
246. noStroke();
247. float Bx= constrain(bullX,30,width-40);
248. ellipse(Bx,bullY,bullR,bullR);
249. if (shoot == true) {
250. bullY = bullY - 35;
251. }
253. if (bullY < -10) {
254. shoot = false;
255. }
257. if (circlecircleIntersect(circleX,circleY,circleR,bullX,bullY,bullR) == true) {
258. if(Blue == true) {
259. shoot=false;
260. score+=1;
261. println(score);
262. }
263. }
265. if (circlecircleIntersect(circleX,circleY,circleR,bullX,bullY,bullR) == true && shoot ==true) {
266. if(Blue == false) {
267. shoot=false;
268. time=m;
269. page=3;
270. }
271. }
273. if(shoot == false) {
274. bullY=300;
275. }
277. if (key == CODED) {
278. if (keyCode == LEFT) {
279. if (keyPressed == true) {
280. bullX-=6;
281. }
282. }
283. }
285. if (key == CODED) {
286. if (keyCode == RIGHT) {
287. if (keyPressed == true) {
288. bullX+=6;
289. }
290. }
291. }
293. }
295. // BEGIN GAME CHOOSE BLUE===============================================
296. void gameStartBLUE() {
297. background(0);
298. m=millis()-lastStart;
299. println("m equals"+ m);
300. textSize(10);
301. text("SCORE:"+ score,410,15);
302. //BOTTOM RECTANGLE SHOOTER================================
303. fill(75);
304. noStroke();
305. float Rx=constrain(rectX,30,width-30);
306. rect(Rx,rectY,20,20);
309. //CIRCLE TARGET COLOR START BLUE============================================
310. currentR=r;
311. currentG=g;
312. currentB=b;
313. println(currentR + " " + currentG + " " + currentB);
315. fill(currentR,currentG,currentB);
317. r-=speedC*colorCr;
318. if((r>=252) || (r<=33)) {
319. colorCr=-colorCr;
320. }
321. g+=speedC*colorCg;
322. if((g<=71) || (g>=146)) {
323. colorCg=-colorCg;
324. }
326. b+=speedC*colorCb;
327. if((b<=145) || (b>=249)) {
328. colorCb=-colorCb;
329. }
330. // CIRCLE TARGET=========================================
331. noStroke();
332. ellipse(circleX,circleY,circleR,circleR);
333. circleX += (speedX+ (m/10000)) * directionX;
335. if ((circleX > width-circleR) || (circleX < circleR)) {
336. directionX = -directionX;
337. }
338. circleY += speedY * directionY;
339. if ((circleY > 252) || (circleY < circleR)) {
340. directionY = -directionY;
341. }
344. if (key == CODED) {
345. if (keyCode == LEFT) {
346. if (keyPressed == true) {
347. rectX-=6;
348. }
349. }
350. }
352. if (key == CODED) {
353. if (keyCode == RIGHT) {
354. if (keyPressed == true) {
355. rectX+=6;
356. }
357. }
358. }
360. // COLOR BOOLEAN===================================
362. if(currentR<=252 && currentR>=216) {
364. Pink=true;
365. }
366. else {
367. Pink=false;
368. }
369. if(Pink) {
370. println("PINK");
371. }
372. // PENDULUM================================
374. float pendX2=((cos(angle))*250)+width/2;
375. float pendY2=(sin(angle))*250;
376. angle+=speedP*directionP;
377. stroke(75);
378. strokeWeight(5);
379. strokeCap(SQUARE);
380. line(pendX,pendY,pendX2,pendY2);
382. if((angle>PI) || (angle<0)) {
383. directionP=-directionP;
384. }
386. if (side(pendX,pendY,pendX2,pendY2,circleX,circleY)<0){
387. left=true;
388. }
390. if (side(pendX,pendY,pendX2,pendY2,circleX,circleY)>0){
391. right=true;
392. }
394. //TARGET HIT PENDLULUM LEFT SIDE
395. if (circleLineIntersect(pendX, pendY,pendX2,pendY2, circleX, circleY, circleR) == true){
396. hitting=true;}
397. if (hitting ==true && left==true){
398. directionX=-directionX;
399. speedX=4.5;
400. hitting=false;
401. circleR=random(7,25);
402. }
404. //TARGET HIT PENDULUM RIGHT SIDE
405. if (hitting ==true && right==true){
406. directionX=-directionX;
407. speedX=4.5;
408. hitting=false;
409. circleR=random(7,25);
410. }
414. // SHOOT BOOLEAN=======================
415. fill(75);
416. noStroke();
417. float Bx= constrain(bullX,30,width-40);
418. ellipse(Bx,bullY,bullR,bullR);
419. if (shoot == true) {
420. bullY = bullY - 35;
421. }
423. if (bullY < -10) {
424. shoot = false;
425. }
427. if (circlecircleIntersect(circleX,circleY,circleR,bullX,bullY,bullR) == true) {
428. if(Pink == true) {
429. shoot=false;
430. score+=1;
431. println(score);
432. }
433. }
435. if (circlecircleIntersect(circleX,circleY,circleR,bullX,bullY,bullR) == true && shoot==true) {
436. if(Pink == false) {
437. shoot=false;
438. page=3;
439. }
440. }
442. if(shoot == false) {
443. bullY=300;
444. }
446. if (key == CODED) {
447. if (keyCode == LEFT) {
448. if (keyPressed == true) {
449. bullX-=6;
450. }
451. }
452. }
454. if (key == CODED) {
455. if (keyCode == RIGHT) {
456. if (keyPressed == true) {
457. bullX+=6;
458. }
459. }
460. }
462. }
463. //CIRCLE LINE INTERSECT FUNCTION===============================================
465. float side ( float Sx1, float Sy1, float Sx2, float Sy2, float pointSx, float pointSy )
466. {
467. return (Sx2 - Sx1) * (pointSy - Sy1) - (Sy2 - Sy1) * (pointSx - Sx1);
468. }
470. boolean circlecircleIntersect(float Cx1, float Cy1, float Cr1, float Cx2, float Cy2, float Cr2) {
471. return dist(Cx1, Cy1, Cx2, Cy2) < Cr1 + Cr2;
472. }
474. //Following code adapted from http://www.openprocessing.org/visuals/?visualID=8009
476. boolean circleLineIntersect(float x1, float y1, float x2, float y2, float cx, float cy, float cr ) {
477. float dx = x2 - x1;
478. float dy = y2 - y1;
479. float a = dx * dx + dy * dy;
480. float b = 2 * (dx * (x1 - cx) + dy * (y1 - cy));
481. float c = cx * cx + cy * cy;
482. c += x1 * x1 + y1 * y1;
483. c -= 2 * (cx * x1 + cy * y1);
484. c -= cr * cr;
485. float bb4ac = b * b - 4 * a * c;
487. //println(bb4ac);
489. if (bb4ac < 0) { // Not intersecting
490. return false;
491. }
492. else {
494. float mu = (-b + sqrt( b*b - 4*a*c )) / (2*a);
495. float ix1 = x1 + mu*(dx);
496. float iy1 = y1 + mu*(dy);
497. mu = (-b - sqrt(b*b - 4*a*c )) / (2*a);
498. float ix2 = x1 + mu*(dx);
499. float iy2 = y1 + mu*(dy);
501. // The intersection points
502. //ellipse(ix1, iy1, 10, 10);
503. //ellipse(ix2, iy2, 10, 10);
505. float testX;
506. float testY;
507. // Figure out which point is closer to the circle
508. if (dist(x1, y1, cx, cy) < dist(x2, y2, cx, cy)) {
509. testX = x2;
510. testY = y2;
511. }
512. else {
513. testX = x1;
514. testY = y1;
515. }
517. if (dist(testX, testY, ix1, iy1) < dist(x1, y1, x2, y2) || dist(testX, testY, ix2, iy2) < dist(x1, y1, x2, y2)) {
518. return true;
519. }
520. else {
521. return false;
522. }
523. }
524. }
526. void keyPressed() {
527. if (key == ' ') {
528. shoot=true;
529. }
530. }
532. //RESTART================================================
533. void restart(){
534. background(0);
535. fill(75);
536. textSize(50);
537. text("YOU LOSE",120,160);
538. fill(255);
539. textSize(10);
540. text("Click to restart.",200,180);
541. score=0;
544. if(mousePressed && move){
545. move=false;
546. page=1;
547. }
548. }
551. //MOVE BOOLEAN===================================
552. void mouseReleased()
553. {
554. move=true;
555. }

Circle Line Intersect Reaction

[2 Replies]
- 01-Dec-2010 08:50 AM
- Forum: Programming Questions
Hello!

I am new to processing and this is my first attempt at a simple game. A pendulum swinging at the top of the window interacts with a moving target, the pendulum being a line and the target a circle. I want the circle to rebound off the pendulum when they intersect. So far I have been able to detect if there is an intersection and which side of the line the intersection happens on. But, when I try to reverse the x direction, after an intersection, to look like the circle is bouncing off, the circle freaks out.

Any suggestions?

Here is my code so far:

//circle target

noStroke();

  ellipse(circleX,circleY,circleR,circleR);

  circleX += (speedX+(millis()/8000)) * directionX;

  if ((circleX > width-circleR) || (circleX < circleR)) {

   directionX = -directionX;

  }

  circleY += speedY * directionY;

  if ((circleY > height-circleR) || (circleY < circleR)) {

   directionY = -directionY;

  }

//pendulum

  float pendX2=((cos(angle))*250)+width/2;

  float pendY2=(sin(angle))*250;

  angle+=speedP*directionP;

  stroke(75);

  strokeWeight(5);

  strokeCap(SQUARE);

  line(pendX,pendY,pendX2,pendY2);

  if((angle>PI) || (angle<0)) {

   directionP=-directionP;

  }

  if (circleLineIntersect(pendX, pendY,pendX2,pendY2, circleX, circleY, circleR) == true ) {

   if(side(pendX,pendY,pendX2,pendY2,circleX,circleY)<0) {

   println("LEFT");

   directionX=-directionX;

   }

  }

//booleans

float side ( float Sx1, float Sy1, float Sx2, float Sy2, float pointSx, float pointSy )

{

  return (Sx2 - Sx1) * (pointSy - Sy1) - (Sy2 - Sy1) * (pointSx - Sx1);

}

boolean circlecircleIntersect(float Cx1, float Cy1, float Cr1, float Cx2, float Cy2, float Cr2) {

  return dist(Cx1, Cy1, Cx2, Cy2) < Cr1 + Cr2;

}

//Adapted from C.Reas on OpenProcessing

boolean circleLineIntersect(float x1, float y1, float x2, float y2, float cx, float cy, float cr ) {

  float dx = x2 - x1;

  float dy = y2 - y1;

  float a = dx * dx + dy * dy;

  float b = 2 * (dx * (x1 - cx) + dy * (y1 - cy));

  float c = cx * cx + cy * cy;

  c += x1 * x1 + y1 * y1;

  c -= 2 * (cx * x1 + cy * y1);

  c -= cr * cr;

  float bb4ac = b * b - 4 * a * c;

  //println(bb4ac);

  if (bb4ac < 0) { // Not intersecting

   return false;

  }

  else {

   float mu = (-b + sqrt( b*b - 4*a*c )) / (2*a);

   float ix1 = x1 + mu*(dx);

   float iy1 = y1 + mu*(dy);

   mu = (-b - sqrt(b*b - 4*a*c )) / (2*a);

   float ix2 = x1 + mu*(dx);

   float iy2 = y1 + mu*(dy);

   // The intersection points

   //ellipse(ix1, iy1, 10, 10);

   //ellipse(ix2, iy2, 10, 10);

   float testX;

   float testY;

   // Figure out which point is closer to the circle

   if (dist(x1, y1, cx, cy) < dist(x2, y2, cx, cy)) {

   testX = x2;

   testY = y2;

   }

   else {

   testX = x1;

   testY = y1;

   }

   if (dist(testX, testY, ix1, iy1) < dist(x1, y1, x2, y2) || dist(testX, testY, ix2, iy2) < dist(x1, y1, x2, y2)) {

   return true;

   }

   else {

   return false;

   }

  }

}

«Prev
Next »