Jokemon

Repository

I developed Jokemon to experiment with building a game engine from scratch using only the Java standard library and console-based rendering. This project features a tile-based world system, persistent game saves via serialization, and a modular architecture for managing entities like buildings and Jokemons. It served as a deep dive into object-oriented design patterns and the use of modern Java features to simplify complex game logic.

Persistent Game State Serialization

To allow players to save and resume their progress, I implemented a comprehensive GameState serialization system. By implementing the Serializable interface, I could capture the entire world state—including player position, inventory, level, and the individual stats of all Jokemons—into a single binary file. This system ensures that complex object graphs are preserved accurately across different sessions, providing a seamless "Save/Load" experience in a traditionally stateless console environment.

1public class GameState implements Serializable {
2    private int seed;
3    private int playerLevel;
4    private int playerCoins;
5    private int[] playerPosition; // [x, y] coordinates
6    private int playerDirection;
7
8    private List<JokemonData> playerJokemons;
9    private List<JokemonData> discoveredJokemons;
10    private List<WildJokemonData> activeWildJokemons;
11
12    public GameState(int seed, int playerLevel, int playerCoins, int[] playerPosition,
13      int playerDirection, List<JokemonData> jokemons, List<WildJokemonData> wildJokemons) {
14        this.seed = seed;
15        this.playerLevel = playerLevel;
16        this.playerCoins = playerCoins;
17        this.playerPosition = playerPosition;
18        this.playerDirection = playerDirection;
19        this.playerJokemons = jokemons;
20        this.activeWildJokemons = wildJokemons;
21    }
22}

Abstract Building Architecture

The world is populated with various interactable structures, all derived from a central Building abstract class. This architecture uses polymorphism to manage different building types—such as Medical facilities, Shops, and Houses—while sharing common properties like grid coordinates and ASCII-based design templates. This modular approach makes it trivial to expand the world with new building types by simply extending the base class and overriding the interaction logic.

1public abstract class Building {
2    public enum BuildingType { MEDICAL, SHOP, HOUSE, OUTSIDE }
3
4    protected int centerX, centerY;
5    protected BuildingType buildingType;
6    protected boolean canEnter;
7    protected char[][] design; // ASCII art representation
8
9    public Building(int centerX, int centerY, BuildingType type, boolean canEnter, char[][] design) {
10        this.centerX = centerX;
11        this.centerY = centerY;
12        this.buildingType = type;
13        this.canEnter = canEnter;
14        this.design = design;
15    }
16
17    public char[][] getBuildingDesign() { return design; }
18}

Modern Java: Pattern Matching for switch

To handle the diverse interactions between players and world objects, I utilized Java 21's pattern matching for switch. This feature significantly reduces boilerplate by allowing for direct type-checking and extraction within the switch statement. This makes the code for generating building descriptions or handling collision events more readable and less error-prone compared to traditional instanceof chains.

1public String getBuildingDescription(Building building) {
2    // Java 21 feature: Pattern matching for switch
3    return switch (building) {
4        case MedicalBuilding m -> "A medical facility located at [" + m.centerX + ", " + m.centerY + "]";
5        case ShopBuilding s -> "A bustling shop with rare items in stock.";
6        case HouseBuilding h -> "A quiet residence; the door is locked.";
7        case default -> "An unidentified structure in the distance.";
8    };
9}

Console Engine and ANSI Rendering

The rendering engine uses ANSI escape codes to provide a 2D-like experience in a text-based terminal. By manipulating the cursor position and using specific color codes, I was able to draw a scrollable map and animated character sprites. The game loop operates on a tick-based system, processing user input from the keyboard and updating the world state before re-rendering the relevant sections of the console, ensuring a flicker-free gameplay experience.