Processing Forum

hiding joptionpane messagebox

[1 Reply]
- 04-Dec-2011 08:59 AM
- Forum: Programming Questions
Is there a way to hide joptionpane message box. I want to hide this box each time the player dies and the game restarts. I don't wanna use controlP5 method to create message box. It is too much coding for nothing.
1. void MsgBox() {
2. javax.swing.JOptionPane.showMessageDialog(null, "<html>My Breakout Game Remix<br>INSTRUCTIONS<br> 1.Avoid hitting with the balls at all cost.<br> 2.If you die. It's game over.<br> 3.You will be asked for number of balls input, When you will die.Challenge yourself with more balls.");
3. }

adding scoring and sound in breakout game

[14 Replies]
- 30-Nov-2011 08:24 AM
- Forum: Programming Questions
Like my title says i wanna add scoring and sound when ball hitting the brick and also when ball hits ground the game ends. Any help would be apprieciated.
1. /********************GLOBAL VARIABLES********************************************/
2. // variable of type Rectangle:
3. //This variable represents the game "board" - a game is played within the gameFrame...
4. float r = random (0, 255);
5. float g = random (0, 255);
6. float b = random (0, 255);
7. Rectangle gameFrame;
8. // variable to hold an array of objects of type Brick
9. Brick[] bricks;
10. // variable of type Paddle that represents a paddle
11. Paddle paddle;
12. // variable to hold an array of objects of type Ball
13. Ball[] balls;
14. int frameNum = 0;
15. // THE SCREEN PROPERTIES :
16. int screenWidth = 800;
17. int screenHeight = 400;
18. color backgroundColor = #333F48;
19. boolean backgroundRefreshes = true;
20. // THE GAME FRAME PROPERTIES:
21. int gameFrameWidth = 400;
22. int gameFrameHeight = 400;
23. color gameFrameStroke = #333F48;
24. boolean gameFrameHasStroke = false;
25. color gameFrameFill = #333F48;
26. int opacityOfRefresh = 255;
27. boolean gameFrameRefreshes = true;
28. float spin = 0.0;
29. int recX = (screenWidth-gameFrameWidth)/2;
30. int recY = (screenHeight-gameFrameHeight)/2;
31. /********************SET UP FUNCTION********************************************
32. This function sets up the startup properties for a new game session
33. - occurs before a new game starts
34. ******************************************************************************/
35. void setup() {
36. size(screenWidth, screenHeight, P3D);
37. background(r, g, b);
38. frameRate(60);
39. // Instantiate the necessary objects for a new game
40. // create a rectanle object to represnt the game frame
41. gameFrame = new Rectangle(gameFrameWidth, gameFrameHeight, gameFrameHasStroke, gameFrameStroke, true, gameFrameFill);
42. gameFrame.opacity = opacityOfRefresh;
43. // call the function to create the Bricks for a new game session
44. createBricks();
45. // call the function to create the Balls for a new game session
46. createBalls();
47. paddle = new Paddle();
48. // call the function to refresh the screen
49. refreshScreen();
50. }
51. /********************DRAW FUNCTION*******************************************
52. This function is the function that starts a new game and the progam will
53. continuously loop in this function for the duration of the program lifecycle
54. - (until we quit a game)
55. ***************************************************************************/
56. void draw() {
58. // translate(width, height/2, 50);
59. // rotateY(map(mouseX, 0, width, 0, PI));
60. // rotateX(map(mouseY, 0, height, 0, PI));
61. // box(150);
62. rotateX(radians(35));
63. rotateZ(radians(10));
64. translate(50,-170,20);
65. rotateY(radians(25));
66. // scale(.9);
67. // rotateZ(radians(28));
68. // translate(110, -200);
69. // call the refreshScreen function
70. //(will update all the necessary properties, objects and game state)
71. refreshScreen();
72. // call saveScreenShots()
73. saveScreenshots();
74. }
75. /********************createBalls() FUNCTION**********************************
76. This function is called when we want to define and create the balls.
77. This function takes no arguements and does not return anything
78. ***************************************************************************/
79. void createBalls() {
80. // Local Variables for Ball Properties
81. //make changes here to the ball numbers
82. int numberOfBalls = 30;
83. int yBalls = 60;
84. //assign the balls variable to be an array of Ball objects -
85. //the array will hold "numberOfBalls" = 1 object ( have only 1 ball at the time in a game)
86. balls = new Ball[numberOfBalls];
87. for (int i=0; i<numberOfBalls; i++) {
88. int x = i*20;
89. /***** This line is fundamental: as it will create a new Ball object with the specified parameters
90. and will put the instantiated Ball object into our "ball" array.************************************/
91. balls[i] = new Ball(x, yBalls);
92. }
93. }
94. /********************createBricks() FUNCTION**********************************
95. This function is called when we want to define and create the bricks
96. The function takes no arguments and does not return anything
97. ****************************************************************************/
98. void createBricks() {
99. // Local Variables for Brick Group Properties
100. int numberOfBricks = 80;//80 make change here
101. int bricksPerRow = 6; //6 make change here
102. int brickWidth = gameFrameWidth/bricksPerRow;
103. int brickHeight = 20; //60 make change here
104. boolean brickHasStroke = false;
105. color brickStroke = #8E8B82; //60 make change here
106. boolean brickHasFill = true;
107. color brickFill = #ff0000; //60 make change here
108. int yBricks = 50;
109. //make change here
110. color[] rowsColors = {
111. #01DAF5, #A6D7DE, #ff9900, #ff9900, #00DAF5, #ff9900, #00DAF5
112. };
114. // Create the bricks
115. //assign the brick variable to be an array of Brick objects - the array will hold "numberOfBricks" =60 objects
116. bricks = new Brick[numberOfBricks];
117. // use a for loop to put 60 Brick objects into the array named "brick"
118. for (int i=0; i<numberOfBricks; i++)
119. {
120. // to keep track of the row we are on
121. int rowNum = i/bricksPerRow;
122. // coords for creating a brick
123. int x = brickWidth*i;
124. x -= rowNum*bricksPerRow*brickWidth;
125. int y = yBricks+i/bricksPerRow*brickHeight;
126. // variable used for determination of the colour of a brick
127. // rowColors = an array of colors
128. // min() is an inbuilt function which will return the minimum value between its two arguements
129. int num = min(rowNum, rowsColors.length-1);
130. // choose a colour based on the value of num
131. color rowColor = rowsColors[num];
132. /***** This line is fundamental: as it will create a new Brick object with the specified parameters
133. and will put the instantiated Brick object into our "bricks" array.************************************/
134. bricks[i] = new Brick(x, y, brickWidth, brickHeight, brickHasStroke, brickStroke, brickHasFill, rowColor);
135. }
136. }
137. /********************refreshScreen() FUNCTION**********************************
138. This function is called when we want to refresh the game properties and/or update
139. the state of the game.
140. This function takes no arguements and does not return anything
141. ******************************************************************************/
142. void refreshScreen() {
143. // condition for refreshing the Background
144. // check if this (global) boolean is TRUE...
145. if (backgroundRefreshes) {
146. background (backgroundColor);
147. //background(r,g,b);
148. }
149. // condition for refreshing the GameFrame
150. // check if this (global) boolean is TRUE...
151. if (gameFrameRefreshes) {
152. // call this function: located in the Rectangle class - because the gameFrame is an object of type Rectangle
153. gameFrame.drawYourself();
154. }
155. // PADDLE
156. // Update paddle Properties
157. // call the refresh() function for the Paddle object (the function is in the Paddle class...)
158. paddle.refresh();
159. // BRICKS
160. // Update the bricks array
161. // within the for loop call the refresh() function for every Brick oject currently within the bricks array
162. //(the function is within the Bricks class...)
163. for (int i=0; i<bricks.length; i++) {
164. bricks[i].refresh();
165. }
166. // BALLS
167. //Update the balls array
168. // within the for loop call the refresh() function for every Ball oject currently within the balls array
169. //(the function is within the Ball class...)
170. for (int i=0; i<balls.length; i++) {
171. balls[i].refresh();
172. }
173. }
174. /********************saveScreenShots() FUNCTION**********************************
175. This function is for saving screen shots of the game ...
176. Be careful with this function - only change if you know what you're doing
177. the hard disk could fill up with images in a few minutes
178. press the 'G' key to save frames in TGA pictures in 'saved' folder
179. *******************************************************************************/
180. void saveScreenshots() {
181. frameNum++;
182. if (keyPressed) {
183. if (key == 'g' || key == 'G') {
184. if (frameNum%2==0) {
185. saveFrame("saved/frame-####.tga");
186. }
187. }
188. }
189. }
this is ball class

