Loading...
Logo
Processing Forum
Programming Questions
marvellkid
marvellkid

Creating Space Invaders - Can't Stop 'Game Over' Screen coming up at start

in Programming Questions  •  2 years ago  
I have a almost finished Space Invaders Game. But when the game starts, it thinks that Game Over has Occurred. 
I'm getting no error code. Also any slight tweek's are welcomed if they are noted.
If you can help, thank you very much.
Sorry about the Long code, but Invader1Bullet class is basically repeated in the corresponding numbers.

Code:
Copy code
  2. SpaceShip spaceship;
  3. bullet bullet;

  5. Invader invader1;
  6. Invader invader2;
  7. Invader invader3;
  8. Invader invader4;
  9. Invader invader5;
  10. Invader invader6;
  11. Invader invader7;
  12. Invader invader8;

  14. Inv1Bullet inv1bullet;
  15. Inv2Bullet inv2bullet;
  16. Inv3Bullet inv3bullet;
  17. Inv4Bullet inv4bullet;
  18. Inv5Bullet inv5bullet;
  19. Inv6Bullet inv6bullet;
  20. Inv7Bullet inv7bullet;
  21. Inv8Bullet inv8bullet;

  23. boolean gameplay = false;
  24. int startingTime;

  26. void setup () {
  27.   size (1000,600);
  28.   smooth ();
  29.   
  30.   //Create SpaceShip & Bullet
  31.   spaceship = new SpaceShip ();
  32.   bullet = new bullet ();
  33.   
  34.   //Create 8 Invaders
  35.   invader1 = new Invader (65,100);
  36.   invader2 = new Invader (165,100);
  37.   invader3 = new Invader (265,100);
  38.   invader4 = new Invader (365,100);
  39.   invader5 = new Invader (65,190);
  40.   invader6 = new Invader (165,190);
  41.   invader7 = new Invader (265,190);
  42.   invader8 = new Invader (365,190);
  43.   
  44.   //Create 8 Bullets for Invaders
  45.   inv1bullet = new Inv1Bullet (65,100);
  46.   inv2bullet = new Inv2Bullet (165,100);
  47.   inv3bullet = new Inv3Bullet (265,100);
  48.   inv4bullet = new Inv4Bullet (365,100);
  49.   inv5bullet = new Inv5Bullet (65,190);
  50.   inv6bullet = new Inv6Bullet (165,190);
  51.   inv7bullet = new Inv7Bullet (265,190);
  52.   inv8bullet = new Inv8Bullet (365,190);
  53.   
  54.   //Start Timer at 0sec
  55.   startingTime = millis ();
  56. }

  58. void draw () {
  59.   game ();
  60. }
  61. void game () {
  62.   
  63.   //Variables to randomly fire Invader Bullet
  64.   float t = random (0,400);
  65.   float r = random (0,400);
  66.   
  67.   //Set background to Black
  68.   background (0);
  69.   
  70.   //Clock or Timer
  71.   int m = millis () - startingTime;
  72.   int seconds = m /1000;
  73.   
  74.   //Display information if Game hasn't been Lost
  75.   if (spaceship.GameOver == false); {
  76.     loadFont ("ArialMT-16.vlw");
  77.     fill (255);
  78.     textAlign (LEFT);
  79.     text ("Invaders From Space (c)2011 - Paul Marvell",20,20);
  80.     text ("Time:",935,20);
  81.     text (seconds,970,20);
  82.     text (spaceship.ShipHP,960,580);
  83.   }
  84.   
  85.   //Draw White title underline
  86.   stroke (255);
  87.   line (0,30,width+1,30);
  88.   
  89.   //Draw Shields
  90.   noStroke ();
  91.   fill (0,255,0);
  92.   rectMode (CENTER);
  93.   rect (140,500,width/10,height/20);
  94.   rect (380,500,width/10,height/20);
  95.   rect (620,500,width/10,height/20);
  96.   rect (860,500,width/10,height/20);
  97.   
  98.   //Display Spaceship
  99.   spaceship.display ();
  100.     //GameOver
  101.   if (spaceship.ShipHP <= 0) {
  102.     spaceship.GameOver = true;
  103.   }
  104.   if (spaceship.GameOver = true) {
  105.     spaceship.lose ();
  106.   }
  107.     //Winning Game
  108.   if (spaceship.InvCount <= 0) {
  109.     if (spaceship.ShipHP > 0) {
  110.       spaceship.win ();
  111.     }
  112.   }
  113.   
  114.   //Bullet Displayed and able to Move
  115.   if (spaceship.GameOver == false) {
  116.     bullet.display ();
  117.     bullet.move ();
  118.   }
  119.   
  120.   //Invader Displayed and able to Move
  121.   invader1.display ();
  122.   invader1.move ();
  123.   invader2.display ();
  124.   invader2.move ();
  125.   invader3.display ();
  126.   invader3.move ();
  127.   invader4.display ();
  128.   invader4.move ();
  129.   invader5.display ();
  130.   invader5.move ();
  131.   invader6.display ();
  132.   invader6.move ();
  133.   invader7.display ();
  134.   invader7.move ();
  135.   invader8.display ();
  136.   invader8.move ();
  137.   
  138.   //Invader Bullets
  139.   if (invader1.InvHP > 0) {
  140.     inv1bullet.display ();
  141.     inv1bullet.move ();
  142.     inv1bullet.fire ();
  143.   }
  144.   if (invader2.InvHP > 0) {
  145.     inv2bullet.display ();
  146.     inv2bullet.move ();
  147.     inv2bullet.fire ();
  148.   }
  149.   if (invader3.InvHP > 0) {
  150.     inv3bullet.display ();
  151.     inv3bullet.move ();
  152.     inv3bullet.fire ();
  153.   }
  154.   if (invader4.InvHP > 0) {
  155.     inv4bullet.display ();
  156.     inv4bullet.move ();
  157.     inv4bullet.fire ();
  158.   }
  159.   if (invader5.InvHP > 0) {
  160.     inv5bullet.display ();
  161.     inv5bullet.move ();
  162.     inv5bullet.fire ();
  163.   }
  164.   if (invader6.InvHP > 0) {
  165.     inv6bullet.display ();
  166.     inv6bullet.move ();
  167.     inv6bullet.fire ();
  168.   }
  169.   if (invader7.InvHP > 0) {
  170.     inv7bullet.display ();
  171.     inv7bullet.move ();
  172.     inv7bullet.fire ();
  173.   }
  174.   if (invader8.InvHP > 0) {
  175.     inv8bullet.display ();
  176.     inv8bullet.move ();
  177.     inv8bullet.fire ();
  178.   }
  179.   
  180.   //Bullet hits Invaders - Lose 1HP (destroyed)
  181.   if (invader1.intersect (bullet)) {
  182.     invader1.HP ();
  183.   }
  184.   if (invader2.intersect (bullet)) {
  185.     invader2.HP ();
  186.   }
  187.   if (invader3.intersect (bullet)) {
  188.     invader3.HP ();
  189.   }
  190.   if (invader4.intersect (bullet)) {
  191.     invader4.HP ();
  192.   }
  193.   if (invader5.intersect (bullet)) {
  194.     invader5.HP ();
  195.   }
  196.   if (invader6.intersect (bullet)) {
  197.     invader6.HP ();
  198.   }
  199.   if (invader7.intersect (bullet)) {
  200.     invader7.HP ();
  201.   }
  202.   if (invader8.intersect (bullet)) {
  203.     invader8.HP ();
  204.   }
  205. //Invader Bullet hits Spaceship - Lose 1HP
  206.   if (inv1bullet.intersect (spaceship)) {
  207.     spaceship.HP ();
  208.     inv1bullet.bulletFired = false;
  209.     inv1bullet.bulletHit = true;
  210.   }
  211.   if (inv2bullet.intersect (spaceship)) {
  212.     spaceship.HP ();
  213.     inv2bullet.bulletFired = false;
  214.     inv2bullet.bulletHit = true;
  215.   }
  216.   if (inv3bullet.intersect (spaceship)) {
  217.     spaceship.HP ();
  218.     inv3bullet.bulletFired = false;
  219.     inv3bullet.bulletHit = true;
  220.   }
  221.   if (inv4bullet.intersect (spaceship)) {
  222.     spaceship.HP ();
  223.     inv4bullet.bulletFired = false;
  224.     inv4bullet.bulletHit = true;
  225.   }
  226.   if (inv5bullet.intersect (spaceship)) {
  227.     spaceship.HP ();
  228.     inv5bullet.bulletFired = false;
  229.     inv5bullet.bulletHit = true;
  230.   }
  231.   if (inv6bullet.intersect (spaceship)) {
  232.     spaceship.HP ();
  233.     inv6bullet.bulletFired = false;
  234.     inv6bullet.bulletHit = true;
  235.   }
  236.   if (inv7bullet.intersect (spaceship)) {
  237.     spaceship.HP ();
  238.     inv7bullet.bulletFired = false;
  239.     inv7bullet.bulletHit = true;
  240.   }
  241.   if (inv8bullet.intersect (spaceship)) {
  242.     spaceship.HP ();
  243.     inv8bullet.bulletFired = false;
  244.     inv8bullet.bulletHit = true;
  245.   }
  246. }

  248. //Bullet fired on Mouse Press
  249. void mousePressed () {
  250.   if ((bullet.bulletHit == true) && (bullet.bulletFired == false)); {
  251.     bullet.bulletFired = true;
  252.     bullet.bulletHit = false;
  253.   }
  254. }

  257. //create Invader class
  258. class Invader {
  259.   
  260.   //Invader Variables
  261.   float InvXpos;
  262.   float InvYpos;
  263.   float InvXspd;
  264.   float InvYspd;
  265.   int InvHP;
  266.   float InvXconst;
  267.   float InvXconstRev;
  268.   int lastMillis = 0;
  269.   boolean InvGameOver = false;
  270.   boolean InvDead = false;
  271.   float InvBulletX;
  272.   float InvBulletY;
  273.   int InvBulletLength = 10;
  274.   int InvBulletSpd = 40;
  275.   
  276.   //Invader Constructor
  277.   Invader (float _xpos,float _ypos) {
  278.     InvXpos = _xpos;
  279.     InvYpos = _ypos;
  280.     InvHP = 1;
  281.     InvXspd = 4;
  282.     InvXconst = _xpos +120; //change 65 to see difference
  283.     InvXconstRev = _xpos -120; //think its to stop InvBullets going too far in X direction
  284.   }
  285.   
  286.   //Invader
  287.   void display () {
  288.     if (InvHP > 0) {
  289.       fill (0,0,255);
  290.       noStroke ();
  291.       smooth ();
  292.       ellipse (InvXpos,InvYpos,50,50);
  293.     }
  294.   }
  295.   
  296.   //Invader hit by Bullet
  297.   boolean intersect (bullet a) {
  298.     float distance = dist (InvXpos,InvYpos,bullet.bulletX,bullet.bulletY-bullet.bulletLength /2);
  299.     if (distance < 10) {
  300.       return true;
  301.     } else {
  302.       return false;
  303.     }
  304.   }
  305.   void HP () {
  306.     if (InvHP > 0) {
  307.       InvHP = InvHP -1;
  308.       spaceship.InvCount = spaceship.InvCount -1;
  309.       bullet.bulletFired = false;
  310.       bullet.bulletHit = true;
  311.     } else {
  312.       InvDead = true;
  313.     }
  314.   }
  315.   
  316.   //Invader Movement - side to side and then move down
  317.   void move () {
  318.     if (spaceship.GameOver == false) {
  319.       InvXpos = InvXpos + InvXspd;
  320.       if (InvXpos > InvXconst) InvXspd = InvXspd *-1;
  321.       if (InvXpos < InvXconstRev) InvXspd = InvXspd *-1;
  322.       if (millis () > lastMillis + 20000) {
  323.         lastMillis = millis ();
  324.         InvYpos = InvYpos +50;
  325.         InvXspd = InvXspd *1.25;
  326.       }
  327.     }
  328.     
  329.     //When Invaders reach Shields, Game Over
  330.     if (InvYpos > 475) spaceship.GameOver = true;
  331.   }
  332. }

  335. //create Invader Bullet 1 class
  336. class Inv1Bullet {
  337.   
  338.   //Invader Bullet Variables
  339.   float InvBulletX;
  340.   float InvBulletY;
  341.   int InvBulletLength = 10;
  342.   int InvBulletSpd = 40;
  343.   float InvBulletXspd;
  344.   float InvBulletYspd;
  345.   float InvBulletXconst;
  346.   float InvBulletXconstRev;
  347.   int lastMillis = 0;
  348.   boolean bulletFired;
  349.   boolean bulletHit;
  350.   float r = random (100,5000);
  351.   
  352.   //Invader 1 Bullet constuctor
  353.   Inv1Bullet (float _xpos, float _ypos) {
  354.     bulletFired = false;
  355.     bulletHit = true;
  356.     InvBulletX = _xpos;
  357.     InvBulletY = _ypos + InvBulletLength/2;
  358.     InvBulletXspd = 2;
  359.     InvBulletXconst = _xpos +50;
  360.     InvBulletXconstRev = _xpos -50;
  361.   }
  362.   
  363.   //Invader 1 Bullet
  364.   void display () {
  365.     if ((spaceship.GameOver == false) && (invader1.InvDead == false)) {
  366.       if (bulletFired == false) {
  367.         InvBulletX = invader1.InvXpos;
  368.         InvBulletY = invader1.InvYpos;
  369.         fill (0,0,255);
  370.       }
  371.       if (bulletFired == true) {
  372.         fill (255,166,0);
  373.       }
  374.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  375.       strokeWeight (3);
  376.     }
  377.   }
  378.   
  379.   //Invader 1 Bullet Hits Spaceship
  380.   boolean intersect (SpaceShip a) {
  381.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  382.     if (distance2 <20){
  383.       return true;
  384.     } else {
  385.       return false;
  386.     }
  387.   }
  388.   
  389.   //Invader 1 Bullet Movement
  390.   void move () {
  391.     if (spaceship.GameOver == false) {
  392.       InvBulletX = InvBulletX + InvBulletXspd;
  393.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  394.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  395.       if (millis () > lastMillis + 20000) {
  396.         lastMillis = millis ();
  397.         InvBulletY = InvBulletY +50;
  398.         InvBulletXspd = InvBulletXspd *1.25;
  399.       }
  400.       if ((bulletHit == true) && (bulletFired == false)); {
  401.         if (millis () > r) {
  402.           lastMillis = millis ();
  403.           bulletFired = true;
  404.           bulletHit = false;
  405.           float t = random (5000,10000);
  406.           r = r+t;
  407.         }
  408.       }
  409.     }
  410.   }
  411.   
  412.   //Invader 1 Bullet Random Firing
  413.   void fire () {
  414.     if (bulletFired == true) {
  415.       InvBulletY = InvBulletY +20;
  416.     }
  417.     if (InvBulletY > height) {
  418.       bulletFired = false;
  419.       bulletHit = true;
  420.     }
  421.     if (InvBulletY > 475) {
  422.       if (InvBulletX > 90) {
  423.         if(InvBulletX < 190) {
  424.           bulletFired = false;
  425.           bulletHit = true;
  426.         }
  427.       }
  428.       if (InvBulletX > 330) {
  429.         if(InvBulletX < 430) {
  430.           bulletFired = false;
  431.           bulletHit = true;
  432.         }
  433.       }
  434.       if (InvBulletX > 570) {
  435.         if(InvBulletX < 670) {
  436.           bulletFired = false;
  437.           bulletHit = true;
  438.         }
  439.       }
  440.       if (InvBulletX > 810) {
  441.         if(InvBulletX < 910) {
  442.           bulletFired = false;
  443.           bulletHit = true;
  444.         }
  445.       }
  446.     }
  447.   }
  448. }

  451. //create SpaceShip class
  452. class SpaceShip {
  453.   
  454.   //Spaceship Variables
  455.   float ShipXpos;
  456.   float ShipYpos;
  457.   int ShipHP;
  458.   int InvCount;
  459.   boolean win = false;
  460.   boolean loose = false;
  461.   boolean GameOver = false;
  462.   boolean Dead = false;
  463.   
  464.   //SpaceShip Constructor
  465.   SpaceShip () {
  466.     ShipHP = 5;
  467.     InvCount = 8;
  468.   }
  469.   
  470.   //Spaceship
  471.   void display () {
  472.     if (ShipHP > 0) {
  473.       fill (255,0,0);
  474.       smooth();
  475.       if (GameOver == false) {
  476.         noStroke ();
  477.         triangle(ShipXpos,ShipYpos-25,ShipXpos-40,ShipYpos,ShipXpos+40,ShipYpos);
  478.         float ShipXpos = constrain (mouseX,40,560);
  479.         float ShipYpos = constrain (mouseY,575,575);
  480.       }
  481.     }
  482.   }
  483.   
  484.   //SpaceShip hit by Invader Bullet
  485.   void HP () {
  486.     if (ShipHP > 0) {
  487.       ShipHP = ShipHP -1;
  488.     }
  489.     if (ShipHP < 1) {
  490.       GameOver = true;
  491.     }
  492.   }
  493.   
  494.   //Game Won
  495.   void win () {
  496.     win = true;
  497.     gameplay = false;
  498.     loadFont ("ArialMT-16.vlw");
  499.     fill (255);
  500.     textAlign (CENTER);
  501.     text ("Well Done, You have Destroyed All Invaders",width/2,height/2);
  502.   }
  503.   
  504.   //Game Lost
  505.   void lose () {
  506.     gameplay = false;
  507.     
  508.     loadFont ("ArialMT-16.vlw");
  509.     fill (255);
  510.     textAlign (CENTER);
  511.     text ("GAME OVER",width/2,width/2);
  512.   }
  513. }
  516. //create bullet class
  517. class bullet {
  518.   
  519.   //bullet variables
  520.   float bulletX;
  521.   float bulletY;
  522.   int bulletSpd;
  523.   boolean bulletFired;
  524.   boolean bulletHit;
  525.   int bulletLength;
  526.   float xpos;
  527.   float ypos;
  528.   
  529.   //bullet constructor
  530.   bullet () {
  531.     bulletFired = false;
  532.     bulletHit = true;
  533.     bulletLength = 10;
  534.     bulletSpd = 0;
  535.   }
  536.   
  537.   //Bullet
  538.   void display () {
  539.     if (spaceship.GameOver == false) {
  540.       line (bulletX,bulletY,bulletX,bulletY-bulletLength);
  541.       fill (255,0,0);
  542.       strokeWeight (3);
  543.       
  544.       if (bulletFired == false) {
  545.         bulletX = constrain (mouseX,40,560);
  546.         bulletY = constrain (mouseY,575,575);
  547.       }
  548.     }
  549.   }
  550.   
  551.   //Bullet Movement
  552.   void move () {
  553.     if (bulletFired == true) {
  554.       bulletY = bulletY -20;
  555.     }
  556.     if (bulletY <= 30) {
  557.       bulletFired = false;
  558.       bulletHit = true;
  559.     }
  560.     if (bulletY < 525){
  561.       if (bulletX > 90) {
  562.         if (bulletX < 190) {
  563.           bulletFired = false;
  564.           bulletHit = true;
  565.         }
  566.       }
  567.       if (bulletX > 330) {
  568.         if (bulletX < 430) {
  569.           bulletFired = false;
  570.           bulletHit = true;
  571.         }
  572.       }
  573.       if (bulletX > 670) {
  574.         if (bulletX < 770) {
  575.           bulletFired = false;
  576.           bulletHit = true;
  577.         }
  578.       }
  579.       if (bulletX > 810) {
  580.         if (bulletX < 910) {
  581.           bulletFired = false;
  582.           bulletHit = true;
  583.         }
  584.       }
  585.     }
  586.   }
  587. }

