Lesson 6 - Arena with warriors in Java

Java OOP Arena with warriors in Java

In the previous lesson, Warrior for the arena in Java, we created the Warrior class. In today's tutorial, we're going to put it all together and create a fully functioning arena. The tutorial is going to be simple and will help you get some more practice working with objects.

We'll need to write some code that will manage our warriors and the messages being printed to the user. To keep things organized, we'll create an Arena object where our fight will take place. ArenaFight.java (the file with the main() method) will only provide the necessary objects, and the Arena object will take care of the rest. Let's add the last class to the project - Arena.java.

The class will be rather simple, it'll include three needed instances as the fields: the 2 warriors and the rolling die. These fields will be initialized from the constructor parameters. The class code will be as following (add comments accordingly):

public class Arena {
        private Warrior warrior1;
        private Warrior warrior2;
        private RollingDie die;

        public Arena(Warrior warrior1, Warrior warrior2, RollingDie die) {
                this.warrior1 = warrior1;
                this.warrior2 = warrior2;
                this.die = die;


We'll make the program output nice and allow the Arena class to access the console directly. We've decided that the printing would be done by the Arena class since it makes sense to do it here. If the printing was performed by warriors, the design would be flawed since the warriors would not be universal. We need a method that prints information about the round and the warriors' health to the console. The damage and defense messages will be printed with a dramatic pause so as to make the battle more intense. For this, we'd have to create a helper method. Let's start with the method that renders the information to the screen:

private void render() {
        System.out.println("-------------- Arena -------------- \n");
        System.out.println("Warriors health: \n");
        System.out.println(warrior1 + " " + warrior1.healthBar());
        System.out.println(warrior2 + " " + warrior2.healthBar());

The method is private, it'll be used only within the class.

Let's create another private method that will print messages with a dramatic pause:

private void printMessage(String message) {
        try {
        } catch (InterruptedException ex) {
                System.err.println("Unable to put the thread to sleep");

The Thread class allows us to work with threads, which we will need access to in order to add the dramatic pause. We'll use the sleep() method which puts the thread of the program to sleep for a given number of milliseconds. We'll go over threads in detail in the last couple of courses. We won't bother with try-catch blocks now, they aren't important for us now and we'll get back to them later. Let's just say they have to be there for now.

Let's move on to the battle part. The fight() method will be parameterless and won't return anything. There will be a loop inside calling the warriors' attacks in turns and printing the information screen with the messages. The method would look something like this:

public void fight() {
        System.out.println("Welcome to the Arena!");
        System.out.println("Today " + warrior1 + " will battle against " + warrior2 + "!\n");
        System.out.println("Let the battle begin...");
        // fight loop
        while (warrior1.alive() && warrior2.alive()) {
                printMessage(warrior1.getLastMessage()); // attack message
                printMessage(warrior2.getLastMessage()); // defense message
                printMessage(warrior2.getLastMessage()); // attack message
                printMessage(warrior1.getLastMessage()); // defense message

The code prints an introductory line and executes the fighting loop after the user presses any key. Then, the program enters a while loop that repeats as long as both warriors are alive. The first warrior attacks its opponent and his attack internally calls the other warrior's defense. After the attack, we render the information screen. The messages about the attack and defense will be printed by our printMessage() method which makes a dramatic pause after the printing. The same thing will happen with the other warrior.

Let's move back to ArenaFight.java. We create'll the needed instances and call the fight() method on the arena:

// creating objects
RollingDie die = new RollingDie(10);
Warrior zalgoren = new Warrior("Zalgoren", 100, 20, 10, die);
Warrior shadow = new Warrior("Shadow", 60, 18, 15, die);
Arena arena = new Arena(zalgoren, shadow, die);
// fight

You can change the values to whatever you'd like. Here's what the program looks like at runtime:

Console application
-------------- Arena --------------

Warriors health:

Zalgoren [##                  ]
Shadow [                    ]
Shadow attacks with a hit worth 19 hp
Zalgoren blocked the hit

The result is quite impressive. Objects communicate with each other, the health bar decreases as expected, the experience is enhanced by a dramatic pause. However, our arena still has two issues:

  • In the fight loop, the first warrior attacks the other one. Then, the second warrior attacks the first one, even if he has already been killed by the first warrior. Look at the screenshot above, at the end, Shadow attacked even though he was dead. The while loop terminated just after that. There are no issues with the first warrior, but we have to check whether the second warrior is alive before letting him attack.
  • The second problem is that the warriors always fight in the same order so "Zalgoren" has an unfair advantage. Let's leave the turn order up to chance by using the rolling die. Since there will always only be two warriors, we could tell the program to set the warriors' turns based off of whether the rolled number is less or equal to half of the number of die sides. Meaning that if it rolls a number less than 5 on a ten-sided die, the second warrior goes first, otherwise, the first one does.

We still have to add a way to swap the warriors places depending on which one goes next. Since we know about references in Java, let's just create 2 variables that will contain warrior instances. We'll assign warrior1 and warrior2 to these variables. If the die condition mentioned above applies, we'll assign warrior2 to w1 and vice versa, then the second warrior will begin. This way, we won't have to change the loop code and it all remains nice and clear.

Updated version preventing the second warrior from attacking if he's dead and letting the warriors turns be chosen at random:

public void fight() {
        // The original order
        Warrior w1 = warrior1;
        Warrior w2 = warrior2;
        System.out.println("Welcome to the Arena!");
        System.out.println("Today " + warrior1 + " will battle against " + warrior2 + "!\n");
        // swapping the warriors
        boolean warrior2Starts = (die.roll() <= die.getSidesCount() / 2);
        if (warrior2Starts) {
                w1 = warrior2;
                w2 = warrior1;
        System.out.println(w1 + " goes first! \nLet the battle begin...");
        // fight loop
        while (w1.alive() && w2.alive()) {
                printMessage(w1.getLastMessage()); // attack message
                printMessage(w2.getLastMessage()); // defense message
                if (w2.alive()) {
                        printMessage(w2.getLastMessage()); // attack message
                        printMessage(w1.getLastMessage()); // defense message

Now, let's take her for a spin!

Console application
-------------- Arena --------------

Warriors health:

Zalgoren [###########         ]
Shadow [                    ]
Zalgoren attacks with a hit worth 27 hp
Shadow defended against the attack but still lost 9 hp, and died

Congratulations! If you've gotten this far and have actually read through, you have the basis of object-oriented programming and should be able to create reasonable applications :)

In the next lesson, Inheritance and polymorphism in Java, we'll explain object-oriented programming in further detail. We mentioned that OOP is based on three concepts - encapsulation, inheritance, and polymorphism. We're already familiar with the encapsulation, the other two await you in the next lesson...



Article has been written for you by David Capka
Do you like this article?
1 votes
The author is a programmer, who likes web technologies and being the lead/chief article writer at ICT.social. He shares his knowledge with the community and is always looking to improve. He believes that anyone can do what they set their mind to.
Unicorn College The author learned IT at the Unicorn College - a prestigious college providing education on IT and economics.
Activities (5)




To maintain the quality of discussion, we only allow registered members to comment. Sign in. If you're new, Sign up, it's free.

No one has commented yet - be the first!