Copy code
1. // import the necessary library
2. import java.awt.geom.*;
3. /********************************************************************************
4. Defintion of the Ball Class:
5. The Ball class has dual functionality:
6. First: It is used to create an instance of a ball object
7. Second: A ball instance will detect if it is touching a brick,
8. the paddle or the bounding limits of the game frame. Therefore the ball class contains
9. the necessary functions for detecting any collision with the other above mentioned
10. objects that are instantiated in the game session ...
11. *********************************************************************************/
12. public class Ball {
13. // Define an a local variable "rectangle" to represent an object of type Rectangle
14. Rectangle rectangle;
15. // local Variables that represent the properties of a Brick object
16. int width = 10; // make change here to the ball
17. int height = 10; // make change here to the ball
18. boolean hasStroke = true;
19. color strokeColor = #550F48; //#333F48 make change here
20. boolean hasFill = true;
21. color fillColor = #102F48; //#333F48 make change here
22. // velocity
23. int velX = 4; //4 make change here
24. int velY = 2; //4 make change here
25. // positioning variables
26. int x;
27. int y;
28. int ox;
29. int oy;
30. int xcentre;
31. int ycentre;
32. /********************************************************************************
33. Ball Class Default Constructor:
34. In order to create an Instance of a Ball Object, one needs to invoke
35. the Default Constructor in the following manner: new Ball(tempX,tempY).
36. The Ball Constructor makes an instance of the Rectangle Class.
37. /********************************************************************************/
38. Ball(int newX, int newY) {
39. x = newX;
40. y = newY;
41. // make an instance of the Rectangle object (the ball is a rectangle...)
42. rectangle = new Rectangle(width, height, hasStroke, strokeColor, hasFill, fillColor);
43. // call the setPosition() function of the rectangle ( the function is within the Rectangle class...)
44. rectangle.setPosition(x, y);
46. }
47. /********************************************************************************
48. Function: refresh()
49. Returns: nothing.
50. Maintains the state of the given Ball on the Screen.
51. The refresh() method calls the updatePosition() method, and there after
52. the setPosition() and finally redraws itself to the screen (with the drawYourself()).
53. **********************************************************************************/
54. void refresh() {
55. // call this function that is local to this class
56. updatePosition();
57. rectangle.setPosition(x, y);
58. rectangle.drawYourself();
59. // Remember that a Brick has been defined as an object rectangle of type Rectangle.
60. // Therefore the drawYourself()&setPosition() functions are within the Rectangle Class...
61. }
62. /********************************************************************************
63. Function: updatePosition()
64. Returns: nothing.
65. Calculates the "real" time positioing of the Ball. Within this function
66. are also the calls to the function to check if the ball
67. has collided with another object.
68. *********************************************************************************/
69. void updatePosition() {
70. // add velocity to position- this simulates the ball movemnet( we update the x and y position of the ball...
71. x+=velX;
72. y+=velY;
73. // collision with limits for "x"
74. if (x<=0 || x>=gameFrameWidth-width) {
75. // set the velocity for the x Position
76. velX = -velX;
77. // the constrain() will make sure that "x" does not go less than 0 and not greater than (gameFrameWidth-width)
78. x = constrain(x, 0, gameFrameWidth-width);
79. }
80. // collision with limits for "y"
81. if (y<=0 || y>=gameFrameHeight-height) {
82. velY = -velY;
83. y = constrain(y, 0, gameFrameHeight-height);
84. }
85. xcentre = x+width/2;
86. ycentre = y+height/2;
88. // We check if the ball is colliding with the paddle
89. // input parameter is the "rectangle" variables defined in the Paddle class
90. // Remember: the "paddle" is an object of type Paddle - and this class has an instance variable named "rectangle" ...
91. // This function will return "result"
92. // collision with paddle
93. int result = checkCollisionWithRectangle(paddle.rectangle);
94. // if collides on top, control direction of ball
95. // if (result == 1){
96. //if(xcentre < paddle.rectangle.x1+paddle.rectangle.width/2){
97. // if(velX>0){
98. // velX = -velX*2;
99. // }
100. // }else{
101. // if(velX<0){
102. // velX = -velX/3;
103. //}
104. //}
105. // }
106. //We detect collision with the bricks if the result is "0"
107. if (result == 0) {
108. // iterate through the array of Bricks
109. for (int i=0; i<bricks.length; i++) {
110. // Check if the brick is alive ( imAlive is a boolean - so if TRUE...)
111. if (bricks[i].imAlive) {
112. /*We check if the ball is collidiing with the paddle
113. Input parameter is the "rectangle" variables defined in the Brick class
114. Remember: the "bricks[i]" is an object of type Brick - and this class has
115. an instance variable named "rectangle" (Every brick instance has its own "rectangle" var)*/
116. // This function will return "res"
117. int res = checkCollisionWithRectangle(bricks[i].rectangle);
118. // if the returned "res" s not 0 then kill this brick.
119. if (res != 0) {
120. bricks[i].die();
121. break;
122. }
123. }
124. }
125. }
126. // keep track of the current x and y vars (make a copy)
127. ox = x;
128. oy = y;
129. }
130. /********************************************************************************
131. Function: checkCollisionWithRectangle()
132. Input Paramer: A Rectangle "tempRect"
133. Returns: an integer:
134. result: 0: no collision 1: top 2: right 3: bottom 4: left 5: couldn't detect which side
135. *********************************************************************************/
136. int checkCollisionWithRectangle (Rectangle R) {
137. // define the result variable
138. int result = 0;
139. // check if the rectangle given (ie the paddle) is being touched by the ball
140. // xcentre, ycentre are ball position variables
141. // doesPointTouchMe() is located in the Rectangle class...
142. // if it returns TRUE then execute this clause
143. if (R.doesPointTouchMe(xcentre, ycentre)) {
144. //check which side of the tempRect object has the ball touched.
145. // This line is easier to work with when we want to check how
146. //the ball has collided with the Rectangle object instead of using the ball itself...
147. Line2D lineaBola = new Line2D.Float(xcentre, ycentre, ox+width/2, oy+height/2);
148. // whatSideDoesLineTouch() is located in the Rectangle class...
149. // if it returns TRUE then execute this clause
150. result = R.whatSideDoesLineTouch(lineaBola, velX, velY);
151. // have to perhaps change the position & velocity parameters of the ball
152. // top
153. if (result==1) {
154. velY = -velY;
155. y = R.y1-height;
156. // right
157. }
158. else if (result==2) {
159. velX = -velX;
160. x = R.x2;
161. // bottom
162. }
163. else if (result==3) {
164. velY = -velY;
165. y = R.y2;
166. // left
167. }
168. else if (result==4) {
169. velX = -velX;
170. x = R.x1-width;
171. }
172. else {
173. result = 20;
174. }
175. }
176. // return the correct result ... also remember
177. //if this result!=0 then the brick touched will die...
178. return result;
179. }
180. /*********************************************************************************/
181. }// End of Ball Class Definition
Brick class

Copy code
1. /********************************************************************************
2. Defintion of the Brick Class:
3. The Brick Class is used to define a Brick object in the game.
4. It makes use of the Rectangle Class.
5. **********************************************************************************/
6. public class Brick
7. {
8. // Define an a local variable "rectangle" to represent an object of type Rectangle
9. Rectangle rectangle;
10. // local Variables that represent the properties of a Brick object
11. boolean hasStroke = true; //make change here
12. color strokeColor = 0; // make change here
13. boolean hasFill = true; //make change here
14. color fillColor = 157; // make change here
15. //
16. int x = 500; //make change here
17. int y = 100; //make change here
18. //
19. boolean respawns = true; //make change here
20. int timeToRespawn = 20; // time is in frames
21. // time is in frames
22. int frame;
23. boolean imAlive;
24. /********************************************************************************
25. Brick Class Default Constructor:
26. In order to create an Instance of a Brick Object, one needs to invoke
27. the Default Constructor in the following manner:
28. new Brick(rectX, rectY, rectWidth,rectHeight, hasStroke, strokeDef, hasFill, fillColour).
29. The Brick Constructor makes an instance of the Rectangle Class.
30. /********************************************************************************/
31. Brick(int X, int Y, int W, int H, boolean HASSTROKE, color STROKE, boolean HASFILL, color FILL) {
32. // make an instance of the Rectangle object
33. rectangle = new Rectangle(W, H, HASSTROKE, STROKE, HASFILL, FILL);
34. // call the setPosition() function of the rectangle ( the function is within the Rectangle class...)
35. rectangle.setPosition(X, Y);
36. imAlive = false;
37. }
38. /********************************************************************************
39. Function: refresh()
40. Returns: nothing.
41. Maintains the state of the given Brick on the Screen.
42. The refresh() method checks the state of the Brick (alive or dead)
43. / if a new one should be created - if it is alive it will call the drawYourself().
44. **********************************************************************************/
45. void refresh() {
46. if (imAlive) {
47. // Remember that a Brick has been defined as an object rectangle of type Rectangle.
48. // Therefore the drawYourself() function is within the Rectangle Class...
49. rectangle.drawYourself();
50. }
51. else {
52. if (respawns) {
53. frame++;
54. if (frame>timeToRespawn-10) {
55. // rise up from your grave, brick
56. imAlive=true;
57. }
58. }
59. }
60. }
61. /********************************************************************************
62. Function: die()
63. Returns: nothing.
64. Maintains the state of a Brick. If a Brick is "dead", it is removed from the screen.
65. *********************************************************************************/
66. void die() {
67. imAlive = false;
68. frame = 2;
69. }
70. }// End of Brick Class Definition
paddle class

/********************************************************************************
Defintion of the Paddle Class:
The Paddle Class is used to define the Paddle object in the game.
It makes use of the Rectangle Class.
*********************************************************************************/

