Usable Items

Step 1: Useful Rubbish

According to image from several functioning cameras, heavy battles took place in the area of colony after which multitude of items remained in mess inside rooms. Such first aid kits and ammunition magazines could come in handy...

In this step we will start to add more items which may be useful for Ripley into the project. Since some of these items will be tools at the same time, we will generalise package tools to items.

Class Energy will represent a first aid kit, which will always lift Ripley's spirit and refills her energy to 100%. However, you will implement this functionality a bit later.

For animation representing first aid kit use file energy.

Ripley's energy will be represented by integer. We will use range of values 0 - 100 as amount of percent of remaining energy. Initial value of energy should be 100.

Ensure that after the change of Ripley's state the first aid kit should be removed from scene. If Ripley has full energy, "using" the first aid kit will not happen.

The Use action will allow you to plan usage of Usable actors by other actor that is compatible with its useWith() method. The main task of the Use action is to call useWith() method on the Usable object passed as the action's constructor argument. The argument of the called useWith() method will be the actor for which the action is scheduled. In code it can look like this:

usableActor.useWith(getActor());

new Use(energy).scheduleFor(ripley);

new Use(hammer).scheduleFor(reactor);

Compose new action Use with appropriate existing action.

scene.getGame().getOverlay();

int windowHeight = scene.getGame().getWindowSetup().getHeight();
int yTextPos = windowHeight - GameApplication.STATUS_LINE_OFFSET;

Modify initial value of Ripley's energy for a while to verify behaviour of first aid kit. It should disappear from scene only if Ripley has not full energy when passing through it.

Class Ammo will represent ammunition magazine (ammo), which always lifts up Ripley's mood by increasing amount of bullets in her weapon.

Implement the following behaviour:

• Only instance of class Ripley will be able to take ammo.
• Amount of bullets will be increased by 50.
• Maximal amount of bullets that Ripley can currently hold in her pockets is 500.
• After Ripley "uses" the ammo, remove it from scene.
• When Ripley's amount of bullets is at its maximum, no increasing or removing the ammo from scene will happen.

As sprite for representing the ammo use file named ammo.

Step 2: !Samsonite Backpack

Your task now is to create a backpack, with respect to instructions provided by our tactical and strategic team, with which Ripley will be equipped. This backpack will allow her to have various items at hand which may be needed during the mission. The instructions prepared for you also show a way how to teach Ripley to distinguish items that can fit into her backpack.

To have something to build on, our technological team also prepared a universal interface ActorContainer which represents LIFO collection of specific type of _actor_s. The backpack created by you should implement this interface.

This interface will extend interface Actor and will not define any additional methods. Therefore, it will serve as marker interface which in the scope of type system defines new type for distinguishing group of objects from others - in this case for distinguishing actors that can be stored into backpack.

When implementing Backpack you need to specify type parameter of interface ActorContainer. Since we want Ripley to be able to hold only such items in her backpack which are suitable for it, use type Collectible in there.

Backpack will behave as stack (LIFO). You can use one of collections provided by Java language for storing elements, e.g. ArrayList.

Constructor of backpack will have the following signature:

public Backpack(String name, int capacity)

• name represents name of the backpack,
• capacity defines maximal capacity (i.e. number of items that can be stored in backpack at the same time)

• getCapacity() will represent getter for capacity of backpack.
• getContent() will return copy of list of items in backpack. It is important that the changes made to this list will not influence content of backpack!
• getName() will return name of container (backpack) which will be displayed in game together with its content.
• getSize() will return current amount of items in backpack.

Adhere to the following specification of behaviour while implementing methods:

• Items will be stored in collection in the same order in which they were inserted into backpack.
• Backpack will hold at most as many items as specified by argument capacity at the time of its creation.
• If backpack is full and method for adding another item will be called nevertheless, raise a runtime exception IllegalStateException. In its constructor specify message "<backpack name> is full" where <backpack name> should be substituted with backpack's name.

throw new IllegalStateException();

Interface ActorContainer extends standard Java interface Iterable<E> which defines method iterator(). By implementing this method we will gain the possibility to iterate through backpack's contents by so-called enhanced for loop, as the following code snippet illustrates:

for (Collectible item : backpack) {
    // using item from backpack
}

To implement the method, just returning iterator available on collection storing contents of backpack will suffice.

Backpack is represented as stack. It is important to be able to obtain reference on last inserted item at any time, since this will be the item which which various operations will be performed (e.g. using it or dropping on the ground).

In container you can work only with actor which is on top. Because of that, when you will need to work with another actor which is deeper in the container, you will have to rearrange the content. Instead of taking all actors out and inserting them back in desired order, you can rearrange them directly in container with this method shift().

An example of usage can be the following: if container holds actors in the order D, C, B, A (from last inserted to first inserted), then after calling method shift() the order of actors in container will be C, B, A, D.

The interface will have type parameter bound to type Actor which will determine type of actors in container.

The interface will add the following method to actor:

Backpack getBackpack();

Set backpack's capacity to 10 items and you can name it for example "Ripley's backpack".

After this adjustment, objects of mentioned classes will be possible to insert into backpack.

In scenario, fill backpack with at least 3 items and check if last added item is on the left in backpack displayed in the game. Try calling method shift() to verify reordering of items.

Step 3: man backpack

In this step we will teach Ripley to use backpack that you created. Therefore, you will create several actions thanks to which Ripley will manage it with no problem. You will remember the principle of polymorphism, according to which these actions should not be limited only for Ripley, but to work with any Keeper.

Actions should be adapted to any type of actors in container. Because of that, we will create them with type parameter which will enable to specify type of actors in classes of created actions.

In method execute() find first Collectible actor in scene which collides with (intersects) Keeper actor executing the action. If you find such actor, add it into container of Keeper actor and remove it from scene.

Since action Take adds actors into container, calling method add() can cause exception IllegalStateException to be thrown. Instead of letting the application crash we want to display exception's message on the screen to the player. Therefore, the exception needs to be handled and properly presented.

try {
  // code which can cause exception
} catch (Exception ex) {
  // handling the exception of type Exception
  // get the excpetion's message with ex.getMessage() method
}

overlay.drawText(exception.getMessage(), x, y).showFor(2);

When implementing method execute(), take the topmost actor from container and place it into scene so that its center position matches the center position of Keeper actor which executes the action.

Obtain reference to controlled actor by parametric constructor. Then override method keyPressed() and implement scheduling of actions for work with container as follows:

• **Enter** - take item into backpack
• **Backspace** - drop item which is on top of backpack (last inserted item)
• **S** - shift items in backpack, which will change which item is on top of backpack

For new KeeperController to work with Ripley's backpack by using keyboard, do not forget to create instance of this class in scenario and set it as another listener for handling the input.

Thoroughly check if actions work properly by pressing corresponding keys. In addition to basic functionality of keys and actions for working with backpack, check also unusual situations, for example

• pressing a key to add another item into backpack even if its capacity is full,
• pressing a key to drop item from backpack even when backpack is empty,
• pressing a key to shift items in backpack when it is empty and then when its capacity is full.

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.