The Sky is the Limit.

Engine: Unity

Platform: PC

Extent: Bachelor's Thesis, 4 Months

Team Size: 2

Year of launch: 2026

Average session: ~ 25 mins

Genre: Chess, Deckbuilder, Strategy

Language: C#

Data Management

Laskards was built with a strong focus on clean and safe data management. As a deckbuilding game, it contains many cards, modifiers, decks and effects. To keep this content easy to expand and balance, the project uses a clear separation between authored data and runtime gameplay logic.

Basically all content is stored in Unity Scriptable Objects. These act as blueprints for cards, modifiers and decks and can be edited directly in the Unity Editor. To prevent errors, these assets are never modified during gameplay. Instead, their data is copied into separate runtime classes that exist only during a match. This avoids common issues such as values accidentally persisting between play sessions.

Each important asset also owns a unique ID. This makes saving and loading more efficient, since save files only store small identifier strings instead of full object data. Automatic validation systems ensure that no duplicate IDs exist and that all content remains consistent.

Cards are defined through structured definition assets. Modifiers are stored separately and referenced in the cards. During gameplay, modifiers create runtime effects that are applied to units or players and automatically update or expire over time. This creates a flexible and decoupled effect system that is easy to extend.

Overall, the architecture was designed for clarity, safety and long term growth. While it adds some complexity, it provides a strong and maintainable foundation for a content heavy deckbuilding game like Laskards.

Boss AI System 

To make Laskards work as a strong singleplayer experience, the game needed a boss that could make meaningful decisions. IThe project uses the classic minimax algorithm with alpha beta pruning. This method is widely used in strategy and chess-like games and was a natural fit for Laskards.

Minimax explores possible future game states and assumes that both sides play optimally. It searches several moves ahead and chooses the action that leads to the best guaranteed result. Because a turn in Laskards can include multiple moves, the number of possible states can grow very large. Alpha beta pruning reduces the number of states that must be evaluated, which keeps the system performant. Calculations run asynchronously so the game remains responsive.

To judge which position is better, the AI uses a state evaluation function. It considers unit value, safety, board position and active effects. This creates a clear and tunable definition of good play. Designers can adjust weights and personality settings through data assets without changing code. 

Not all behaviour is fully dynamic. The opening setup and card play patterns are data driven and authored in advance. This gives each boss a clear identity and predictable rhythm. When playing cards, the boss evaluates all valid targets by simulating outcomes and running minimax again to choose the strongest option.

Overall, the boss AI became one of the strongest systems in the project. It creates a believable opponent and adds real strategic depth. While not perfect, it provides a solid and extensible foundation for intelligent singleplayer gameplay.

Tweening System 

For Laskards, a custom tweening library was developed. It supports common easing types, which make animations feel more natural by adjusting how they speed up or slow down. This added clarity and responsiveness to many gameplay actions.

The system includes reusable components such as PositionTween, ScaleTween, RotationTween, ColorTween and FadeTween. These can be configured directly in the Unity Inspector without writing code. Tweens support duration, delay and looping. Multiple tweens can be combined in TweenGroups, which allows animations to run in sequence or in parallel. They can be triggered by code or UI-Event components.

In addition to inspector components, the library provides API for gameplay animations triggered in code. This was used for moving cards, units and other dynamic elements.

Overall, the tweening system greatly improved the visual quality of Laskards. It made animations flexible, reusable and easy to manage and became an important part of the project’s polish and usability.

Cheat Menu

To support fast testing and debugging, Laskards includes a cheat menu that is available only in development builds and inside the Unity editor. It allows instant runtime actions such as drawing cards, recycling discard piles or dealing damage. This made it possible to reproduce specific situations immediately without playing through the full game, which greatly improved iteration speed.

The system is built around a simple attribute based approach. Any method marked with a CheatCommandAttribute automatically becomes a console command. There is no central list that needs manual updates. Static methods can define global cheats, while non static methods only appear when the related object exists in the current scene. This allows scene specific debugging tools without extra setup.

The internal structure follows a clean and modular design. Command registration is handled through reflection, which scans assemblies and scene objects for attributed methods. This means new cheat commands are registered automatically without additional configuration.

The console also includes quality of life features such as command suggestions, tab completion and command history navigation.

Overall, the cheat menu became one of the most valuable development tools in Laskards. It reduced debugging time, increased iteration speed and provides a flexible system that can easily grow with the project.