public class Paddle {

Copy code
1. /********************************************************************************
2. Paddle Class Instance Variables:
3. These Instance Variables will be initialised(defined)when an Instance of the
4. Paddle Class is invoked by calling the default constructor new Paddle().
5. /*********************************************************************************/
6. // Define an a local variable "rectangle" to represent an object of type Rectangle
7. Rectangle rectangle;
8. // Paddle Variables
9. int width = 200;
10. int height = 50;
11. // boolean variables
12. boolean hasStroke = false;
13. boolean hasFill = true;
14. // color variables make change here
15. //#333F48
16. color strokeColor = #102F48;
17. //#333F48
18. color fillColor = #100F48;
19. //
20. int x = gameFrameWidth/2;
21. int y = 370;
22. /********************************************************************************
23. Paddle Class Default Constructor -
24. In order to create an Instance of a Paddle Object, one needs to invoke
25. the Default Constructor in the following manner new Paddle().
26. The Paddle Class makes an instance of the Rectangle Class.
27. *********************************************************************************/
28. Paddle() {
29. rectangle = new Rectangle(width, height, hasStroke, strokeColor, hasFill, fillColor);
30. rectangle.setPosition(x, y);
31. }
32. /********************************************************************************
33. Function: refresh()
34. Returns: nothing.
35. Maintains the Position of the Paddle on the Screen.
36. The refresh() method call the updatePosition() method, and there after
37. the setPosition() and redraws itself to the screen (with the drawYourself()).
38. /******************************************************************************** */
39. void refresh() {
40. updatePosition();
41. // Update the Position of the Rectangle (Paddle) Object
42. // this function is in THIS class...
43. rectangle.setPosition(x, y);
44. // now set the position ...
45. rectangle.drawYourself();
46. // Remember that a Paddle has been defined as an object rectangle of type Rectangle.
47. // Therefore the drawYourself() function is within the Rectangle Class...
48. }
49. /********************************************************************************
50. Function: updatePosition()
51. Returns: nothing.
52. Calculates the "real" time positioning of the Paddle.
53. *********************************************************************************/
54. void updatePosition() {
55. x = mouseX-recX-width/2;
56. x = constrain(x, 0, gameFrameWidth-width);
57. }
58. /********************************************************************************/
59. } // End of Paddle Class Definition
rectangle class

Copy code
1. // import the necessary library
2. import java.awt.geom.*;
3. /********************************************************************************
4. Defintion of the Rectangle Class:
5. The Rectangle Class is used to define every visible object in the game
6. (The game frame, the bricks, the paddle and the ball)
7. *********************************************************************************/
8. public class Rectangle {
9. int width;
10. int height;
11. //change here for the color
12. boolean hasStroke = false;
13. color strokeColor;
14. boolean hasFill = true;
15. color fillColor;
16. color opacity;
17. int x1;
18. int y1;
19. int x2;
20. int y2;
21. /********************************************************************************
22. Rectangle Class Default Constructor -
23. In order to create an Instance of a Rectangle Object,
24. one needs to invoke the Default Constructor in the following manner:
25. Rectangle myRectangle = new Rectangle(rectWidth, rectHeight, temp_hasStroke,temp_strokeColor,temp_hasFill,temp_fillColor)
26. /*********************************************************************************/
27. Rectangle(int widthOfRect, int heightOfRect, boolean hasStroke, color strokeColor, boolean fillIsHere, color tempFILL) {
28. // set the values of the instance variables to the given arguements.
29. width = widthOfRect;
30. height = heightOfRect;
31. hasStroke = hasStroke;
32. strokeColor = strokeColor;
33. hasFill = fillIsHere;
34. fillColor = tempFILL;
35. //change here 205
36. opacity = 505;
37. }
38. /*********************************************************************************
39. Function: setPosition(int posX, int posY)
40. Returns: nothing.
41. Set the position of the Rectangle Instance Object and defines the dimensions
42. *********************************************************************************/
43. void setPosition(int newX, int newY) {
44. x1 = newX;
45. y1 = newY;
46. x2 = x1+width;
47. y2 = y1+height;
48. }
49. /*********************************************************************************
50. Function: drawYourself()
51. Returns: nothing.
52. The drawYourself() function is invoked each time the Rectangle is to be drawn on the Screen.
53. The drawYourself() function also checks and applies styling parameters to the Rectangle
54. i.e. Stroke, Fill and the of Dimensions a rectangle.
55. It will also call the inbuilt rect() to draw the shape to the screen...
56. *********************************************************************************/
57. void drawYourself() {
58. // Check if this Rectangle has to a stroke property enabled, if so, apply the stroke property.
59. if (hasStroke) {
60. stroke(strokeColor);
61. }
62. else {
63. noStroke();
64. }
65. // Check if this Rectangle is fill property enabled, if so, apply the fill property.
66. if (hasFill) {
67. fill(fillColor, opacity);
68. }
69. else {
70. noFill();
71. }
72. // Draw the Rectangle and enabled propoerties. make change here
73. rect(recX+x1, recY+y1, width/2, height/2);
74. }
75. /*********************************************************************************
76. Function: doesPointTouchMe()
77. Returns: boolean.
78. The doesPointTouchMe Method implements a collision detetction algorithm, if the points (pX, pY)
79. are discovered to be within the bounds of the Rectangle Object(i.e a Brick, Paddle...).
80. Then the object (ball object) represented by position (pX, pY), indeed touches that Rectangle object.
81. *********************************************************************************/
82. boolean doesPointTouchMe (int PX, int PY) {
83. // Set the return variable to false, assume that the Rectangle is not Touched.
84. boolean result = false;
85. // Check the if pX is found inside the x coordinates of the current Rectangle
86. if (PX >= x1 && PX <= x2) {
87. // Check if pY is found inside the y coordinates of the current Rectangle
88. if (PY >= y1 && PY <= y2) {
89. // If we reach this statement, then the Rectangle has been Touched.
90. result = true;
91. }
92. }
93. return result;
94. }
96. /*********************************************************************************
97. Function: whatSideDoesLineTouch()
98. Input Parameters: tempLine (represents the side of the ball that has touched the other Rectangle object)
99. velX, velY (velocity parameters of the ball)
100. Returns: an int (represnts the side of the touched Rectangle oject) - touched BY the ball..
101. This function determines which side of the Rectangle object that called this function (i.e. a Brick)
102. has been touched by the Ball object
103. /*********************************************************************************/
104. int whatSideDoesLineTouch (Line2D LINE, int VELX, int VELY) {
105. // local variable to represent the side
106. Line2D side;
107. // condition check based on velY value
108. // top touched will return (1) and bottom touched will return(3)
109. if (VELY>0) {
110. // create an instance of a 2D Line
111. side = new Line2D.Float(x1, y1, x2, y1);
112. // check if our line representing the side of the "ball" intersects the side.
113. // Note: the function intersectsLine is deined in the Line2D class which is from the
114. // java.awt.geom library
115. if (LINE.intersectsLine(side)) {
116. return 1;
117. }
118. }
119. else if (VELY<0) {
120. side = new Line2D.Float(x1, y2, x2, y2);
121. if (LINE.intersectsLine(side)) {
122. return 3;
123. }
124. }
125. // left touched will return (4) / right touched will return (2)
126. if (VELX>0) {
127. side = new Line2D.Float(x1, y1, x1, y2);
128. if (LINE.intersectsLine(side)) {
129. return 4;
130. }
131. }
132. else if (VELX<0) {
133. side = new Line2D.Float(x2, y1, x2, y2);
134. if (LINE.intersectsLine(side)) {
135. return 2;
136. }
137. }
138. return 0;
139. }
140. }

Mapping gamemod on each side of a 3d box

