SHARE
TWEET

Untitled

a guest Nov 12th, 2019 83 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // board Breakout8
  2. final int WIDTH=500;
  3. final int HEIGHT=500;
  4.  
  5. // bricks
  6.  
  7. final int BRICKW=WIDTH/10;
  8. final int BRICKH=20;
  9.  
  10. // ball
  11. final int BALLINITX=50;
  12. final int BALLINITY=200;
  13.  
  14. int lives;
  15. int score=0;
  16. int rows=0;
  17. int highscore;
  18. int count;
  19. boolean playing;
  20. boolean scoreAdd=true;
  21. //boolean snitchState=false;
  22.  
  23. Ball myBall;
  24. Bat myBat;
  25. ArrayList<Brick> Bricks;
  26. ArrayList<Integer> scores;
  27. ArrayList<Snitch> snitches;
  28.  
  29. void settings()
  30. {
  31.   size(WIDTH, HEIGHT);
  32. }
  33.  
  34. void setup()
  35. {
  36.   // create text font
  37.   PFont f;
  38.   f = createFont("Arial", 16, true); // Arial, 16 point, anti-aliasing on
  39.   textFont(f, 18);
  40.  
  41.   ellipseMode(CORNER);
  42.   frameRate(200);
  43.  
  44.   scores=new ArrayList<Integer>();
  45.   lives=3;
  46.   initBricks();
  47.   initSnitches();
  48.  
  49.   myBall=new Ball(BALLINITX, BALLINITY, 20, 127, 127, 127);
  50.   myBat=new Bat(450, 100, 20, 255, 255, 127);
  51.  
  52.   playing=true;
  53. }
  54.  
  55.  
  56. void initBricks()
  57. {
  58.   Bricks=new ArrayList<Brick>();
  59.   if (lives>0)
  60.     rows++;
  61.  
  62.   for (int row=0; row<rows; row++)
  63.   {
  64.     for (int col=0; col<WIDTH/BRICKW-2; col++)
  65.     {
  66.       //if(numb%10==0)
  67.       Bricks.add(new Brick((col+1)*BRICKW, (row+1)*BRICKH));
  68.     }
  69.   }
  70.   println("Added "+Bricks.size()+" bricks");
  71. }
  72. void initSnitches()
  73. {
  74.   snitches=new ArrayList<Snitch>();
  75.   for (int i = 0; i<Bricks.size(); i++)
  76.   {
  77.     if (Bricks.get(i).snitchType==0)
  78.     {
  79.       //print(1);
  80.       snitches.add(new Snitch(Bricks.get(i).x, Bricks.get(i).y));
  81.       // print(snitches.size());
  82.     }
  83.   }
  84. }
  85. void drawSnitches()
  86. {
  87.   for (int j=0; j<snitches.size(); j++)
  88.   {
  89.     Snitch s=snitches.get(j);
  90.     if (s.y>470)
  91.     {
  92.       snitches.remove(j);
  93.     }
  94.     if (s.y<470 && s.y>=450&&s.scoreAdd && (s.x>=mouseX) && (s.x<=mouseX+100))
  95.     {
  96.       score=score+500;
  97.       s.scoreAdd=false;
  98.       snitches.remove(j);
  99.     }
  100.     s.draw();
  101.   }
  102. }
  103.  
  104. void drawBricks()
  105. {
  106.   for (int i=0; i<Bricks.size(); i++)
  107.   {
  108.     Bricks.get(i).draw();
  109.   }
  110. }
  111. void initBall()
  112. {
  113.   myBall.x=BALLINITX;
  114.   myBall.y=BALLINITY;
  115.   myBall.offsetX=1;
  116.   myBall.offsetY=1;
  117. }
  118.  
  119. void draw()
  120. {
  121.   if (playing)
  122.   {
  123.     // clear the background
  124.     background(0, 0, 0);
  125.     drawSnitches();
  126.     drawBricks();
  127.  
  128.  
  129.     // draw lives
  130.     fill(255, 255, 255);
  131.     text("Lives: "+lives, WIDTH-80, HEIGHT-10);
  132.     text("Level: "+rows, WIDTH-80-80, HEIGHT-10);
  133.     if (highscore<score)
  134.     {
  135.       fill(0, 200, 0);
  136.     }
  137.     text("Score: "+score, 20, HEIGHT-10);
  138.     fill(255);
  139.     text("Highscore: "+highscore, 150, HEIGHT-10);
  140.  
  141.     // move the ball
  142.     if (myBall.move(myBat.y, myBat.w) == false) // ball "died"
  143.     {
  144.       lives--;
  145.       if (lives==0) // lost all lives, so no longer playing
  146.       {
  147.         fill(255, 0, 0);
  148.         text("GAME OVER", WIDTH/2-55, HEIGHT/2);
  149.         text("CLICK TO RESTART", WIDTH/2-85, HEIGHT/2+30);
  150.         playing=false;
  151.       } else
  152.       { // move ball back to start
  153.         initBall();
  154.       }
  155.     }
  156.  
  157.     // draw the ball
  158.     myBall.draw();
  159.  
  160.  
  161.     // draw the bat
  162.     myBat.draw();
  163.     if (Bricks.size()==0)
  164.     {
  165.       initBricks();
  166.       initSnitches();
  167.     }
  168.   }
  169. }
  170. void mouseClicked()
  171. {
  172.   if (!playing)
  173.   {
  174.     background(0);
  175.     rows=0;
  176.     initBricks();
  177.     initSnitches();
  178.     drawBricks();
  179.     drawSnitches();
  180.     initBall();
  181.     playing=true;
  182.     lives=3;
  183.     if (count==0)
  184.     {
  185.       highscore=score;
  186.     }
  187.     scores.add(score);
  188.     for (int i=0; i<scores.size(); i++)
  189.     {
  190.  
  191.       if (highscore<scores.get(i))
  192.       {
  193.         highscore=scores.get(i);
  194.       }
  195.     }  
  196.  
  197.     score=0;
  198.     //int Highscore=0;
  199.     count++;
  200.   }
  201. }
  202.  
  203.  
  204. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  205.  
  206. //BALL
  207.  
  208. class Ball
  209. {
  210.   int x;
  211.   int y;
  212.   int diam;
  213.   int offsetX;
  214.   int offsetY;
  215.   int r;
  216.   int g;
  217.   int b;
  218.   int colls;
  219.  
  220.   Ball(int xloc, int yloc, int d, int red, int green, int blue)
  221.   {
  222.     x=xloc;
  223.     y=yloc;
  224.     diam=d;
  225.     offsetX=1;
  226.     offsetY=1;
  227.     r=red;
  228.     g=green;
  229.     b=blue;
  230.   }
  231.  
  232.   void draw()
  233.   {
  234.     strokeWeight(3);
  235.     fill(r, g, b);
  236.     stroke(255, 255, 255);
  237.     ellipse(x, y, diam, diam);
  238.   }
  239.  
  240.   void trackSnitch()
  241.   {
  242.     // if(
  243.     // Snitch s= snitches.get(i);
  244.   }
  245.  
  246.   boolean move(int batY, int batW) // returns true if ball "ok", false if it's "lost"
  247.   {
  248.     x=x+offsetX;
  249.     y=y+offsetY;
  250.  
  251.     // detect loss
  252.     if (y > batY) // ball has gone beyond bat)
  253.       return (false);
  254.  
  255.     // detect edges
  256.     // right-left
  257.     if (x > WIDTH-diam || x < diam/2)
  258.       offsetX=-offsetX;
  259.     else // top
  260.     if (y < diam/2)
  261.       offsetY=-offsetY;
  262.  
  263.     // check to see if in contact with bat
  264.  
  265.     if ((x>=mouseX) && (x<=mouseX+batW) && (y>batY-diam))
  266.     {
  267.       offsetY=-offsetY;
  268.     }
  269.  
  270.     // check all bricks
  271.     for (int i=0; i<Bricks.size(); i++)
  272.     {
  273.       Brick b=Bricks.get(i);
  274.  
  275.  
  276.       if ((x>=b.x) && (x<=b.x+BRICKW) && (y==b.y+BRICKH)) // bottom of brick
  277.       {
  278.  
  279.         if (b.brickLifes<1)
  280.         {
  281.           Bricks.remove(i);
  282.           score=score+10;
  283.           if (b.snitchType==0)
  284.           {
  285.             for (int j=0; j<snitches.size(); j++)
  286.             {
  287.               Snitch s=snitches.get(j);
  288.               if (s.x==b.x&&s.y==b.y)
  289.               {
  290.                 s.snitchMove=true;
  291.               }
  292.             }
  293.           }
  294.         }
  295.         b.brickLifes--;
  296.  
  297.         b.r=b.r-10;
  298.         b.g=b.g-10;
  299.         b.b=b.b-10;
  300.         offsetX=-offsetX;
  301.       } else
  302.         if ((x>=b.x) && (x<=b.x+BRICKW) && (y==b.y)) // top of brick
  303.         {
  304.  
  305.           if (b.brickLifes<1)
  306.           {
  307.  
  308.             Bricks.remove(i);
  309.             score=score+10;
  310.             if (b.snitchType==0)
  311.             {
  312.               for (int j=0; j<snitches.size(); j++)
  313.               {
  314.                 Snitch s=snitches.get(j);
  315.                 if (s.x==b.x&&s.y==b.y)
  316.                 {
  317.                   s.snitchMove=true;
  318.                 }
  319.               }
  320.             }
  321.           }
  322.           b.brickLifes--;
  323.  
  324.           b.r=b.r-10;
  325.           b.g=b.g-10;
  326.           b.b=b.b-10;
  327.           offsetX=-offsetX;
  328.         } else
  329.           if ((y>=b.y) && (y<=b.y+BRICKH) && (x==b.x-diam)) // left of brick
  330.           {
  331.  
  332.             if (b.brickLifes<1)
  333.             {
  334.  
  335.               Bricks.remove(i);
  336.               score=score+10;
  337.               if (b.snitchType==0)
  338.               {
  339.                 for (int j=0; j<snitches.size(); j++)
  340.                 {
  341.                   Snitch s=snitches.get(j);
  342.                   if (s.x==b.x&&s.y==b.y)
  343.                   {
  344.                     s.snitchMove=true;
  345.                   }
  346.                 }
  347.               }
  348.             }
  349.  
  350.             b.brickLifes--;
  351.  
  352.             b.r=b.r-10;
  353.             b.g=b.g-10;
  354.             b.b=b.b-10;
  355.             offsetX=-offsetX;
  356.           } else
  357.             if ((y>=b.y) && (y<=b.y+BRICKH) && (x==b.x+BRICKW)) // right of brick
  358.             {
  359.  
  360.               if (b.brickLifes<1)
  361.               {
  362.  
  363.  
  364.                 Bricks.remove(i);
  365.                 score=score+10;
  366.                 if (b.snitchType==0)
  367.                 {
  368.                   for (int j=0; j<snitches.size(); j++)
  369.                   {
  370.                     Snitch s=snitches.get(j);
  371.                     if (s.x==b.x&&s.y==b.y)
  372.                     {
  373.                       s.snitchMove=true;
  374.                     }
  375.                   }
  376.                 }
  377.               }
  378.               b.brickLifes--;
  379.  
  380.               b.r=b.r-10;
  381.               b.g=b.g-10;
  382.               b.b=b.b-10;
  383.               offsetX=-offsetX;
  384.             }
  385.     }
  386.  
  387.     return (true);
  388.   }
  389. }
  390.  
  391. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  392.  
  393. //Bat
  394.  
  395. class Bat
  396. {
  397.   int y;
  398.   int w;
  399.   int h;
  400.   int r;
  401.   int g;
  402.   int b;
  403.  
  404.   Bat(int yloc, int width, int height, int red, int green, int blue)
  405.   {
  406.  
  407.     y=yloc;
  408.     w=width;
  409.     h=height;
  410.     r=red;
  411.     g=green;
  412.     b=blue;
  413.   }
  414.  
  415.   void draw()
  416.   {
  417.     fill(r, g, b);
  418.     stroke(r, g, b);
  419.     rect(mouseX, y, w, h);
  420.   }
  421. }
  422.  
  423. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  424.  
  425.  
  426. //Brick
  427.  
  428. class Brick
  429. {
  430.   int x;
  431.   int y;
  432.   int r;
  433.   int g;
  434.   int b;
  435.   int type;
  436.   int brickLifes;
  437.   int snitchType;
  438.  
  439.   Brick(int xpos, int ypos)
  440.   {
  441.     snitchType=(int)random(5);
  442.     type=(int)random(30);
  443.     x=xpos;
  444.     y=ypos;
  445.     r=(int)random(256);
  446.     g=(int)random(256);
  447.     b=(int)random(256);
  448.     if(type==1||type==2||type==3)
  449.     brickLifes=type;
  450.     else
  451.     brickLifes=0;
  452.   }
  453.  
  454.   void draw()
  455.   {
  456.     strokeWeight(3);
  457.     if (type==1)
  458.     {
  459.       stroke(170,170,170);
  460.       fill(r,g,b);
  461.      
  462.      
  463.     }
  464.     else if(type==2)
  465.     {
  466.      stroke(170,170,170);
  467.      fill(r,g,b);
  468.     }
  469.     else if(type==3)
  470.     {
  471.       stroke(170,170,170);
  472.       fill(r,g,b);
  473.     }
  474.     else
  475.     {
  476.       stroke(255,255,255);
  477.       fill(r,g,b);
  478.       brickLifes=0;
  479.     }
  480.     rect(x,y,BRICKW, BRICKH);
  481.   }
  482. }
  483.  
  484. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  485.  
  486. //Snitch
  487.  
  488. class Snitch
  489. {
  490.   int x;
  491.   int y;
  492.   int offsetY;
  493.   int diam;
  494.   int initLocX;
  495.   int initLocY;
  496.   boolean snitchMove;
  497.   boolean scoreAdd;
  498.   Snitch(int xpos, int ypos)
  499.   {
  500.     diam=10;
  501.     x=xpos;
  502.     y=ypos;
  503.     initLocX=x;
  504.     initLocY=y;
  505.     offsetY=0;
  506.     snitchMove=false;
  507.     scoreAdd=true;
  508.   }
  509.   void draw()
  510.   {
  511.     stroke(255);
  512.     strokeWeight(2);
  513.     fill(204, 100, 100);
  514.     ellipse(x, y, diam, diam);
  515.     y=y+offsetY;
  516.     snitchState();
  517.     borders();
  518.   }
  519.   void snitchState()
  520.   {
  521.     if (snitchMove)
  522.     {
  523.       offsetY=1;
  524.     }
  525.   }
  526.   void borders()
  527.   {
  528.    
  529.   }
  530. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top