Java for Video Games at TIP

Using Alarms

alarms are one of the primary ways of event handling (the other being testing conditions like collisions yourself)
they can be used to set a timer in your game or to cause certain things to happen (like release a new enemy every 5 seconds for example)
To make a tracker you need to create a new class inside of your game's regular class. This is what is known as an inner or nested class. Often you don't want to use them but for Alarms it is the simplest way. To make a new Alarm add the following code somewhere inside your regular class, just like you would place a method.
```
   private class MyAlarm implements Alarm
   {
        public void alarm( )
        {
                mySprite.setVisible( !mySprite.isVisible( ) ) ;
        }
   } 
```
When making an Alarm you must always write the alarm( ) method. This method is where you want to put the code that will be executed when the alarm goes off. In this case, it will set the visibility of mySprite (which has to be a field instance of your regular class) to be the opposite of its current visibility. This makes an Alarm data type available, but never actually creates one. To create one and set it to go off you need to place the following in your code wherever you want to start the Alarm at.
```
  scheduleRelative( new MyAlarm( ), time ) ;
```
The time can be any number or numeric variable. For instance, if you put 5 there the new Alarm will go off after 5 seconds. The first parameter must be an alarm, we are just creating one inline by saying "new MyAlarm( )". Alternatively you could make a MyAlarm variable, assign it a new MyAlarm( ), and then pass that variable into scheduleRelative, if you prefer.
What if you want the Alarm to set a specified sprite to be visible/invisible, not mySprite all the time. Then you would need to add more code to your MyAlarm class.
```
  private class MyAlarm implements Alarm
  {
    private Sprite changeSprite ;
    public MyAlarm( Sprite s ) 
    {
      changeSprite = s ;
    }
    public void alarm( )
    {
       changeSprite.setVisible( !changeSprite.isVisible( ) ) ;
    }
  }
```
There are three additions here. The first is to make a field instance called changeSprite that becomes the sprite that has its visibility changed. The second is adding a constructor, which takes a String as a parameter and assigns it to changeSprite. Remember that s and changeSprite are objects, so when you assing s to changeSprite you are really only assigning s's memory reference to changeSprite. So, after that line they are both pointing to the same Sprite sitting out in memory. The final change is alarm( ) is updated to use changeSprite instead of mySprite. Since changeSprite points to the same place as the Sprite you passed in on making the alarm, it will make that Sprite visibile or invisible when the alarm goes off. To start this new alarm we must update our scheduleRelative call to pass in a Sprite to the constructor.
```
  scheduleRelative( new MyAlarm( whateverSpriteYouWant ), time ) ;
```
Finally, you can tell an alarm to reschedule itself. If we wanted changeSprite to blink instead of just turn off or on once we would need to do this. Only the alarm( ) method would need to be changed.
```
  public void alarm( )
  {
    changeSprite.setVisible( !changeSprite.isVisible( ) ) ;
    scheduleRelative( this, 5 ) ;
  }
```
This new scheduleRelative sets up an alarm for "this", which refers to the current alarm going off, to go off in 5 seconds. So, the alarm reschedules itself to go off again in 5sec.

Understanding Alarms

When you schedule an alarm to go off after x seconds, FANG monitors the system clock and once that time period has elapsed it calls the alarm( ) method of the alarm that was scheduled. When you call scheduleRelative, the first argument (or parameter) is the particular Alarm instance that will go off.

When you write an Alarm class it is not specific to one instance of an alarm. Say we wanted two different sprites to blink on the screen, once every 5 seconds. You could do this by making the first MyAlarm just set both of them to turn on/off whenever the alarm( ) method gets called. However, you may not always want the blinking to start at the same time. What if you want want your triangle to blink from the start every 5 seconds but your rectangle to blink only after the user clicks? Then you can use the second MyAlarm we wrote and just schedule two different alarms.

  public void startGame( )
  {
    ....
    scheduleRelative( new MyAlarm( triangle ), 5 ) ;
    ....
  }
  ...
  public void advanceFrame( double timePassed )
  {
    ...
    scheduleRelative( new MyAlarm( rectangle ), 5 ) ;
    ...
  }

You may have noticed that we have used 5 seconds for all of our alarms. You can obviously pass in any number you want in the starting scheduleRelative call, but our scheduleRelative( this, 5 ) INSIDE of the MyAlarm class will always be the same number for all alarms of that type. So if you schedule one alarm to go off in 1sec and another to go in 7, once they do those first wait periods, they will repeat themselves every 5 seconds instead of the original time passed in. What is a way to fix this? HINT: It is similar to how we modified MyAlarm to use different sprites rather than the same one all the time.

More on Alarms

To learn more do the following tutorial: FANG tutorial. Make a new project, package, and class then go through the steps. Note that the wiki's code has "package Jam.firstalarm;" and "import wik.Wiki;" up at the top. You need to change the package to whatever package you created and remove the "import wiki.Wiki;" line before your code will work.