[0 Replies]
- 28-Nov-2011 09:46 AM
- Forum: Core Library Questions
Hi guys i wanna map my game mod remix on each side of the 3d box and any help would be appreicated. I am using an internal library called lightGL but i don't know how to map it on the each side. Also how would i go by adding sound each time the ball hits the brick?
1. /**
2. * LightsGL.
3. * Modified from an example by Simon Greenwold.
4. *
5. * Display a box with three different kinds of lights.
6. */
7. import processing.opengl.*;
8. void setup()
9. {
10. size(1024, 768, OPENGL);
11. noStroke();
12. }
13. void draw()
14. {
15. defineLights();
16. background(0);
18. for (int x = 0; x <= width; x += 100) {
19. for (int y = 0; y <= height; y += 100) {
20. pushMatrix();
21. translate(x, y);
22. rotateY(map(mouseX, 0, width, 0, PI));
23. rotateX(map(mouseY, 0, height, 0, PI));
24. box(90);
25. popMatrix();
26. }
27. }
28. }
29. void defineLights() {
30. // Orange point light on the right
31. pointLight(150, 100, 0, // Color
32. 200, -150, 0); // Position
33. // Blue directional light from the left
34. directionalLight(0, 102, 255, // Color
35. 1, 0, 0); // The x-, y-, z-axis direction
36. // Yellow spotlight from the front
37. spotLight(255, 255, 109, // Color
38. 0, 40, 200, // Position
39. 0, -0.5, -0.5, // Direction
40. PI / 2, 2); // Angle, concentration
41. }
when the game start i want the ball to be sticking to the paddle and when mouseclicked it shoots and when it comes back it sticks again. For this do i have to put an if statement in the collisiondetection with the paddle?
here is my code remix
1. /********************GLOBAL VARIABLES********************************************/
2. // variable of type Rectangle:
3. //This variable represents the game "board" - a game is played within the gameFrame...
4. float r = random (0, 255);
5. float g = random (0, 255);
6. float b = random (0, 255);
7. Rectangle gameFrame;
8. // variable to hold an array of objects of type Brick
9. Brick[] bricks;
10. // variable of type Paddle that represents a paddle
11. Paddle paddle;
12. // variable to hold an array of objects of type Ball
13. Ball[] balls;
14. int frameNum = 0;
15. // THE SCREEN PROPERTIES :
16. //int screenWidth = 800;
17. //int screenHeight = 400;
18. color backgroundColor = #333F48;
19. boolean backgroundRefreshes = true;
20. // THE GAME FRAME PROPERTIES:
21. int gameFrameWidth = 400;
22. int gameFrameHeight = 400;
23. color gameFrameStroke = #333F48;
24. boolean gameFrameHasStroke = false;
25. color gameFrameFill = #333F48;
26. int opacityOfRefresh = 255;
27. boolean gameFrameRefreshes = true;
28. float spin = 0.0;
29. int recX = (800-gameFrameWidth)/2;
30. int recY = (400-gameFrameHeight)/2;
31. /********************SET UP FUNCTION********************************************
32. This function sets up the startup properties for a new game session
33. - occurs before a new game starts
34. ******************************************************************************/
35. void setup() {
36. size(800, 400, P2D,P3D);
37. background(r, g, b);
38. frameRate(60);
39. // Instantiate the necessary objects for a new game
40. // create a rectanle object to represnt the game frame
41. gameFrame = new Rectangle(gameFrameWidth, gameFrameHeight, gameFrameHasStroke, gameFrameStroke, true, gameFrameFill);
42. gameFrame.opacity = opacityOfRefresh;
43. // call the function to create the Bricks for a new game session
44. createBricks();
45. // call the function to create the Balls for a new game session
46. createBalls();
47. paddle = new Paddle();
48. // call the function to refresh the screen
49. refreshScreen();
50. }
51. /********************DRAW FUNCTION*******************************************
52. This function is the function that starts a new game and the progam will
53. continuously loop in this function for the duration of the program lifecycle
54. - (until we quit a game)
55. ***************************************************************************/
56. void draw() {
58. // translate(width, height/2, 50);
59. // rotateY(map(mouseX, 0, width, 0, PI));
60. // rotateX(map(mouseY, 0, height, 0, PI));
61. // box(150);
62. rotateX(radians(35));
63. rotateZ(radians(10));
64. translate(50,-170,20);
65. rotateY(radians(25));
66. // scale(.9);
67. // rotateZ(radians(28));
68. // translate(110, -200);
69. // call the refreshScreen function
70. //(will update all the necessary properties, objects and game state)
71. refreshScreen();
72. // call saveScreenShots()
73. saveScreenshots();
74. }
75. /********************createBalls() FUNCTION**********************************
76. This function is called when we want to define and create the balls.
77. This function takes no arguements and does not return anything
78. ***************************************************************************/
79. void createBalls() {
80. // Local Variables for Ball Properties
81. //make changes here to the ball numbers
82. int numberOfBalls = 30;
83. int yBalls = 60;
84. //assign the balls variable to be an array of Ball objects -
85. //the array will hold "numberOfBalls" = 1 object ( have only 1 ball at the time in a game)
86. balls = new Ball[numberOfBalls];
87. for (int i=0; i<numberOfBalls; i++) {
88. int x = i*20;
89. /***** This line is fundamental: as it will create a new Ball object with the specified parameters
90. and will put the instantiated Ball object into our "ball" array.************************************/
91. balls[i] = new Ball(x, yBalls);
92. }
93. }
94. /********************createBricks() FUNCTION**********************************
95. This function is called when we want to define and create the bricks
96. The function takes no arguments and does not return anything
97. ****************************************************************************/
98. void createBricks() {
99. // Local Variables for Brick Group Properties
100. int numberOfBricks = 80;//80 make change here
101. int bricksPerRow = 6; //6 make change here
102. int brickWidth = gameFrameWidth/bricksPerRow;
103. int brickHeight = 20; //60 make change here
104. boolean brickHasStroke = false;
105. color brickStroke = #8E8B82; //60 make change here
106. boolean brickHasFill = true;
107. color brickFill = #ff0000; //60 make change here
108. int yBricks = 50;
109. //make change here
110. color[] rowsColors = {
111. #01DAF5, #A6D7DE, #ff9900, #ff9900, #00DAF5, #ff9900, #00DAF5
112. };
114. // Create the bricks
115. //assign the brick variable to be an array of Brick objects - the array will hold "numberOfBricks" =60 objects
116. bricks = new Brick[numberOfBricks];
117. // use a for loop to put 60 Brick objects into the array named "brick"
118. for (int i=0; i<numberOfBricks; i++)
119. {
120. // to keep track of the row we are on
121. int rowNum = i/bricksPerRow;
122. // coords for creating a brick
123. int x = brickWidth*i;
124. x -= rowNum*bricksPerRow*brickWidth;
125. int y = yBricks+i/bricksPerRow*brickHeight;
126. // variable used for determination of the colour of a brick
127. // rowColors = an array of colors
128. // min() is an inbuilt function which will return the minimum value between its two arguements
129. int num = min(rowNum, rowsColors.length-1);
130. // choose a colour based on the value of num
131. color rowColor = rowsColors[num];
132. /***** This line is fundamental: as it will create a new Brick object with the specified parameters
133. and will put the instantiated Brick object into our "bricks" array.************************************/
134. bricks[i] = new Brick(x, y, brickWidth, brickHeight, brickHasStroke, brickStroke, brickHasFill, rowColor);
135. }
136. }
137. /********************refreshScreen() FUNCTION**********************************
138. This function is called when we want to refresh the game properties and/or update
139. the state of the game.
140. This function takes no arguements and does not return anything
141. ******************************************************************************/
142. void refreshScreen() {
143. // condition for refreshing the Background
144. // check if this (global) boolean is TRUE...
145. if (backgroundRefreshes) {
146. background (backgroundColor);
147. //background(r,g,b);
148. }
149. // condition for refreshing the GameFrame
150. // check if this (global) boolean is TRUE...
151. if (gameFrameRefreshes) {
152. // call this function: located in the Rectangle class - because the gameFrame is an object of type Rectangle
153. gameFrame.drawYourself();
154. }
155. // PADDLE
156. // Update paddle Properties
157. // call the refresh() function for the Paddle object (the function is in the Paddle class...)
158. paddle.refresh();
159. // BRICKS
160. // Update the bricks array
161. // within the for loop call the refresh() function for every Brick oject currently within the bricks array
162. //(the function is within the Bricks class...)
163. for (int i=0; i<bricks.length; i++) {
164. bricks[i].refresh();
165. }
166. // BALLS
167. //Update the balls array
168. // within the for loop call the refresh() function for every Ball oject currently within the balls array
169. //(the function is within the Ball class...)
170. for (int i=0; i<balls.length; i++) {
171. balls[i].refresh();
172. }
173. }
174. /********************saveScreenShots() FUNCTION**********************************
175. This function is for saving screen shots of the game ...
176. Be careful with this function - only change if you know what you're doing
177. the hard disk could fill up with images in a few minutes
178. press the 'G' key to save frames in TGA pictures in 'saved' folder
179. *******************************************************************************/
180. void saveScreenshots() {
181. frameNum++;
182. if (keyPressed) {
183. if (key == 'g' || key == 'G') {
184. if (frameNum%2==0) {
185. saveFrame("saved/frame-####.tga");
186. }
187. }
188. }
189. }
Ball class
1. // import the necessary library
2. import java.awt.geom.*;
3. /********************************************************************************
4. Defintion of the Ball Class:
5. The Ball class has dual functionality:
6. First: It is used to create an instance of a ball object
7. Second: A ball instance will detect if it is touching a brick,
8. the paddle or the bounding limits of the game frame. Therefore the ball class contains
9. the necessary functions for detecting any collision with the other above mentioned
10. objects that are instantiated in the game session ...
11. *********************************************************************************/
12. public class Ball {
13. // Define an a local variable "rectangle" to represent an object of type Rectangle
14. Rectangle rectangle;
15. // local Variables that represent the properties of a Brick object
16. int width = 10; // make change here to the ball
17. int height = 10; // make change here to the ball
18. boolean hasStroke = true;
19. color strokeColor = #550F48; //#333F48 make change here
20. boolean hasFill = true;
21. color fillColor = #102F48; //#333F48 make change here
22. // velocity
23. int velX = 4; //4 make change here
24. int velY = 2; //4 make change here
25. // positioning variables
26. int x;
27. int y;
28. int ox;
29. int oy;
30. int xcentre;
31. int ycentre;
32. /********************************************************************************
33. Ball Class Default Constructor:
34. In order to create an Instance of a Ball Object, one needs to invoke
35. the Default Constructor in the following manner: new Ball(tempX,tempY).
36. The Ball Constructor makes an instance of the Rectangle Class.
37. /********************************************************************************/
38. Ball(int newX, int newY) {
39. x = newX;
40. y = newY;
41. // make an instance of the Rectangle object (the ball is a rectangle...)
42. rectangle = new Rectangle(width, height, hasStroke, strokeColor, hasFill, fillColor);
43. // call the setPosition() function of the rectangle ( the function is within the Rectangle class...)
44. rectangle.setPosition(x, y);
46. }
47. /********************************************************************************
48. Function: refresh()
49. Returns: nothing.
50. Maintains the state of the given Ball on the Screen.
51. The refresh() method calls the updatePosition() method, and there after
52. the setPosition() and finally redraws itself to the screen (with the drawYourself()).
53. **********************************************************************************/
54. void refresh() {
55. // call this function that is local to this class
56. updatePosition();
57. rectangle.setPosition(x, y);
58. rectangle.drawYourself();
59. // Remember that a Brick has been defined as an object rectangle of type Rectangle.
60. // Therefore the drawYourself()&setPosition() functions are within the Rectangle Class...
61. }
62. /********************************************************************************
63. Function: updatePosition()
64. Returns: nothing.
65. Calculates the "real" time positioing of the Ball. Within this function
66. are also the calls to the function to check if the ball
67. has collided with another object.
68. *********************************************************************************/
69. void updatePosition() {
70. // add velocity to position- this simulates the ball movemnet( we update the x and y position of the ball...
71. x+=velX;
72. y+=velY;
73. // collision with limits for "x"
74. if (x<=0 || x>=gameFrameWidth-width) {
75. // set the velocity for the x Position
76. velX = -velX;
77. // the constrain() will make sure that "x" does not go less than 0 and not greater than (gameFrameWidth-width)
78. x = constrain(x, 0, gameFrameWidth-width);
79. }
80. // collision with limits for "y"
81. if (y<=0 || y>=gameFrameHeight-height) {
82. velY = -velY;
83. y = constrain(y, 0, gameFrameHeight-height);
84. }
85. xcentre = x+width/2;
86. ycentre = y+height/2;
88. // We check if the ball is colliding with the paddle
89. // input parameter is the "rectangle" variables defined in the Paddle class
90. // Remember: the "paddle" is an object of type Paddle - and this class has an instance variable named "rectangle" ...
91. // This function will return "result"
92. // collision with paddle
93. int result = checkCollisionWithRectangle(paddle.rectangle);
94. // if collides on top, control direction of ball
95. // if (result == 1){
96. //if(xcentre < paddle.rectangle.x1+paddle.rectangle.width/2){
97. // if(velX>0){
98. // velX = -velX*2;
99. // }
100. // }else{
101. // if(velX<0){
102. // velX = -velX/3;
103. //}
104. //}
105. // }
106. //We detect collision with the bricks if the result is "0"
107. if (result == 0) {
108. // iterate through the array of Bricks
109. for (int i=0; i<bricks.length; i++) {
110. // Check if the brick is alive ( imAlive is a boolean - so if TRUE...)
111. if (bricks[i].imAlive) {
112. /*We check if the ball is collidiing with the paddle
113. Input parameter is the "rectangle" variables defined in the Brick class
114. Remember: the "bricks[i]" is an object of type Brick - and this class has
115. an instance variable named "rectangle" (Every brick instance has its own "rectangle" var)*/
116. // This function will return "res"
117. int res = checkCollisionWithRectangle(bricks[i].rectangle);
118. // if the returned "res" s not 0 then kill this brick.
119. if (res != 0) {
120. bricks[i].die();
121. break;
122. }
123. }
124. }
125. }
126. // keep track of the current x and y vars (make a copy)
127. ox = x;
128. oy = y;
129. }
130. /********************************************************************************
131. Function: checkCollisionWithRectangle()
132. Input Paramer: A Rectangle "tempRect"
133. Returns: an integer:
134. result: 0: no collision 1: top 2: right 3: bottom 4: left 5: couldn't detect which side
135. *********************************************************************************/
136. int checkCollisionWithRectangle (Rectangle R) {
137. // define the result variable
138. int result = 0;
139. // check if the rectangle given (ie the paddle) is being touched by the ball
140. // xcentre, ycentre are ball position variables
141. // doesPointTouchMe() is located in the Rectangle class...
142. // if it returns TRUE then execute this clause
143. if (R.doesPointTouchMe(xcentre, ycentre)) {
144. //check which side of the tempRect object has the ball touched.
145. // This line is easier to work with when we want to check how
146. //the ball has collided with the Rectangle object instead of using the ball itself...
147. Line2D lineaBola = new Line2D.Float(xcentre, ycentre, ox+width/2, oy+height/2);
148. // whatSideDoesLineTouch() is located in the Rectangle class...
149. // if it returns TRUE then execute this clause
150. result = R.whatSideDoesLineTouch(lineaBola, velX, velY);
151. // have to perhaps change the position & velocity parameters of the ball
152. // top
153. if (result==1) {
154. velY = -velY;
155. y = R.y1-height;
156. // right
157. }
158. else if (result==2) {
159. velX = -velX;
160. x = R.x2;
161. // bottom
162. }
163. else if (result==3) {
164. velY = -velY;
165. y = R.y2;
166. // left
167. }
168. else if (result==4) {
169. velX = -velX;
170. x = R.x1-width;
171. }
172. else {
173. result = 20;
174. }
175. }
176. // return the correct result ... also remember
177. //if this result!=0 then the brick touched will die...
178. return result;
179. }
180. /*********************************************************************************/
181. }// End of Ball Class Definition
Brick Class
1. /********************************************************************************
2. Defintion of the Brick Class:
3. The Brick Class is used to define a Brick object in the game.
4. It makes use of the Rectangle Class.
5. **********************************************************************************/
6. public class Brick
7. {
8. // Define an a local variable "rectangle" to represent an object of type Rectangle
9. Rectangle rectangle;
10. // local Variables that represent the properties of a Brick object
11. boolean hasStroke = true; //make change here
12. color strokeColor = 0; // make change here
13. boolean hasFill = true; //make change here
14. color fillColor = 157; // make change here
15. //
16. int x = 500; //make change here
17. int y = 100; //make change here
18. //
19. boolean respawns = true; //make change here
20. int timeToRespawn = 20; // time is in frames
21. // time is in frames
22. int frame;
23. boolean imAlive;
24. /********************************************************************************
25. Brick Class Default Constructor:
26. In order to create an Instance of a Brick Object, one needs to invoke
27. the Default Constructor in the following manner:
28. new Brick(rectX, rectY, rectWidth,rectHeight, hasStroke, strokeDef, hasFill, fillColour).
29. The Brick Constructor makes an instance of the Rectangle Class.
30. /********************************************************************************/
31. Brick(int X, int Y, int W, int H, boolean HASSTROKE, color STROKE, boolean HASFILL, color FILL) {
32. // make an instance of the Rectangle object
33. rectangle = new Rectangle(W, H, HASSTROKE, STROKE, HASFILL, FILL);
34. // call the setPosition() function of the rectangle ( the function is within the Rectangle class...)
35. rectangle.setPosition(X, Y);
36. imAlive = false;
37. }
38. /********************************************************************************
39. Function: refresh()
40. Returns: nothing.
41. Maintains the state of the given Brick on the Screen.
42. The refresh() method checks the state of the Brick (alive or dead)
43. / if a new one should be created - if it is alive it will call the drawYourself().
44. **********************************************************************************/
45. void refresh() {
46. if (imAlive) {
47. // Remember that a Brick has been defined as an object rectangle of type Rectangle.
48. // Therefore the drawYourself() function is within the Rectangle Class...
49. rectangle.drawYourself();
50. }
51. else {
52. if (respawns) {
53. frame++;
54. if (frame>timeToRespawn-10) {
55. // rise up from your grave, brick
56. imAlive=true;
57. }
58. }
59. }
60. }
61. /********************************************************************************
62. Function: die()
63. Returns: nothing.
64. Maintains the state of a Brick. If a Brick is "dead", it is removed from the screen.
65. *********************************************************************************/
66. void die() {
67. imAlive = false;
68. frame = 2;
69. }
70. }// End of Brick Class Definition
Paddle class
1. /********************************************************************************
2. Defintion of the Paddle Class:
3. The Paddle Class is used to define the Paddle object in the game.
4. It makes use of the Rectangle Class.
5. *********************************************************************************/
6. public class Paddle {
7. /********************************************************************************
8. Paddle Class Instance Variables:
9. These Instance Variables will be initialised(defined)when an Instance of the
10. Paddle Class is invoked by calling the default constructor new Paddle().
11. /*********************************************************************************/
12. // Define an a local variable "rectangle" to represent an object of type Rectangle
13. Rectangle rectangle;
14. // Paddle Variables
15. int width = 200;
16. int height = 50;
17. // boolean variables
18. boolean hasStroke = false;
19. boolean hasFill = true;
20. // color variables make change here
21. //#333F48
22. color strokeColor = #102F48;
23. //#333F48
24. color fillColor = #100F48;
25. //
26. int x = gameFrameWidth/2;
27. int y = 370;
28. /********************************************************************************
29. Paddle Class Default Constructor -
30. In order to create an Instance of a Paddle Object, one needs to invoke
31. the Default Constructor in the following manner new Paddle().
32. The Paddle Class makes an instance of the Rectangle Class.
33. *********************************************************************************/
34. Paddle() {
35. rectangle = new Rectangle(width, height, hasStroke, strokeColor, hasFill, fillColor);
36. rectangle.setPosition(x, y);
37. }
38. /********************************************************************************
39. Function: refresh()
40. Returns: nothing.
41. Maintains the Position of the Paddle on the Screen.
42. The refresh() method call the updatePosition() method, and there after
43. the setPosition() and redraws itself to the screen (with the drawYourself()).
44. /******************************************************************************** */
45. void refresh() {
46. updatePosition();
47. // Update the Position of the Rectangle (Paddle) Object
48. // this function is in THIS class...
49. rectangle.setPosition(x, y);
50. // now set the position ...
51. rectangle.drawYourself();
52. // Remember that a Paddle has been defined as an object rectangle of type Rectangle.
53. // Therefore the drawYourself() function is within the Rectangle Class...
54. }
55. /********************************************************************************
56. Function: updatePosition()
57. Returns: nothing.
58. Calculates the "real" time positioning of the Paddle.
59. *********************************************************************************/
60. void updatePosition() {
61. x = mouseX-recX-width/2;
62. x = constrain(x, 0, gameFrameWidth-width);
63. }
64. /********************************************************************************/
65. } // End of Paddle Class Definition
rectangle class
1. // import the necessary library
2. import java.awt.geom.*;
3. /********************************************************************************
4. Defintion of the Rectangle Class:
5. The Rectangle Class is used to define every visible object in the game
6. (The game frame, the bricks, the paddle and the ball)
7. *********************************************************************************/
8. public class Rectangle {
9. int width;
10. int height;
11. //change here for the color
12. boolean hasStroke = false;
13. color strokeColor;
14. boolean hasFill = true;
15. color fillColor;
16. color opacity;
17. int x1;
18. int y1;
19. int x2;
20. int y2;
21. /********************************************************************************
22. Rectangle Class Default Constructor -
23. In order to create an Instance of a Rectangle Object,
24. one needs to invoke the Default Constructor in the following manner:
25. Rectangle myRectangle = new Rectangle(rectWidth, rectHeight, temp_hasStroke,temp_strokeColor,temp_hasFill,temp_fillColor)
26. /*********************************************************************************/
27. Rectangle(int widthOfRect, int heightOfRect, boolean hasStroke, color strokeColor, boolean fillIsHere, color tempFILL) {
28. // set the values of the instance variables to the given arguements.
29. width = widthOfRect;
30. height = heightOfRect;
31. hasStroke = hasStroke;
32. strokeColor = strokeColor;
33. hasFill = fillIsHere;
34. fillColor = tempFILL;
35. //change here 205
36. opacity = 505;
37. }
38. /*********************************************************************************
39. Function: setPosition(int posX, int posY)
40. Returns: nothing.
41. Set the position of the Rectangle Instance Object and defines the dimensions
42. *********************************************************************************/
43. void setPosition(int newX, int newY) {
44. x1 = newX;
45. y1 = newY;
46. x2 = x1+width;
47. y2 = y1+height;
48. }
49. /*********************************************************************************
50. Function: drawYourself()
51. Returns: nothing.
52. The drawYourself() function is invoked each time the Rectangle is to be drawn on the Screen.
53. The drawYourself() function also checks and applies styling parameters to the Rectangle
54. i.e. Stroke, Fill and the of Dimensions a rectangle.
55. It will also call the inbuilt rect() to draw the shape to the screen...
56. *********************************************************************************/
57. void drawYourself() {
58. // Check if this Rectangle has to a stroke property enabled, if so, apply the stroke property.
59. if (hasStroke) {
60. stroke(strokeColor);
61. }
62. else {
63. noStroke();
64. }
65. // Check if this Rectangle is fill property enabled, if so, apply the fill property.
66. if (hasFill) {
67. fill(fillColor, opacity);
68. }
69. else {
70. noFill();
71. }
72. // Draw the Rectangle and enabled propoerties. make change here
73. rect(recX+x1, recY+y1, width/2, height/2);
74. }
75. /*********************************************************************************
76. Function: doesPointTouchMe()
77. Returns: boolean.
78. The doesPointTouchMe Method implements a collision detetction algorithm, if the points (pX, pY)
79. are discovered to be within the bounds of the Rectangle Object(i.e a Brick, Paddle...).
80. Then the object (ball object) represented by position (pX, pY), indeed touches that Rectangle object.
81. *********************************************************************************/
82. boolean doesPointTouchMe (int PX, int PY) {
83. // Set the return variable to false, assume that the Rectangle is not Touched.
84. boolean result = false;
85. // Check the if pX is found inside the x coordinates of the current Rectangle
86. if (PX >= x1 && PX <= x2) {
87. // Check if pY is found inside the y coordinates of the current Rectangle
88. if (PY >= y1 && PY <= y2) {
89. // If we reach this statement, then the Rectangle has been Touched.
90. result = true;
91. }
92. }
93. return result;
94. }
96. /*********************************************************************************
97. Function: whatSideDoesLineTouch()
98. Input Parameters: tempLine (represents the side of the ball that has touched the other Rectangle object)
99. velX, velY (velocity parameters of the ball)
100. Returns: an int (represnts the side of the touched Rectangle oject) - touched BY the ball..
101. This function determines which side of the Rectangle object that called this function (i.e. a Brick)
102. has been touched by the Ball object
103. /*********************************************************************************/
104. int whatSideDoesLineTouch (Line2D LINE, int VELX, int VELY) {
105. // local variable to represent the side
106. Line2D side;
107. // condition check based on velY value
108. // top touched will return (1) and bottom touched will return(3)
109. if (VELY>0) {
110. // create an instance of a 2D Line
111. side = new Line2D.Float(x1, y1, x2, y1);
112. // check if our line representing the side of the "ball" intersects the side.
113. // Note: the function intersectsLine is deined in the Line2D class which is from the
114. // java.awt.geom library
115. if (LINE.intersectsLine(side)) {
116. return 1;
117. }
118. }
119. else if (VELY<0) {
120. side = new Line2D.Float(x1, y2, x2, y2);
121. if (LINE.intersectsLine(side)) {
122. return 3;
123. }
124. }
125. // left touched will return (4) / right touched will return (2)
126. if (VELX>0) {
127. side = new Line2D.Float(x1, y1, x1, y2);
128. if (LINE.intersectsLine(side)) {
129. return 4;
130. }
131. }
132. else if (VELX<0) {
133. side = new Line2D.Float(x2, y1, x2, y2);
134. if (LINE.intersectsLine(side)) {
135. return 2;
136. }
137. }
138. return 0;
139. }
140. }

