Red Alert: Reactor Overheat!

Step 1: Reactor Class

Your task is to create a class which will represent a reactor in Alien Breed game. Its state will be represented by actual temperature of the core, total damage and animation which visualises reactor's current condition.

Since the project uses build tool Gradle, it is necessary to comply with its convention of Java source files placement and therefore you need to create this package in directory src/main/java.

In Java, the notation that tells that class A is a subclass of class B is the following:

class A extends B {

}

Class AbstractActor which you will use as a parent class of new class Reactor is part of library GameLib which is defined among dependencies of your project. Because of that there is no need to create the class again! You only need to import it into the source file of Reactor class. The development environment will facilitate the work for you, after you type in a class name that compiler do not recognizes without an import statement.

They are the following instance variables:

• temperature - current temperature of reactor represented by whole number, with minimal value 0 degrees,
• damage - damage of reactor as percentage, represented by whole numbers in range from 0 (reactor is intact) to 100 (reactor is broken),
• normalAnimation - object of animation which visually represents reactor in its intact state. We will use type Animation represented by class Animation from package sk.tuke.kpi.gamelib.graphics.

When writing instance variables, do not forget that they shouldn't be visible outside the class! Use adequate visibility modifier.

Comment

In computer graphics (mainly in relation to 2D games) a term sprite is used very often. Sprite is a small two-dimensional picture (or animation) which is integrated into larger scene. The effect of animation is created by sequential rendering of several pictures (frames) on the same position.

In game library that we use we will work with objects of type Animation which can be used equally for simple single images and also images containing several frames of sprite's animation.

In initialization of the object set:

• animation which will represent the reactor, by using the following image

  

• initial temperature of reactor's core to value 0, and

• initial percentage of reactor's damage to value 0.

Animations are located in the project in directory src/main/resources/sprites/. When setting path to animation file use a relative path - the root directory is src/main/resources/. As a result, path to reactor's animation will be sprites/reactor_on.png.

To set the animation use the following fragment of code in constructor of Reactor class:

// create animation object
normalAnimation = new Animation("sprites/reactor_on.png", 80, 80, 0.1f, Animation.PlayMode.LOOP_PINGPONG);
// set actor's animation to just created Animation object
setAnimation(normalAnimation);

If you have proceeded correctly, after you run the project (Shift+F10) you will be able to use inspector to create instance of class Reactor and place it into the game.

These methods provide access for reading values of temperature and damage. Naturally, their visibility should be set to public. After that you can check their functionality with inspector.

Step 2: Intermezzo - Method Overloading

Now when you know how to create class and its methods we will show you one of several properties of polymorphism (we will return to it several times later). The property is method overloading.

To set its animation use image computer.

Each of these methods will have 2 parameters of the same type for operands of given arithmetic operation. In one case parameters will be of type int, in other case float. As a result, 4 methods need to be implemented: add() for int, add() for float, sub() for int and sub() for float type. By implementing methods in described way they will become overloaded.

Verify your implementation by running the project and using inspector.

Step 3: Reactor (Over)Heating

Back to reactor! You already know how to get its state and now we will take a look at how to change the state.

This method will return no value and will have one whole-numbered parameter (named e.g. increment) which will represent value by which actual temperature of reactor should increase.

When implementing the method, consider the following conditions:

• With increasing reactor's temperature linearly increase its damage. Reactor starts to be damaged after exceeding temperature 2000 degrees and completely breaks when reaching 6000 degrees and more. Every following attempt to cool down the reactor will not affect its damage that was caused by high temperature (it means that after calling this method reactor's damage cannot be lower than before the method call). When calculating damage, round the decimal part of the result down.

  

  Comment

  Decreasing reactor's damage will be possible only by repairing the reactor, which will be your task later.

• If the temperature after increasing exceeds value 4000 degrees, from that moment reactor's appearance will be represented by the following animation:

  

• If reactor's damage is in the interval <33%, 66%>, temperature rises 1.5-fold; if it exceeds value 66%, temperature rises twofold. In both cases the change of temperature's increase is based on the initial value of parameter increment. After calculating new value of temperature always round the decimal part of the result up to the nearest integer.

• If temperature after increasing reaches (or exceeds) value 6000 degrees, reactor will be broken (its damage reaches value 100%). Broken reactor will be represented by the following animation:

  

• Once reactor's damage reached value 100%, any further increase of temperature will have no effect.

This method will return no value and will have one whole-numbered parameter (named e.g. decrement) which will represent value by which actual temperature of reactor should decrease. Beware, decreasing temperature will not decrease the damage which has already been made by high temperature!

When implementing the method, consider the following conditions:

• If damage of reactor's core is at least 50%, actual decreasing of temperature will be halved compared to the value of parameter decrement.
• If damage of reactor's core is at value 100%, decreasing temperature has no effect at all.
• If resulting temperature of reactor's core drops to 4000 degrees or less, change the animation representing state of reactor to reactor_on.

When you look carefully at methods increaseTemperature() and decreaseTemperature() you will notice that both methods address setting proper animation depending on its temperature. Such duplicity is useless and complicates future changes of functionality. Because of that, refactor your code to separate the common functionality into another method updateAnimation().

After refactoring from previous task do not forget to change also original methods from which the code was extracted so that they will use the new method.

Step 4: Repository

Upload your implementation even if it's not yet complete. We recommend to comment out parts of the code that could cause compilation errors.