I knew you'd come (Ripley)

Step 1: Let's start from the beginning

Until now you were adding actors into a scene in your project either by using Inspector or by writing simple scenarios. However, where did the scene or Inspector come from? Why does the application window have dimensions which it has? In this step we will have a look at how to build the entire application nicely from the beginning... from function main which represents the entry point of Java applications.

Method, which can be set to be the first one called when starting an application, has to have the following signature in the Java language:

public static void main(String[] args) {

}

In file build.gradle.kts change value of variable mainClassName in block application to the full name of recently created Main class which contains static method main():

application {
    mainClassName = "sk.tuke.kpi.oop.game.Main"
}

To create the application we need to prepare at least 3 objects - a window configuration, the game itself, and scene displayed by the game. The following code with accompanying comments illustrates the implementation.

public static void main(String[] args) {
    // setting game window: window name and its dimensions
    WindowSetup windowSetup = new WindowSetup("Project Ellen", 800, 600);

    // creating instance of game application
    // using class `GameApplication` as implementation of interface `Game`
    Game game = new GameApplication(windowSetup, new LwjglBackend()); // in case of Mac OS system use "new Lwjgl2Backend()" as the second parameter

    // creating scene for game
    // using class `World` as implementation of interface `Scene`
    Scene scene = new World("world");

    // adding scene into the game
    game.addScene(scene);

    // running the game
    game.start();
}

Firstly, we can correctly end the game from code by calling method stop() on object of type Game which we can obtain from scene by using method getGame().

There are several options how to react on keyboard's key pressed:

• we will permanently (e.g. in scope of some repeating action) check whether desired key was pressed by using method isKeyPressed(), or
• we will setup a so-called callback in form of lambda passed to method onKeyPressed(), which is called by game library every time a specific key is pressed.

We will use the second option with callback. Because we want to exit the application with the ESCAPE key regardless of the active scene, we will use the game's Input object. The solution may look like this:

game.getInput().onKeyPressed(Input.Key.ESCAPE, () -> game.stop());

Or equivalently with a reference to parameter-less method:

game.getInput().onKeyPressed(Input.Key.ESCAPE, game::stop);

You can call the class e.g. FirstSteps.

This time, the class of scenario will directly implement interface SceneListener from library. In the class, override method sceneInitialized() from interface SceneListener - you will soon write scenario into this method. As before, you can organise individual parts of the scenario into more methods.

In method main() of class Main create instance of scenario's class and add it to created scene by using method addListener().

If you proceeded correctly, after running the application by Gradle task run (the same way of execution as you used before) an empty window will show up, bearing the name which you entered in constructor of WindowSetup.

Notice, that the window with Inspector is not showing up anymore.

implementation("sk.tuke.kpi.gamelib:gamelib-inspector:$gamelibVersion")

Scene scene = new InspectableScene(new World("world"), List.of("sk.tuke.kpi"));
game.addScene(scene);

Step 2: Ripley is back!

The character of basic player that was available up to now is no longer shown in new scene. In his stead you will create our own main character of the game: Ripley. And you will teach her step by step.

In the class create parameterless constructor in which you:

• call constructor of superclass and pass it the name of actor as argument: Ellen,
• set animation with image named player and with play mode LOOP_PINGPONG.

Adding an actor into the scene should be performed by method addActor(Actor actor, int x, int y) by using which you can also define a position where Ripley should be placed. The view on displayed scene will be centred on the position [0, 0] (until we set it otherwise), so this position will be in the middle of the application window.

With correct implementation, after you start the game, empty world will be shown, in the middle of which Ripley will show up on defined position.

Step 3: First Steps with Ellen Ripley

Right now, Ripley can just nervously shuffle on the spot. However, it is about to change soon.

Define 4 directions: NORTH, EAST, SOUTH and WEST.

In enum type Direction add private and final integer instance variables dx and dy which will represent changes of position in x and y axes, necessary for movement in given direction. Initialise the variables in constructor Direction(int dx, int dy) and add getter methods for them.