3d box showing elements in each window

[5 Replies]
- 22-Nov-2011 11:45 AM
- Forum: Programming Questions
Hi all, I am doing a remix on game mod and i want to show 2 spinning or on mouse x and y box showing the game mod remix in each of it's sides. How can i do this? I know there is an example of box on mouse x and mousey in the examples library but how can i showing it each the breakout game mod in each of its side.

OR
how can i make a 3d box of my game mod remix and it's rotationing?

Cheers,

dispersing video images cells

[2 Replies]
- 17-Nov-2011 12:53 PM
- Forum: Core Library Questions
Like the title says how can i disperse video image cell when i press the mouse button and when i press it again they come back to their original state? Is this possible?
This is the code i am using from the library.
1. import processing.video.*;
2. // Size of each cell in the grid
3. int cellSize = 15;
4. // Number of columns and rows in our system
5. int cols, rows;
6. // Variable for capture device
7. Capture video;
8. void setup() {
9. size(630, 480, P2D);
10. //set up columns and rows
11. cols = width / cellSize;
12. rows = height / cellSize;
13. colorMode(RGB, 255, 255, 255, 100);
14. rectMode(CENTER);
15. // Uses the default video input, see the reference if this causes an error
16. video = new Capture(this, width, height, 15);
17. background(0);
18. }
19. void draw() {
20. if (video.available()) {
21. video.read();
22. video.loadPixels();
24. // Begin loop for columns
25. if (mousePressed) {
26. background(random(255),random(255),random(219));
27. for (int i = 0; i < cols;i++) {
28. // Begin loop for rows
29. for (int j = 0; j < rows;j++) {
30. // Where are we, pixel-wise?
31. int x = i * cellSize;
32. int y = j * cellSize;
33. int loc = (video.width - x - 1) + y*video.width; // Reversing x to mirror the image
34. // Each rect is colored white with a size determined by brightness
35. color c = video.pixels[loc];
36. float sz = (brightness(c) / 255.0) * cellSize;
37. fill(255);
38. noStroke();
39. rect(x + cellSize/2, y + cellSize/2, sz, sz);
40. }
41. }
42. }
43. }
44. }