Replies(3)

marvellkid
marvellkid

Re: Creating Space Invaders - Can't Stop 'Game Over' Screen coming up at start

2 years ago
Copy code
  2. //create Invader Bullet 1 class
  3. class Inv2Bullet {
  4.   
  5.   //Invader Bullet Variables
  6.   float InvBulletX;
  7.   float InvBulletY;
  8.   int InvBulletLength = 10;
  9.   int InvBulletSpd = 40;
  10.   float InvBulletXspd;
  11.   float InvBulletYspd;
  12.   float InvBulletXconst;
  13.   float InvBulletXconstRev;
  14.   int lastMillis = 0;
  15.   boolean bulletFired;
  16.   boolean bulletHit;
  17.   float r = random (100,5000);
  18.   
  19.   //Invader 2 Bullet constuctor
  20.   Inv2Bullet (float _xpos, float _ypos) {
  21.     bulletFired = false;
  22.     bulletHit = true;
  23.     InvBulletX = _xpos;
  24.     InvBulletY = _ypos + InvBulletLength/2;
  25.     InvBulletXspd = 2;
  26.     InvBulletXconst = _xpos +50;
  27.     InvBulletXconstRev = _xpos -50;
  28.   }
  29.   
  30.   //Invader 2 Bullet
  31.   void display () {
  32.     if ((spaceship.GameOver == false) && (invader1.InvDead == false)) {
  33.       if (bulletFired == false) {
  34.         InvBulletX = invader1.InvXpos;
  35.         InvBulletY = invader1.InvYpos;
  36.         fill (0,0,255);
  37.       }
  38.       if (bulletFired == true) {
  39.         fill (255,166,0);
  40.       }
  41.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  42.       strokeWeight (3);
  43.     }
  44.   }

  46.   //Invader 2 Bullet Hits Spaceship
  47.   boolean intersect (SpaceShip a) {
  48.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  49.     if (distance2 <20){
  50.       return true;
  51.     } else {
  52.       return false;
  53.     }
  54.   }
  55.   
  56.   //Invader 2 Bullet Movement
  57.   void move () {
  58.     if (spaceship.GameOver == false) {
  59.       InvBulletX = InvBulletX + InvBulletXspd;
  60.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  61.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  62.       if (millis () > lastMillis + 20000) {
  63.         lastMillis = millis ();
  64.         InvBulletY = InvBulletY +50;
  65.         InvBulletXspd = InvBulletXspd *1.25;
  66.       }
  67.       if ((bulletHit == true) && (bulletFired == false)); {
  68.         if (millis () > r) {
  69.           lastMillis = millis ();
  70.           bulletFired = true;
  71.           bulletHit = false;
  72.           float t = random (5000,10000);
  73.           r = r+t;
  74.         }
  75.       }
  76.     }
  77.   }
  78.   
  79.   //Invader 2 Bullet Random Firing
  80.   void fire () {
  81.     if (bulletFired == true) {
  82.       InvBulletY = InvBulletY +20;
  83.     }
  84.     if (InvBulletY > height) {
  85.       bulletFired = false;
  86.       bulletHit = true;
  87.     }
  88.     if (InvBulletY > 475) {
  89.       if (InvBulletX > 90) {
  90.         if(InvBulletX < 190) {
  91.           bulletFired = false;
  92.           bulletHit = true;
  93.         }
  94.       }
  95.       if (InvBulletX > 330) {
  96.         if(InvBulletX < 430) {
  97.           bulletFired = false;
  98.           bulletHit = true;
  99.         }
  100.       }
  101.       if (InvBulletX > 570) {
  102.         if(InvBulletX < 670) {
  103.           bulletFired = false;
  104.           bulletHit = true;
  105.         }
  106.       }
  107.       if (InvBulletX > 810) {
  108.         if(InvBulletX < 910) {
  109.           bulletFired = false;
  110.           bulletHit = true;
  111.         }
  112.       }
  113.     }
  114.   }
  115. }

  118. //create Invader Bullet 1 class
  119. class Inv3Bullet {
  120.   
  121.   //Invader Bullet Variables
  122.   float InvBulletX;
  123.   float InvBulletY;
  124.   int InvBulletLength = 10;
  125.   int InvBulletSpd = 40;
  126.   float InvBulletXspd;
  127.   float InvBulletYspd;
  128.   float InvBulletXconst;
  129.   float InvBulletXconstRev;
  130.   int lastMillis = 0;
  131.   boolean bulletFired;
  132.   boolean bulletHit;
  133.   float r = random (100,5000);
  134.   
  135.   //Invader 3 Bullet constuctor
  136.   Inv3Bullet (float _xpos, float _ypos) {
  137.     bulletFired = false;
  138.     bulletHit = true;
  139.     InvBulletX = _xpos;
  140.     InvBulletY = _ypos + InvBulletLength/2;
  141.     InvBulletXspd = 2;
  142.     InvBulletXconst = _xpos +50;
  143.     InvBulletXconstRev = _xpos -50;
  144.   }
  145.   
  146.   //Invader 3 Bullet
  147.   void display () {
  148.     if ((spaceship.GameOver == false) && (invader3.InvDead == false)) {
  149.       if (bulletFired == false) {
  150.         InvBulletX = invader3.InvXpos;
  151.         InvBulletY = invader3.InvYpos;
  152.         fill (0,0,255);
  153.       }
  154.       if (bulletFired == true) {
  155.         fill (255,166,0);
  156.       }
  157.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  158.       strokeWeight (3);
  159.     }
  160.   }
  161.   
  162.   //Invader 3 Bullet Hits Spaceship
  163.   boolean intersect (SpaceShip a) {
  164.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  165.     if (distance2 <20){
  166.       return true;
  167.     } else {
  168.       return false;
  169.     }
  170.   }
  171.   
  172.   //Invader 3 Bullet Movement
  173.   void move () {
  174.     if (spaceship.GameOver == false) {
  175.       InvBulletX = InvBulletX + InvBulletXspd;
  176.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  177.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  178.       if (millis () > lastMillis + 20000) {
  179.         lastMillis = millis ();
  180.         InvBulletY = InvBulletY +50;
  181.         InvBulletXspd = InvBulletXspd *1.25;
  182.       }
  183.       if ((bulletHit == true) && (bulletFired == false)); {
  184.         if (millis () > r) {
  185.           lastMillis = millis ();
  186.           bulletFired = true;
  187.           bulletHit = false;
  188.           float t = random (5000,10000);
  189.           r = r+t;
  190.         }
  191.       }
  192.     }
  193.   }
  194.   
  195.   //Invader 3 Bullet Random Firing
  196.   void fire () {
  197.     if (bulletFired == true) {
  198.       InvBulletY = InvBulletY +20;
  199.     }
  200.     if (InvBulletY > height) {
  201.       bulletFired = false;
  202.       bulletHit = true;
  203.     }
  204.     if (InvBulletY > 475) {
  205.       if (InvBulletX > 90) {
  206.         if(InvBulletX < 190) {
  207.           bulletFired = false;
  208.           bulletHit = true;
  209.         }
  210.       }
  211.       if (InvBulletX > 330) {
  212.         if(InvBulletX < 430) {
  213.           bulletFired = false;
  214.           bulletHit = true;
  215.         }
  216.       }
  217.       if (InvBulletX > 570) {
  218.         if(InvBulletX < 670) {
  219.           bulletFired = false;
  220.           bulletHit = true;
  221.         }
  222.       }
  223.       if (InvBulletX > 810) {
  224.         if(InvBulletX < 910) {
  225.           bulletFired = false;
  226.           bulletHit = true;
  227.         }
  228.       }
  229.     }
  230.   }
  231. }

  234. //create Invader Bullet 1 class
  235. class Inv4Bullet {
  236.   
  237.   //Invader Bullet Variables
  238.   float InvBulletX;
  239.   float InvBulletY;
  240.   int InvBulletLength = 10;
  241.   int InvBulletSpd = 40;
  242.   float InvBulletXspd;
  243.   float InvBulletYspd;
  244.   float InvBulletXconst;
  245.   float InvBulletXconstRev;
  246.   int lastMillis = 0;
  247.   boolean bulletFired;
  248.   boolean bulletHit;
  249.   float r = random (100,5000);
  250.   
  251.   //Invader 4 Bullet constuctor
  252.   Inv4Bullet (float _xpos, float _ypos) {
  253.     bulletFired = false;
  254.     bulletHit = true;
  255.     InvBulletX = _xpos;
  256.     InvBulletY = _ypos + InvBulletLength/2;
  257.     InvBulletXspd = 2;
  258.     InvBulletXconst = _xpos +50;
  259.     InvBulletXconstRev = _xpos -50;
  260.   }
  261.   
  262.   //Invader 4 Bullet
  263.   void display () {
  264.     if ((spaceship.GameOver == false) && (invader4.InvDead == false)) {
  265.       if (bulletFired == false) {
  266.         InvBulletX = invader4.InvXpos;
  267.         InvBulletY = invader4.InvYpos;
  268.         fill (0,0,255);
  269.       }
  270.       if (bulletFired == true) {
  271.         fill (255,166,0);
  272.       }
  273.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  274.       strokeWeight (3);
  275.     }
  276.   }
  277.   
  278.   //Invader 4 Bullet Hits Spaceship
  279.   boolean intersect (SpaceShip a) {
  280.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  281.     if (distance2 <20){
  282.       return true;
  283.     } else {
  284.       return false;
  285.     }
  286.   }
  287.   
  288.   //Invader 4 Bullet Movement
  289.   void move () {
  290.     if (spaceship.GameOver == false) {
  291.       InvBulletX = InvBulletX + InvBulletXspd;
  292.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  293.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  294.       if (millis () > lastMillis + 20000) {
  295.         lastMillis = millis ();
  296.         InvBulletY = InvBulletY +50;
  297.         InvBulletXspd = InvBulletXspd *1.25;
  298.       }
  299.       if ((bulletHit == true) && (bulletFired == false)); {
  300.         if (millis () > r) {
  301.           lastMillis = millis ();
  302.           bulletFired = true;
  303.           bulletHit = false;
  304.           float t = random (5000,10000);
  305.           r = r+t;
  306.         }
  307.       }
  308.     }
  309.   }
  310.   
  311.   //Invader 4 Bullet Random Firing
  312.   void fire () {
  313.     if (bulletFired == true) {
  314.       InvBulletY = InvBulletY +20;
  315.     }
  316.     if (InvBulletY > height) {
  317.       bulletFired = false;
  318.       bulletHit = true;
  319.     }
  320.     if (InvBulletY > 475) {
  321.       if (InvBulletX > 90) {
  322.         if(InvBulletX < 190) {
  323.           bulletFired = false;
  324.           bulletHit = true;
  325.         }
  326.       }
  327.       if (InvBulletX > 330) {
  328.         if(InvBulletX < 430) {
  329.           bulletFired = false;
  330.           bulletHit = true;
  331.         }
  332.       }
  333.       if (InvBulletX > 570) {
  334.         if(InvBulletX < 670) {
  335.           bulletFired = false;
  336.           bulletHit = true;
  337.         }
  338.       }
  339.       if (InvBulletX > 810) {
  340.         if(InvBulletX < 910) {
  341.           bulletFired = false;
  342.           bulletHit = true;
  343.         }
  344.       }
  345.     }
  346.   }
  347. }

  350. //create Invader Bullet 1 class
  351. class Inv5Bullet {
  352.   
  353.   //Invader Bullet Variables
  354.   float InvBulletX;
  355.   float InvBulletY;
  356.   int InvBulletLength = 10;
  357.   int InvBulletSpd = 40;
  358.   float InvBulletXspd;
  359.   float InvBulletYspd;
  360.   float InvBulletXconst;
  361.   float InvBulletXconstRev;
  362.   int lastMillis = 0;
  363.   boolean bulletFired;
  364.   boolean bulletHit;
  365.   float r = random (100,5000);
  366.   
  367.   //Invader 5 Bullet constuctor
  368.   Inv5Bullet (float _xpos, float _ypos) {
  369.     bulletFired = false;
  370.     bulletHit = true;
  371.     InvBulletX = _xpos;
  372.     InvBulletY = _ypos + InvBulletLength/2;
  373.     InvBulletXspd = 2;
  374.     InvBulletXconst = _xpos +50;
  375.     InvBulletXconstRev = _xpos -50;
  376.   }
  377.   
  378.   //Invader 5 Bullet
  379.   void display () {
  380.     if ((spaceship.GameOver == false) && (invader5.InvDead == false)) {
  381.       if (bulletFired == false) {
  382.         InvBulletX = invader5.InvXpos;
  383.         InvBulletY = invader5.InvYpos;
  384.         fill (0,0,255);
  385.       }
  386.       if (bulletFired == true) {
  387.         fill (255,166,0);
  388.       }
  389.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  390.       strokeWeight (3);
  391.     }
  392.   }
  393.   
  394.   //Invader 5 Bullet Hits Spaceship
  395.   boolean intersect (SpaceShip a) {
  396.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  397.     if (distance2 <20){
  398.       return true;
  399.     } else {
  400.       return false;
  401.     }
  402.   }
  403.   
  404.   //Invader 5 Bullet Movement
  405.   void move () {
  406.     if (spaceship.GameOver == false) {
  407.       InvBulletX = InvBulletX + InvBulletXspd;
  408.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  409.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  410.       if (millis () > lastMillis + 20000) {
  411.         lastMillis = millis ();
  412.         InvBulletY = InvBulletY +50;
  413.         InvBulletXspd = InvBulletXspd *1.25;
  414.       }
  415.       if ((bulletHit == true) && (bulletFired == false)); {
  416.         if (millis () > r) {
  417.           lastMillis = millis ();
  418.           bulletFired = true;
  419.           bulletHit = false;
  420.           float t = random (5000,10000);
  421.           r = r+t;
  422.         }
  423.       }
  424.     }
  425.   }
  426.   
  427.   //Invader 5 Bullet Random Firing
  428.   void fire () {
  429.     if (bulletFired == true) {
  430.       InvBulletY = InvBulletY +20;
  431.     }
  432.     if (InvBulletY > height) {
  433.       bulletFired = false;
  434.       bulletHit = true;
  435.     }
  436.     if (InvBulletY > 475) {
  437.       if (InvBulletX > 90) {
  438.         if(InvBulletX < 190) {
  439.           bulletFired = false;
  440.           bulletHit = true;
  441.         }
  442.       }
  443.       if (InvBulletX > 330) {
  444.         if(InvBulletX < 430) {
  445.           bulletFired = false;
  446.           bulletHit = true;
  447.         }
  448.       }
  449.       if (InvBulletX > 570) {
  450.         if(InvBulletX < 670) {
  451.           bulletFired = false;
  452.           bulletHit = true;
  453.         }
  454.       }
  455.       if (InvBulletX > 810) {
  456.         if(InvBulletX < 910) {
  457.           bulletFired = false;
  458.           bulletHit = true;
  459.         }
  460.       }
  461.     }
  462.   }
  463. }

  466. //create Invader Bullet 1 class
  467. class Inv6Bullet {
  468.   
  469.   //Invader Bullet Variables
  470.   float InvBulletX;
  471.   float InvBulletY;
  472.   int InvBulletLength = 10;
  473.   int InvBulletSpd = 40;
  474.   float InvBulletXspd;
  475.   float InvBulletYspd;
  476.   float InvBulletXconst;
  477.   float InvBulletXconstRev;
  478.   int lastMillis = 0;
  479.   boolean bulletFired;
  480.   boolean bulletHit;
  481.   float r = random (100,5000);
  482.   
  483.   //Invader 6 Bullet constuctor
  484.   Inv6Bullet (float _xpos, float _ypos) {
  485.     bulletFired = false;
  486.     bulletHit = true;
  487.     InvBulletX = _xpos;
  488.     InvBulletY = _ypos + InvBulletLength/2;
  489.     InvBulletXspd = 2;
  490.     InvBulletXconst = _xpos +50;
  491.     InvBulletXconstRev = _xpos -50;
  492.   }
  493.   
  494.   //Invader 6 Bullet
  495.   void display () {
  496.     if ((spaceship.GameOver == false) && (invader6.InvDead == false)) {
  497.       if (bulletFired == false) {
  498.         InvBulletX = invader6.InvXpos;
  499.         InvBulletY = invader6.InvYpos;
  500.         fill (0,0,255);
  501.       }
  502.       if (bulletFired == true) {
  503.         fill (255,166,0);
  504.       }
  505.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  506.       strokeWeight (3);
  507.     }
  508.   }
  509.   
  510.   //Invader 6 Bullet Hits Spaceship
  511.   boolean intersect (SpaceShip a) {
  512.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  513.     if (distance2 <20){
  514.       return true;
  515.     } else {
  516.       return false;
  517.     }
  518.   }
  519.   
  520.   //Invader 6 Bullet Movement
  521.   void move () {
  522.     if (spaceship.GameOver == false) {
  523.       InvBulletX = InvBulletX + InvBulletXspd;
  524.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  525.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  526.       if (millis () > lastMillis + 20000) {
  527.         lastMillis = millis ();
  528.         InvBulletY = InvBulletY +50;
  529.         InvBulletXspd = InvBulletXspd *1.25;
  530.       }
  531.       if ((bulletHit == true) && (bulletFired == false)); {
  532.         if (millis () > r) {
  533.           lastMillis = millis ();
  534.           bulletFired = true;
  535.           bulletHit = false;
  536.           float t = random (5000,10000);
  537.           r = r+t;
  538.         }
  539.       }
  540.     }
  541.   }
  542.   
  543.   //Invader 6 Bullet Random Firing
  544.   void fire () {
  545.     if (bulletFired == true) {
  546.       InvBulletY = InvBulletY +20;
  547.     }
  548.     if (InvBulletY > height) {
  549.       bulletFired = false;
  550.       bulletHit = true;
  551.     }
  552.     if (InvBulletY > 475) {
  553.       if (InvBulletX > 90) {
  554.         if(InvBulletX < 190) {
  555.           bulletFired = false;
  556.           bulletHit = true;
  557.         }
  558.       }
  559.       if (InvBulletX > 330) {
  560.         if(InvBulletX < 430) {
  561.           bulletFired = false;
  562.           bulletHit = true;
  563.         }
  564.       }
  565.       if (InvBulletX > 570) {
  566.         if(InvBulletX < 670) {
  567.           bulletFired = false;
  568.           bulletHit = true;
  569.         }
  570.       }
  571.       if (InvBulletX > 810) {
  572.         if(InvBulletX < 910) {
  573.           bulletFired = false;
  574.           bulletHit = true;
  575.         }
  576.       }
  577.     }
  578.   }
  579. }

  582. //create Invader Bullet 1 class
  583. class Inv7Bullet {
  584.   
  585.   //Invader Bullet Variables
  586.   float InvBulletX;
  587.   float InvBulletY;
  588.   int InvBulletLength = 10;
  589.   int InvBulletSpd = 40;
  590.   float InvBulletXspd;
  591.   float InvBulletYspd;
  592.   float InvBulletXconst;
  593.   float InvBulletXconstRev;
  594.   int lastMillis = 0;
  595.   boolean bulletFired;
  596.   boolean bulletHit;
  597.   float r = random (100,5000);
  598.   
  599.   //Invader 7 Bullet constuctor
  600.   Inv7Bullet (float _xpos, float _ypos) {
  601.     bulletFired = false;
  602.     bulletHit = true;
  603.     InvBulletX = _xpos;
  604.     InvBulletY = _ypos + InvBulletLength/2;
  605.     InvBulletXspd = 2;
  606.     InvBulletXconst = _xpos +50;
  607.     InvBulletXconstRev = _xpos -50;
  608.   }
  609.   
  610.   //Invader 7 Bullet
  611.   void display () {
  612.     if ((spaceship.GameOver == false) && (invader7.InvDead == false)) {
  613.       if (bulletFired == false) {
  614.         InvBulletX = invader7.InvXpos;
  615.         InvBulletY = invader7.InvYpos;
  616.         fill (0,0,255);
  617.       }
  618.       if (bulletFired == true) {
  619.         fill (255,166,0);
  620.       }
  621.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  622.       strokeWeight (3);
  623.     }
  624.   }
  625.   
  626.   //Invader 7 Bullet Hits Spaceship
  627.   boolean intersect (SpaceShip a) {
  628.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  629.     if (distance2 <20){
  630.       return true;
  631.     } else {
  632.       return false;
  633.     }
  634.   }
  635.   
  636.   //Invader 7 Bullet Movement
  637.   void move () {
  638.     if (spaceship.GameOver == false) {
  639.       InvBulletX = InvBulletX + InvBulletXspd;
  640.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  641.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  642.       if (millis () > lastMillis + 20000) {
  643.         lastMillis = millis ();
  644.         InvBulletY = InvBulletY +50;
  645.         InvBulletXspd = InvBulletXspd *1.25;
  646.       }
  647.       if ((bulletHit == true) && (bulletFired == false)); {
  648.         if (millis () > r) {
  649.           lastMillis = millis ();
  650.           bulletFired = true;
  651.           bulletHit = false;
  652.           float t = random (5000,10000);
  653.           r = r+t;
  654.         }
  655.       }
  656.     }
  657.   }
  658.   
  659.   //Invader 7 Bullet Random Firing
  660.   void fire () {
  661.     if (bulletFired == true) {
  662.       InvBulletY = InvBulletY +20;
  663.     }
  664.     if (InvBulletY > height) {
  665.       bulletFired = false;
  666.       bulletHit = true;
  667.     }
  668.     if (InvBulletY > 475) {
  669.       if (InvBulletX > 90) {
  670.         if(InvBulletX < 190) {
  671.           bulletFired = false;
  672.           bulletHit = true;
  673.         }
  674.       }
  675.       if (InvBulletX > 330) {
  676.         if(InvBulletX < 430) {
  677.           bulletFired = false;
  678.           bulletHit = true;
  679.         }
  680.       }
  681.       if (InvBulletX > 570) {
  682.         if(InvBulletX < 670) {
  683.           bulletFired = false;
  684.           bulletHit = true;
  685.         }
  686.       }
  687.       if (InvBulletX > 810) {
  688.         if(InvBulletX < 910) {
  689.           bulletFired = false;
  690.           bulletHit = true;
  691.         }
  692.       }
  693.     }
  694.   }
  695. }
  697. //create Invader Bullet 1 class
  698. class Inv8Bullet {
  699.   
  700.   //Invader Bullet Variables
  701.   float InvBulletX;
  702.   float InvBulletY;
  703.   int InvBulletLength = 10;
  704.   int InvBulletSpd = 40;
  705.   float InvBulletXspd;
  706.   float InvBulletYspd;
  707.   float InvBulletXconst;
  708.   float InvBulletXconstRev;
  709.   int lastMillis = 0;
  710.   boolean bulletFired;
  711.   boolean bulletHit;
  712.   float r = random (100,5000);
  713.   
  714.   //Invader 8 Bullet constuctor
  715.   Inv8Bullet (float _xpos, float _ypos) {
  716.     bulletFired = false;
  717.     bulletHit = true;
  718.     InvBulletX = _xpos;
  719.     InvBulletY = _ypos + InvBulletLength/2;
  720.     InvBulletXspd = 2;
  721.     InvBulletXconst = _xpos +50;
  722.     InvBulletXconstRev = _xpos -50;
  723.   }
  724.   
  725.   //Invader 8 Bullet
  726.   void display () {
  727.     if ((spaceship.GameOver == false) && (invader8.InvDead == false)) {
  728.       if (bulletFired == false) {
  729.         InvBulletX = invader8.InvXpos;
  730.         InvBulletY = invader8.InvYpos;
  731.         fill (0,0,255);
  732.       }
  733.       if (bulletFired == true) {
  734.         fill (255,166,0);
  735.       }
  736.       line (InvBulletX,InvBulletY,InvBulletX,InvBulletY + InvBulletLength);
  737.       strokeWeight (3);
  738.     }
  739.   }
  740.   
  741.   //Invader 8 Bullet Hits Spaceship
  742.   boolean intersect (SpaceShip a) {
  743.     float distance2 = dist (constrain (mouseX,40,560),constrain (mouseY,575,575),InvBulletX,InvBulletY);
  744.     if (distance2 <20){
  745.       return true;
  746.     } else {
  747.       return false;
  748.     }
  749.   }
  750.   
  751.   //Invader 8 Bullet Movement
  752.   void move () {
  753.     if (spaceship.GameOver == false) {
  754.       InvBulletX = InvBulletX + InvBulletXspd;
  755.       if (InvBulletX > InvBulletXconst) InvBulletXspd = InvBulletXspd *-1;
  756.       if (InvBulletX < InvBulletXconstRev) InvBulletXspd = InvBulletXspd *-1;
  757.       if (millis () > lastMillis + 20000) {
  758.         lastMillis = millis ();
  759.         InvBulletY = InvBulletY +50;
  760.         InvBulletXspd = InvBulletXspd *1.25;
  761.       }
  762.       if ((bulletHit == true) && (bulletFired == false)); {
  763.         if (millis () > r) {
  764.           lastMillis = millis ();
  765.           bulletFired = true;
  766.           bulletHit = false;
  767.           float t = random (5000,10000);
  768.           r = r+t;
  769.         }
  770.       }
  771.     }
  772.   }
  773.   
  774.   //Invader 8 Bullet Random Firing
  775.   void fire () {
  776.     if (bulletFired == true) {
  777.       InvBulletY = InvBulletY +20;
  778.     }
  779.     if (InvBulletY > height) {
  780.       bulletFired = false;
  781.       bulletHit = true;
  782.     }
  783.     if (InvBulletY > 475) {
  784.       if (InvBulletX > 90) {
  785.         if(InvBulletX < 190) {
  786.           bulletFired = false;
  787.           bulletHit = true;
  788.         }
  789.       }
  790.       if (InvBulletX > 330) {
  791.         if(InvBulletX < 430) {
  792.           bulletFired = false;
  793.           bulletHit = true;
  794.         }
  795.       }
  796.       if (InvBulletX > 570) {
  797.         if(InvBulletX < 670) {
  798.           bulletFired = false;
  799.           bulletHit = true;
  800.         }
  801.       }
  802.       if (InvBulletX > 810) {
  803.         if(InvBulletX < 910) {
  804.           bulletFired = false;
  805.           bulletHit = true;
  806.         }
  807.       }
  808.     }
  809.   }
  810. }
PhiLho
PhiLho

Re: Creating Space Invaders - Can't Stop 'Game Over' Screen coming up at start

2 years ago
Strange... You use classes but ignore the usage of arrays. And what is the point of making duplicates of a class? It is negation of the principles of OO programming, and the DRY (don't repeat yourself) rule.
By addressing these issues, you might have a more manageable code, and errors might be easier to catch (honestly, I don't feel like analyzing such code...).
jeff_g
jeff_g

Re: Creating Space Invaders - Can't Stop 'Game Over' Screen coming up at start

2 years ago
The code that I offered in this thread cleaned it up a bit.. http://forum.processing.org/topic/expecting-eof-found-class
Not sure where the two meet though..
Top Reply

Statistics

  • 3 Replies
  • 2232  Views
  • 0 Followers

Actions

Related Posts