Tutorial2:Wackadot:Eclipse

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package wackadot;


import fang.*;
import java.awt.*;
import java.awt.geom.*;

/**
* All about my game here.
* @author YourName
*/
public class Wackadot extends GameLoop
{
   public static void main(String[] argv)
   {
      Wackadot dot=new Wackadot();
      dot.runAsApplication();
   }
}

Line 1: the package this class is in

Line 4: importing the fang package for use in the class.

Lines 14-18: the main method is required to allow the game to be run as an application in addition to it being an applet. (It is an applet because it is derived from the GameLoop class which is indirectly derived from the JApplet class.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package wackadot;

import fang2.core.*;
import fang2.sprites.*;
import fang2.attributes.*;
import fang2.transformers.*;

/**
* All about my game here.
* @author YourName
*/
public class Wackadot extends Game
{
   private Sprite dot;
    
   public void setup()
   {
       makeSprites();
       addSprites();
   }
    
   private void makeSprites()
   {
       dot=new OvalSprite(0.1, 0.1);
       dot.setLocation(0.5, 0.5);
       dot.setColor(getColor("Red"));
   }
    
   private void addSprites()
   {
       addSprite(dot);
   }

   public static void main(String[] argv)
   {
       Wackadot dot=new Wackadot();
       dot.runAsApplication();
   }
}

Line 1: declares the package this class resides in

Line 14: declares a Sprite instance variable that will be used in the game logic eventually.

Lines 16-20: the setup method is called when the Start button is pressed the first time. In this method, you need to make and add all the sprites. Note: for multiplayer games, the number of players is only available once the setup method is called.

Lines 22-27: helper method for constructing and placing sprites. The positions and sizes are relative to a screen which spans (0, 0) to (1, 1).

Lines 29-32: helper method for adding sprites to the canvas. Simply making a sprite does not make it visible. Sprites are only visible once they are added to the canvas within the bounds of the canvas and sized properly.

33
34
35
36
37
38
39

  
   public void advance()
   {
      Location2D mouse=
          getMouse2D();
      dot.setLocation(mouse);
   }

Line 33: this line is intentionally left blank. In general, it is good practice to leave a blank line between methods

Line 34: this method is called automatically between each frame calculated/displayed.

Lines 36-37: gets the mouse of the current player.

Line 38: places the sprite at the same position as the mouse.

Line 39: close brace ending the advance method. Every method body begins and ends with braces.

Last Line of your Code: don't forget the close brace for your entire program. The very last character in every single program is a close brace. Leaving off the close brace will cause many errors to appear. Every class body begins and ends with braces.

13
14
15
16
17

{
   private Sprite dot;
   private Sprite redDot;
   private Sprite blueDot;

Line 15: declares the red dot

Line 16: declares the blue dot

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

 
private void makeSprites()
{
   dot=new OvalSprite(0.1, 0.1);
   dot.setLocation(0.5, 0.5);
   dot.setColor(getColor("red"));

   redDot=new OvalSprite(0.1, 0.1);
   redDot.setLocation(
          randomDouble(),
          randomDouble());
   redDot.setColor(getColor("red"));

   blueDot=new OvalSprite(0.1, 0.1);
   blueDot.setLocation(
          randomDouble(),
          randomDouble());
   blueDot.setColor(getColor("blue"));
}

private void addSprites()
{
   addSprite(dot);
   addSprite(redDot);
   addSprite(blueDot);
}

Lines 32-33, 38-39: uses the provided random number generator to get a random number between 0 and 1.

Lines 46-47: adds the sprites to make them visible

49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

 
private void repositionRandomly(Sprite sprite)
{    
   sprite.setLocation(
       randomDouble(), 
       randomDouble());
}

private void handleCollisions()
{    
   if(dot.intersects(blueDot))
   {
       repositionRandomly(blueDot);    
   }    
   if(dot.intersects(redDot))    
   {
       repositionRandomly(redDot);    
   }
}

public void advance()
{
   Location2D mouse=
       getMouse2D();
   dot.setLocation(mouse);
   handleCollisions();
}

Lines 50-55: helper method for randomly positioning the dot.

Lines 57-67: helper method for handling dot collisions

Lines 59-62: if the dot moving with the mouse collides with the blue dot, then the blue dot is positioned in a random location.

Lines 63-66: if the dot moving with the mouse collides with the red dot, then the red dot is positioned in a random location.

Lines 69-75: don't duplicate the advance method, just add line 77.

Line 74: calls the helper method for handling collisions

56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

 
private void handleCollisions()
{
   if(dot.intersects(blueDot))
   {
       repositionRandomly(blueDot);
       if(dot.getColor().equals(getColor("blue")))
       {
           dot.setColor(getColor("red"));
       }
   }
   if(dot.intersects(redDot))
   {
       repositionRandomly(redDot);
       if(dot.getColor().equals(getColor("red")))
       {
           dot.setColor(getColor("blue"));
       }
   }
}
 

Lines 62-65, 70-73: checks to see if the dot intersected matches the color of the dot. If it does, the color of the dot is changed to the other color.

16
17
18

private Sprite blueDot;
private StringSprite scoreSprite;
 

Line 17: a sprite which will consist of text

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

private void makeSprites()
{
   dot=new OvalSprite(0.1, 0.1);
   dot.setLocation(0.5, 0.5);
   dot.setColor(getColor("red"));

   redDot=new OvalSprite(0.1, 0.1);
   redDot.setLocation(
          random.nextDouble(),
          random.nextDouble());
   redDot.setColor(getColor("red"));

   blueDot=new OvalSprite(0.1, 0.1);
   blueDot.setLocation(
          random.nextDouble(),
          random.nextDouble());
   blueDot.setColor(getColor("blue");

   scoreSprite=new StringSprite("Score: 0");
   scoreSprite.setHeight(0.1);
   scoreSprite.rightJustify();
   scoreSprite.topJustify();
   scoreSprite.setLocation(1, 0);
}

private void addSprites()
{
   addSprite(dot);
   addSprite(redDot);
   addSprite(blueDot);
   addSprite(scoreSprite);
}

Lines 43-47: makes the score sprite. Right justifying means the location will represent the rightmost location. Similarly top justifying means the location represents the topmost location. (1, 0) is the top right which is where the score will be. The text will be 1/10 of the screen high.

Line 55: adds the score sprite to make it visible

17
18
19

private StringSprite scoreSprite;
private int score;
 

Line 18: the integer which will keep the score

20
21
22
23
24
25
26
27
28
29
30
31
32 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
...
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

public void setup()
{
   score=0;
   makeSprites();
   addSprites();
}

private void makeSprites()
{
   dot=new OvalSprite(0.1, 0.1);
   dot.setLocation(0.5, 0.5);
   dot.setColor(getColor("red"));

   redDot=new OvalSprite(0.1, 0.1);
   redDot.setLocation(
          random.nextDouble(),
          random.nextDouble());
   redDot.setColor(getColor("red"));

   blueDot=new OvalSprite(0.1, 0.1);
   blueDot.setLocation(
          random.nextDouble(),
          random.nextDouble());
   blueDot.setColor(getColor("blue"));

   scoreSprite=new StringSprite("Score: "+score);
   scoreSprite.setHeight(0.1);
   scoreSprite.rightJustify();
   scoreSprite.topJustify();
   scoreSprite.setLocation(1, 0);
}
... code not shown
 
private void updateScore()
{
   scoreSprite.setText("Score: "+score);
}

private void handleCollisions()
{
   if(dot.intersects(blueDot))
   {
      repositionRandomly(blueDot);
      if(dot.getColor().equals(getColor("blue")))
      {
         dot.setColor(getColor("red"));
         score++;
      }
      else
      {
         score--;
      }
      updateScore();
   }
   if(dot.intersects(redDot))
   {
      repositionRandomly(redDot);
      if(dot.getColor().equals(getColor("red")))
      {
         dot.setColor(getColor("blue"));
         score++;
      }
      else
      {
         score--;
      }
      updateScore();
   }
}

Line 22: starts the score out at 0

Line ... : Don't type this line into your code.

Lines 45: initializes the score sprite using the score instance variable. You need to change this line to what it looks like here since originally it just made the score zero.

Lines 69-72: updates the score sprite to make sure it represents the current score

Lines 80, 84, 94, 98: changes the score when the dot intersects one of the colored dots. If the dot is the same color as the one intersected, then 1 is added to the score. If the dot is the opposite color of the one intersected, then 1 is subtracted from the score.

Lines 86, 100: when the int score changes, the StringSprite scoreSprite should change. These lines call the helper method to change the scoreSprite to represent the current score.

18
19
20
21

private int score;
private int timeLeft;
private StringSprite timerSprite;
 

Line 19: an integer representing the number of second left

Line 20: the StringSprite which will show the time left

21
22
23
24
25
26
27
28
29
30
31
...
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

 
public void setup()
{
   score=0;
   timeLeft=10;
   makeSprites();
   addSprites();
}

private void makeSprites()
{
   ... code not shown for brevity

   scoreSprite.setLocation(1, 0);

   timerSprite=new StringSprite("Timer: "+timeLeft);
   timerSprite.leftJustify();
   timerSprite.topJustify();
   timerSprite.setHeight(0.1);
   timerSprite.setLocation(0, 0);
}

private void addSprites()
{
   addSprite(dot);
   addSprite(redDot);
   addSprite(blueDot);
   addSprite(scoreSprite);
   addSprite(timerSprite);
}

private void updateTimer()
{
   timerSprite.setText("Timer: "+timeLeft);
}

Line 25: starts the timer out at 10

Line ... : Do not copy this line, just read it.

Lines 54-58: makes the timer sprite

Line 67: adds the timer sprite to make it visible

Lines 70-73: updates the timer sprite to make sure it represents the current time

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
...
133
134
135
136
137
138
139
140
141
142

 
public void setup()
{
   score=0;
   timeLeft=10;
   makeSprites();
   addSprites();
   scheduleRelative(new TimeUpdater(), 1);
}

class TimeUpdater implements Alarm
{
   public void act()
   {
      timeLeft--;
      updateTimer();
      if(timeLeft>0)
      {
         scheduleRelative(this, 1);
      }
   }
}
... Code not shown
public void advance()
{
   if(timeLeft>0)
   {
       Location2D mouse=
           getMouse2D;
       dot.setLocation(mouse);
       handleCollisions();
   }
}

Line 28: schedules the act method of TimeUpdater to be called 1 second from the start of the game. Adding this line will cause an error until the class below in line 31-42 is copied into the class.

Lines 31-42: an inner class in Wackadot used to update the timeLeft.

Lines 33-41: the method called when scheduled

Lines 37-40: if there is still time remaining, this schedules the act method to be called again in 1 second

Line ... : Don't type this line into your code.

Lines 135-141: allows game control and scoring only while there is time left

21
22
23
24
25
26
27
28
29
30

 
public void setup()
{
   score=0;
   timeLeft=10;
   makeSprites();
   addSprites();
   schedule(new TimeUpdater(), 1);
   setHelpText("Lots of help text here later");
}

8
9
10
11
12
13

/**This is a fun, simple game I made using
 * the FANG Engine.
 * @author Your Name Here
 */
public class Wackadot extends Game
{

Lines 8-11: javadoc style comments. When you learn about how to use these, you can make web page documentation using the comments in your program.