moving the checker board pieces. Need help asap

[33 Replies]
- 10-Nov-2011 10:29 AM
- Forum: Programming Questions
I have a checker board that i would like to the following. I just stuck and i don't wanna spend more time thinking about. I would appreciate any help.

a. Make the cells toggle between moving and not as the user clicks. First click = move; second click = stop; third click = move; fourth click = stop; etc.
b. Make the cells bounce off the edges of the canvas instead of sailing off into infinity.
c. Note that some cells never move. Fix that, so that all cells move.

here is the code
1. // ----------------------------------------------------------------------
2. // CUSTOM CLASSES
3. // ----------------------------------------------------------------------
4. //CheckerCell is a class that draws a black or white rectangle, or cell
5. class CheckerCell {
6. /* properties */
7. int x; // x-coordinate of the cell
8. int y; // y-coordinate of the cell
9. int mySize = 20; //the size of the cell
10. color fillColor;
11. color WHITE = color(255); //a constant property
12. color BLACK = color(0); //a constant property
13. float xSpeed; //how many pixels and in which direction (positive or negative) the cell will move in the x axis
14. float ySpeed; //how many pixels and in which direction (positive or negative) the cell will move in the y axis
15. /* methods */
16. // constructor: simply sets the speeds to random amounts
17. public CheckerCell() {
18. xSpeed = (random(5))*randomPosNeg();
19. ySpeed = (random(5))*randomPosNeg();
20. }
21. //moves the cell based on the values for xSpeed and ySpeed
22. //does edge checks to 'bounce' the cell off the edge of the canvas
23. void move() {
24. x = x + int(xSpeed); //apply proper xSpeed to move in the x axis
25. y = y + int(ySpeed); //apply proper ySpeed to move in the y axis.
26. }
27. // draws the cell
28. void display() {
29. fill(fillColor);
30. //drawing the stroke in contrast makes for better visibility when they start moving
31. if (fillColor == WHITE) {
32. stroke(BLACK);
33. }
34. else {
35. stroke(WHITE);
36. }
37. rect(x, y, mySize, mySize);
38. }
39. //switches the fill from white, if black, and vice-versa
40. void switchFill(boolean newFill) {
41. if (newFill) {
42. fillColor = color(255);
43. }
44. else {
45. fillColor = color(0);
46. }
47. }
49. //set the fillColor property
50. void set(color newFill) {
51. fillColor = newFill;
52. }
53. }
54. // ----------------------------------------------------------------------
55. // GLOBAL VARIABLES
56. // ----------------------------------------------------------------------
57. //the size of our cells
58. int cellSize = 20;
59. //flags whether the cells are in motion or not
60. boolean moving = false;
61. boolean firstClick;
62. boolean secondClick;
63. boolean thirdClick;
64. boolean fourthClick;
65. //A 2-dimensional array for holding the cells of the checkerboard
66. CheckerCell[][] cellArray;
67. // ----------------------------------------------------------------------
68. // BUILT-IN FUNCTIONS
69. // ----------------------------------------------------------------------
70. void setup() {
71. size(500, 500);
72. smooth();
73. noStroke();
74. //populate our board with cells
75. initializeBoard();
76. }
77. void mousePressed() {
78. //turn on the cell movement
79. // moving = true;
81. }
82. void draw() {
83. //refresh the background; this is an animation, after all
84. background(0);
85. //loop through the array, drawing the CheckerCells
86. //first, walk across the columns...
87. for (int column = 0; column < cellArray.length; column++) {
88. //...for each column, walk down the rows
89. for (int row = 0; row < cellArray[0].length; row++) {
90. //tell each cell to draw itself
91. cellArray[column][row].display();
92. if (moving) {
93. //if moving, tell each cell to move
94. cellArray[column][row].move();
95. }
96. }
97. }
98. }
99. // ----------------------------------------------------------------------
100. // CUSTOM FUNCTIONS
101. // ----------------------------------------------------------------------
102. //Walk through the 2-D cellArray, filling it with CheckerCell objects with the correct fill to make a
103. //checkerboard pattern
104. void initializeBoard() {
105. boolean whiteColor = true; //if true, then fill = white; if false, fill = black
106. boolean startColor = true; //used to track the starting fill value for each column
107. int numColumns = width/cellSize; //the number of columns is a function of the width of the canvas & the size of each cell
108. int numRows = height/cellSize; //the number of rows is a function of the height of the canvas & the size of each cell
109. //initialize the 2 dimensional array for holding all the cells
110. cellArray = new CheckerCell[numColumns][numRows];
111. //first, walk across the columns...
112. for (int column = 0; column < cellArray.length; column++) {
113. //...for each column, walk down the rows
114. for (int row = 0; row < cellArray[column].length; row++) {
115. cellArray[column][row] = new CheckerCell(); //make a new CheckerCell object
116. cellArray[column][row].x = column*cellSize; //the x position of each cell is a function of which column it is in and the cell size
117. cellArray[column][row].y = row*cellSize; //the x position of each cell is a function of which column it is in and the cell size
118. cellArray[column][row].switchFill(whiteColor);
119. whiteColor = !whiteColor;//alternate the fill color between white and black
120. }
121. //at bottom of column, flip the value of startColor to make sure the next colum
122. //is filled with the opposite fill of the current column
123. startColor = !startColor;
124. //then set our fill color to that value
125. whiteColor = startColor;
126. }
127. }
128. int randomPosNeg() {
129. float temp = random(0,1);
130. if (temp > 0.5) {
131. return 1;
132. } else {
133. return -1;
134. }
135. }

