Back

Activity 4.5 Turn-Based Battle with GameCharacter

Introduction

Activity 4.5

Turn-Based Battle Simulation

Topics

Objects interacting with other objects
Instance methods that modify and return state
Using loops and conditionals to control game flow
Maintaining invariants during gameplay
Designing a simple system of classes

What Are We Building?

In this activity, you will design a class that models a character in a game and write a simple turn-based battle.

Characters can attack and heal
Health must stay between 0 and maxHealth
Battle continues until one character is defeated

Key Ideas

Objects can call methods on other objects.
Instance methods enforce class invariants.
Logic in main drives the simulation.
Encapsulation ensures predictable behavior.

'F' → Fullscreen

Objectives

Write instance methods that perform actions and update state
Enforce invariants in methods (health cannot go below 0)
Use objects inside other objects and methods
Create a simple text-based game using OOP

Activity Tasks

Create a new project named 4-5-GameCharacter-Battle.
Complete each task individually.

Task 1: Implement GameCharacter

Create the GameCharacter class by following the example shown above.

1
class GameCharacter
2
{
3
    private String name;
4
    private int maxHealth;
5
    private int currentHealth;
6
    private int attackPower;
7

8
    public GameCharacter(String name, int maxHealth, int attackPower)
9
    {
10
        this.name = name;
11
        this.maxHealth = maxHealth;
12
        this.currentHealth = maxHealth;  // start full health
13
        this.attackPower = attackPower;
14
    }
15

16
    public String getName()
17
    {
18
        return name;
19
    }
20

21
    public int getCurrentHealth()
22
    {
23
        return currentHealth;
24
    }
25

26
    public int getAttackPower()
27
    {
28
        return attackPower;
29
    }
30

31
    // Reduce health but never below 0
32
    public void takeDamage(int amount)
33
    {
34
        if (amount > 0)
35
        {
36
            currentHealth -= amount;
37

38
            if (currentHealth < 0)
39
            {
40
                currentHealth = 0;
41
            }
42
        }
43
    }
44

45
    // Heal but never above maxHealth
46
    public void heal(int amount)
47
    {
48
        if (amount > 0)
49
        {
50
            currentHealth += amount;
51
            if (currentHealth > maxHealth)
52
            {
53
                currentHealth = maxHealth;
54
            }
55
        }
56
    }
57

58
    // Deal attack damage equal to attackPower
59
    public void attack(GameCharacter target)
60
    {
61
        target.takeDamage(attackPower);
62
    }
63

64
    public boolean isDefeated()
65
    {
66
        return currentHealth == 0;
67
    }
68
}

Task 2: Build the Battle Loop

Write the main game loop where the player chooses actions and the enemy responds automatically.

1
import java.util.Scanner;
2

3
public class Main
4
{
5
    public static void main(String[] args)
6
    {
7
        Scanner input = new Scanner(System.in);
8

9
        GameCharacter player = new GameCharacter("Hero", 100, 15);
10
        GameCharacter enemy = new GameCharacter("Goblin", 75, 10);
11

12
        System.out.println("-- Turn-Based Battle --");
13

14
        while (!player.isDefeated() && !enemy.isDefeated())
15
        {
16
            System.out.println("\n" + player.getName() + " HP: " + player.getCurrentHealth());
17
            System.out.println(enemy.getName() + " HP: " + enemy.getCurrentHealth());
18

19
            System.out.println("\nChoose an action:");
20
            System.out.println("1) Attack");
21
            System.out.println("2) Heal");
22
            System.out.print("> ");
23
            String choice = input.nextLine();
24

25
            if (choice.equals("1"))
26
            {
27
                player.attack(enemy);
28
                System.out.println("\nYou dealt " + player.getAttackPower() + " damage!");
29
            }
30
            else if (choice.equals("2")) {
31
                player.heal(10);
32
                System.out.println("\nYou healed 10 HP.");
33
            }
34
            else
35
            {
36
                System.out.println("Invalid choice. You lose your turn!");
37
            }
38

39
            if (enemy.isDefeated())
40
            {
41
                break;
42
            }
43

44
            enemy.attack(player);
45
            System.out.println("The " + enemy.getName() + " attacks for " + enemy.getAttackPower() + " damage!");
46
        }
47

48
        if (player.isDefeated())
49
        {
50
            System.out.println("\nYou were defeated...");
51
        }
52
        else
53
        {
54
            System.out.println("\nYou defeated the enemy!");
55
        }
56
    }
57
}

Sample Output

-- Turn-Based Battle --
Hero HP: 100
Goblin HP: 75

Choose an action:
1) Attack
2) Heal
> 1

You dealt 15 damage!
The Goblin attacks for 10 damage!

Hero HP: 90
Goblin HP: 60
...

You defeated the enemy!

Reflection Questions

Why should health never go below 0 or above maxHealth?
How does encapsulation protect the internal state of a character?
Why is a loop used to control the flow of the battle?
What advantages do instance methods provide over writing logic in main?
How could you expand this system in the future (e.g., items, spells, multiple enemies)?

Submission

Submit your project and reflection answers to the appropriate dropbox.