Implementation of Memento Pattern

In a video game, players advance through different stages while gathering objects and achieving goals. Players must be able to save their progress in the game and return to it whenever they'd like.

Let's look at the pseudocode for this example:

Class Game {
    Private level: Integer
    Private score: Integer
    Private inventory: List of Items
    Private gameSaveManager: GameSaveManager

    Constructor() {
        gameSaveManager = new GameSaveManager()
    }

    Method play(levelIncrement: Integer, scoreIncrement: Integer, newItems: List of Items) {
        level += levelIncrement
        score += scoreIncrement
        inventory.addAll(newItems)
        gameSaveManager.addSave(createSave())
    }

    Method createSave(): GameSave {
        return new GameSave(level, score, inventory)
    }

    Method loadSave(gameSave: GameSave) {
        this.level = gameSave.getLevel()
        this.score = gameSave.getScore()
        this.inventory = gameSave.getInventory()
    }

    Method undoLastPlay() {
        loadSave(gameSaveManager.getLastSave())
    }
}

Class GameSave {
    Private level: Integer
    Private score: Integer
    Private inventory: List of Items

    Constructor(level: Integer, score: Integer, inventory: List of Items) {
        this.level = level
        this.score = score
        this.inventory = inventory
    }

    Method getLevel(): Integer {
        return level
    }

    Method getScore(): Integer {
        return score
    }

    Method getInventory(): List of Items {
        return inventory
    }
}

Class GameSaveManager {
    Private saves: Stack of GameSave

    Method addSave(gameSave: GameSave) {
        saves.push(gameSave)
    }

    Method getLastSave(): GameSave {
        return saves.pop()
    }
}

// Client Code
Main {
    game = new Game()
    game.play(1, 100, [Item1, Item2]) // Play level 1
    game.play(2, 200, [Item3]) // Play level 2
    game.undoLastPlay() // Reverts to the state after playing level 1
}

• Originator: The primary class that represents the current state of the game. After every play session, it saves its state (level, score, and inventory) and can be restored with a GameSave.
• GameSave (Memento): Saves a copy of the current state of the game. It contains the inventory, score, and level in this case.
• GameSaveManager (Caretaker): manages the management of saved games. When a rollback is required, it restores previously saved GameSave objects to the game.

After every play, the Game class's play method creates a new save and modifies the current state. The game can be returned to its last saved state using the undoLastPlay method. This method allows players to save their progress and return to previous states without exposing the game's complex state management.

Implementation