moving image using class

[9 Replies]
- 08-Nov-2011 10:49 AM
- Forum: Programming Questions
hi all i am trying to move this image but it's not working. here is my code
//define a square class for animation
class Square {
1. /*----------properties-------*/
2. float x; //x location
3. float y; //y location
4. float speed; // speed of movement
5. int squareSize; // size of the square
6. color fillColor = color (255, 128, 0); // color of square
7. color strokeColor = fillColor;
8. boolean xRight = true; // where true = to the right and false = to the left
9. int easeFactor = 20; //amount of ease
10. /*------------contructor--------------*/
11. public Square(float newX, float newY, int newSize, float mySpeed) {
12. x = newX;
13. y = newY;
14. squareSize = newSize;
15. speed = mySpeed;
16. }
17. public void updatePosition() {
18. // find the distance from the target to the square
19. float distanceX = width-x;
20. // ease towards the target
21. float stepX = distanceX/easeFactor;
22. //...if the square position + step to it won't sent it over the edge...
23. if (x + squareSize + stepX < width) {
24. //move it by the step
25. x += stepX;
26. }
27. else { //othwerwise it will go over the edge, so just move to the edge
28. x = width - squareSize;
29. }
30. }
32. /*------------Methods--------------*/
33. public void move (float newX, float newY) {
34. newX = x;
35. newY = y;
36. if (xRight) { // if moving to the right
37. // if the x position has gone off the screen then we reset the square to the left had side of the screen
38. if (x + squareSize > width) {
39. // switch directions
40. xRight = false;
41. }
42. else {
43. x+=speed; // update the x position - x = x + 1;
44. }
45. }
46. else {
47. if (x < 0) {
48. // switch directions
49. xRight = true;
50. }
51. else {
52. x-=speed; // update the x position - x = x + 1;
53. }
54. }
55. }
56. public void display() {
57. PImage logo;
58. logo = loadImage("logo2.png");
59. image(logo);
60. }
61. //declare a var type square to hold our square
62. Square firstSquare;
63. //Square secondSquare;
64. //Square thirdSquare;
65. //Square fourthSquare;
66. //Square fifthSquare;
67. int genericSize = 40;
68. void setup() {
69. size(400, 400);
70. background(0);
71. firstSquare = new Square(0, random(0, height-genericSize), genericSize, random(0, 10));
72. // secondSquare = new Square(0, random(0, height-genericSize), genericSize, random(0, 10));
73. // thirdSquare = new Square(0, random(0, height-genericSize), genericSize, random(0, 10));
74. // fourthSquare = new Square(0, random(0, height-genericSize), genericSize, random(0, 10));
75. // fifthSquare = new Square(0, random(0, height-genericSize), genericSize, random(0, 10));
76. }
77. void mousePressed () {
78. // int easeFactor = 20;
79. firstSquare.move(mouseX, mouseY);
80. // easeFactor = mouseX-easeFactor;
82. }
83. void draw() {
84. background(0);
85. //draw the square
86. firstSquare.display();
87. //move the square
88. firstSquare.move(mouseX, mouseY);
89. }

trouble bouncing pulses of the canvas

[0 Replies]
- 07-Nov-2011 07:58 AM
- Forum: Programming Questions
here is my code and how do i bounce the pulse of array of the canvas. Also how can i make this draw inifinite forever and ever.
// ----------------------------------------------------------------------
// CUSTOM CLASSES
// ----------------------------------------------------------------------

//Pulse is a class that draws a pulsing dot on the screen
class Pulse {
/* properties */
int SCALE = 50;
int x;    // x-coordinate of the pulse
int y;    // y-coordinate of the pulse
float s; // size of the pulse
color myColor = color(255,255,255); //default color

/* methods */
// constructor 1
public Pulse(int pulseX, int pulseY) {
    x = pulseX;
    y = pulseY;
    s = 5;
}

// constructor 2
public Pulse(int pulseX, int pulseY, int pulseScale) {
    x = pulseX;
    y = pulseY;
    SCALE = pulseScale;
    s = 0;
}

// constructor 3
public Pulse() {
    x = 0;
    y = 0;
    s = 0;
}

// constructor 4
public Pulse(int pulseX, int pulseY, int pulseScale, color newColor) {
    x = pulseX;
    y = pulseY;
    SCALE = pulseScale;
    s = 0;
    myColor = newColor;
}

// moves the pulse to the given position
void move(int newX, int newY) {
    x = newX;
    y = newY;
}

// draws the pulse and updates its size
void display() {
    fill(myColor);
    stroke(0);
    ellipse(x, y, sin(s)*SCALE, sin(s)*SCALE);
    s += 0.1;
}
}

// ----------------------------------------------------------------------
// GLOBAL VARIABLES
// ----------------------------------------------------------------------

int numPulses = 550;
//counter tracking how many pulse objects have been istantiated
int pulseArrayCounter = 0;
//create of any array type pulse pulse array with 1000 elements
Pulse[] pulseArray = new Pulse[numPulses];

//int pulseGap = 50;

// ----------------------------------------------------------------------
// BUILT-IN FUNCTIONS
// ----------------------------------------------------------------------
void setup() {
size(800, 800);
smooth();
color tempColor = color(random(255), random(255), random(255));
}

void draw() {
background(0);

// draw the pulse
for (int index = 0; index < pulseArrayCounter; index++) {
    pulseArray[index].display();
}
}

void mouseDragged() {

color tempColor = color(random(255), random(255), random(255));
int newScale = int(random(100));

// initialize a new pulse object
// pulseArray[pulseArrayCounter] = new Pulse(mouseX, mouseY, newScale, tempColor);
// pulseArrayCounter++;
if (pulseArrayCounter < pulseArray.length) {
    pulseArray[pulseArrayCounter] = new Pulse(mouseX, mouseY, newScale, tempColor);
    pulseArrayCounter++;
}
}

brushes not drawing per quadrent.

[11 Replies]
- 29-Oct-2011 01:29 PM
- Forum: Programming Questions
here is my code. For some reason the brushes are not drawing correctly. Help would be appreciated.
1. void setup ()
2. {
3. background (255);
4. size (400, 400);
5. frameRate(50);
6. smooth ();
7. }
8. //Draws brushes
9. void draw()
10. {
11. float MSize, SMSize;
12. //Calculates how fast the mouse is moving
13. sizeOfMouse=dist(pmouseX, pmouseY, mouseX, mouseY);
14. SMSize=dist(pmouseX, pmouseY, mouseX, mouseY);
15. SMSize += 25;
16. // placements per quadrant
17. if (mousePressed) {
18. if (mouseX < width/2 && mouseY < height/2) {
19. brush(mouseX, mouseY, MSize+20);
20. }
21. else if (mouseX > width/2 && mouseY < height/2) {
22. brush(mouseX, mouseY, MSize+20);
23. }
24. else if (mouseX < width/2 && mouseY > height/2) {
25. brush(mouseX, mouseY, MSize+20);
26. }
27. //Brush
28. brush(mouseX, mouseY, MSize+20);
29. }
30. //Spacebar clears page
31. if (keyPressed) {
32. if (key == ' ') {
33. background (255);
34. }
35. }
36. }
37. //Brush
38. void brush (int xBrushPos, int yBrushPos, float bSize)
39. {
40. // rectMode (CENTER);
41. // ellipseMode (CENTER);
42. //Brush changes per quadrant
43. if (xBrushPos < width/2 && yBrushPos < height/2)
44. {
45. fill(0, random(210), 219);
46. rect (xBrushPos, xBrushPos, bSize*random(3), bSize*random(3));
47. fill(209, 0, 219);
48. ellipse (xBrushPos, yBrushPos, bSize, bSize);
49. fill(0, 0, 219);
50. ellipse (xBrushPos+random(-bSize, bSize), yBrushPos+random(-bSize, bSize), bSize/2, bSize/2);
51. }
52. else if (xBrushPos < height/2 && yBrushPos > height/2)
53. {
54. fill(0, random(210), 219);
55. rect (xBrushPos, xBrushPos, bSize*random(3), bSize*random(3));
56. fill(209, 0, 219);
57. ellipse (xBrushPos, yBrushPos, bSize, bSize);
58. fill(0, 0, 219);
59. ellipse (xBrushPos+random(-bSize, bSize), yBrushPos+random(-bSize, bSize), bSize/2, bSize/2);
60. }
61. else if (xBrushPos > height/2 && yBrushPos < height/2)
62. {
63. fill(0, random(210), 219);
64. rect (xBrushPos, xBrushPos, bSize*random(3), bSize*random(3));
65. fill(209, 0, 219);
66. ellipse (xBrushPos, yBrushPos, bSize, bSize);
67. fill(0, 0, 219);
68. ellipse (xBrushPos+random(-bSize, bSize), yBrushPos+random(-bSize, bSize), bSize/2, bSize/2);
69. }
70. else
71. {
72. fill(0, random(210), 219);
73. rect (xBrushPos, xBrushPos, bSize*random(3), bSize*random(3));
74. fill(209, 0, 219);
75. ellipse (xBrushPos, yBrushPos, bSize, bSize);
76. fill(0, 0, 219);
77. ellipse (xBrushPos+random(-bSize, bSize), yBrushPos+random(-bSize, bSize), bSize/2, bSize/2);
78. }
79. }

how to draw 3 brush on mouse dragged

[9 Replies]
- 24-Oct-2011 10:40 AM
- Forum: Programming Questions
Hi i am this assignment where i have to draw 3 brushes on mouse dragged and they should alter between 1 2 and third brush as i am dragging my mouse. I know it sounds simple but i racking my brain to sort this out but i am having difficulty doing this part. Here is my code. I need help asap.
1. //Global var
2. int brushSize = 50; //brushSize
3. //------------------------------------------------------------------------------------------------
4. //Initialising the functions
5. //Defining the dimension of the display,
6. //background and color settings
7. //------------------------------------------------------------------------------------------------
8. void setup() {
9. smooth();
10. size(500, 500);
11. background(255);
12. }
13. //------------------------------------------------------------------------------------------------
14. // Function Brush from 3.1
15. //------------------------------------------------------------------------------------------------
16. void brush(int xPos, int yPos) {
17. fill(0, 0, 219);
18. ellipse(xPos, yPos, brushSize, brushSize);
19. }
20. //------------------------------------------------------------------------------------------------
21. // Function for drawing brush from 3.1
22. //------------------------------------------------------------------------------------------------
23. void brush2(int xPos, int yPos) {
24. fill(0, 249, 219);
25. rect(xPos, yPos, brushSize, brushSize);
26. }
27. //------------------------------------------------------------------------------------------------
28. // Function for drawing third brush
29. //------------------------------------------------------------------------------------------------
30. void brush3(int xPos, int yPos) {
31. fill(0, 249, 219);
32. triangle(xPos, yPos, xPos, yPos, brushSize, brushSize);
33. }
34. //------------------------------------------------------
35. // Function for drawing 2nd brush on mouse released
36. //------------------------------------------------------
37. void mousePressed () {
38. brushRec(mouseX, mouseY);
39. }
40. //--------------------------------------------------
41. // Function for drawing brush on mouse released
42. //--------------------------------------------------
43. void mouseReleased () {
44. brush(mouseX, mouseY);
45. }
46. //--------------------------------------------
47. // check if the space bar is pressed
48. //if yes, clear the screen
49. //--------------------------------------------
50. void draw() {
51. if (keyPressed)
52. if (key == ' ')
53. background(255);
54. }

Drawing a head nose and mouth in one function. Confused !!!!!!1

[2 Replies]
- 05-Oct-2011 08:26 AM
- Forum: Programming Questions
Hi like the title says i need to draw a head nose and mouth in one function. I am still new to processing and i get concfused very easily with all the vars and in doing so i get lost what i want to do. my head function is very basic but i wanna use better code for drawing my head a nose and a mouth. My head function only draws the head i dunno why it's not drawing the mouth and the nose when i call the head function in the void setup. here is my code.

Also i have to Rewrite drawHead() so that it will accept two arguments which specify the position at which the head is drawn then i have to draw the head in three places on the display. Please reply asap. I really need help with this.

void setup() {
smooth();
size(500,500);

drawHead(250,350);
drawHead(400,120); // draws head at specific pos
drawHead(120,120); // draws head at specific pos
drawEyes(380, 100);
drawEyes(100, 100); // draws eyes at specific X .Y pos
}

// Function that draws head with eyes, mouth and nose
void drawHead(int xPos, int yPos) {
int headSize = 100; // var for the headsize
int mouthX = 100;   // var for the x pos of the mouth
int mouthY = 125;   // var for the y pos of the mouth
int mouthWidth = 100; // var for the mouth width of the mouth
int mouthHeight = 40; // var for the mouth height of the mouth
// booleon mouthTrue = true;

fill(255,216,0);        // applies colour to the head
ellipse(xPos,yPos,headSize,headSize); // position of the head
line(113,130,125,130); // position of the first coordinate for the nose
line(113,130,120,135); // position of the second coordinate for the nose
line(120,135,125,130); // position of the third coordinate for the nose
noFill();               // applies no fill to the mouth
arc(mouthX,mouthY,mouthWidth, mouthHeight, PI/6,PI/2 ); // position of the mouse

}

void drawEye(int xPos, int yPos, int eyeSize) {
// set the fill to white
fill(255);
// draw the white of the eye
ellipse(xPos, yPos, eyeSize, eyeSize);

// set the fill to black
fill(0);
// draw the black pupil
ellipse(xPos, yPos, eyeSize/2, eyeSize/2);
}

void drawEyes(int xPos, int yPos) {
// specify the size of the eye
int eyeSize = 20;

// specify the gap between eyes
// base it on the size to ensure enough space
int gap = eyeSize*2;

drawEye(xPos, yPos, eyeSize);      // draw the left eye
drawEye(xPos+gap, yPos, eyeSize); // draw the right eye
}

New to java

[13 Replies]
- 13-Sep-2011 10:04 AM
- Forum: Programming Questions
Hi i am new to java and i was wondering how would i go by creating an 64*64 px icon with my picture on it.
Thx

Activity Trend