Movable will extend interface Actor and will contain these methods:

• int getSpeed() for obtaining speed of actor's movement.
• void startedMoving(Direction direction) as listener for the event of movement started in given direction.
• void stoppedMoving() as listener for the event of stopped movement.

Add empty default implementation to methods startedMoving() and stoppedMoving() in the interface, so that it will not be necessary to implement them in each and every Movable actor, unless that actor requires it.

Default implementation of method stoppedMoving() in the interface will look like this:

default void stoppedMoving() {}

Set Ripley's speed to, for example, value 2. In method startedMoving() rotate animation to direction of movement and play it. In method stoppedMoving pause the animation.

Use directly interface Action from library sk.tuke.kpi.gamelib.actions for your implementation. Action will have its own type parameter bound to type Movable, because we want to restrict applicability of the action to actors that can move (they implement Movable).

Its constructor will have parameters defining direction of movement and duration of movement in seconds.

public Move(Direction direction, float duration) {
    // implementation of actor's constructor
}

Add also overloaded constructor with only one parameter of type Direction. In this case we will consider duration as zero, which will mean actor's movement in only one step without repetitions.

Purpose of these methods is as follows:

• getActor() and setActor() serve as getter and setter for actor which executes given action. It is set by scene when action is scheduled.
• isDone() represents ending of action. After action is initialised this method should return false for method execute() to be executed at least one time. Since action Move may take some time to finish, this method should return true only after defined time elapses. You will deal with change of the state in next task.
• reset() method will restore action's state (excluding actor that was set) into initial state as after action creation.

In scope of method execute() implement the following:

• In case this method is invoked for the first time, call method startedMoving() on actor executing the action.
• Update actor's position with regards to direction and speed of movement (you will obtain it by method getSpeed()).
• If total time of action's execution exceeds or is equal to time defined at action instantiation, end the action. It means that until that moment, method isDone() has to return value false. Also, do not forget to call method stoppedMoving() on moving actor.

With correct implementation, Ripley should move in defined direction during defined amount of time, while her animation should play only during her movement.

Step 4: Mission Controller

Ripley now knows how to move, but only according to predefined scenario. However, that will not suffice face-to-face with enemies - we need something more flexible. In this step we will take a look at how to navigate Ripley in real time by using keyboard.

Class MovableController should implement interface KeyboardListener from game library. This interface contains methods that, in style of design pattern observer, serve as listener functions called by library when a change of pressed keys on keyboard occurs. Thus, we can react to pressed (and released) keys by implementing these methods.

Create constructor in the class which accepts reference to Movable actor in its parameter which movement it will control.

Instance variable will be of type Map<Input.Key, Direction> - a mapping where key is keyboard's key and value will be direction of movement. By using method get() that accepts key (Input.Key) we obtain respective value (Direction).

Mapping has to be "filled" by pairs key-direction. This initialisation can be implemented either by using method put() on object of mapping, or by factory method Map.ofEntries(), to which you provide 4 parameters created by function call Map.entry() with pairs of values comprising keyboard key and direction of movement:

private Map<Input.Key, Direction> keyDirectionMap = Map.ofEntries(
    Map.entry(Input.Key.UP, Direction.NORTH),
    // another entries of mapping ...
);

In this instance variable you will hold reference to last created action Move, so that you will be able to cancel it in case direction of actor's movement changes.

Remember that to stop the action it is necessary to change its state returned by method isDone() to true and since we work with Movable actor, it is necessary to call its method stoppedMoving()!

In the method check if the key pressed is one of four arrow keys. If yes, schedule movement of controlled actor in corresponding direction for maximal time possible. Remember to store reference on created action.

The procedure with this method will be analogical: check if it concerns key of interest and if yes, stop currently executed movement (if there is some).

Registration of input listener is realised by method registerListener() on object Input which you obtain from scene by method getInput().

Step 5: 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.