Have you ever felt pained by the lack of GADTs and high-arity functors when playing games?
Have you ever wondered if you could play games without being weighted by a runtime evaluation?
Then fear no longer, because in this day it is my pleasure to announce the first release of Roguetype, the first ever roguelike written in the OCaml type system:
Test your mettle against the OCaml typechecker and the 8 levels of roguetype.
Explore functors, mountains, and forests to discover hidden paths.
Vanquish goblins and dragon(s), upgrade your equipment, while being sure that your travel is well-typed by construction.
And maybe, at the end of your adventure, you shall prove that the victory type is inhabited
Note that the first released published version contained a handful bugs (clearly OCaml types should be more strongly typed), they have been fixed in the last commit — or at the very least there is now an empirical proof that the game has one solution.
I’m not sure if it is embarrassing to admit this or not, but I can’t figure out for the life of me how to “play” this game. I typed roguetype in the terminal and got a toplevel. What do I do next?
The game objective is to call the win function hidden inside the Lvl8 functor.
The aim at each level is to construct a path that reaches the type <level_cleared:yes; ..> path
by chaining Rules.move .
For instance, the example/start.ml file gives a solution to the first level (simplified after an UI improvement by @juloo):
open! Generic
open! Rules;;
module Lvl1 = struct
include Game.Lvl1
let trace =
start => D => D => D => R => R => D => R => R => U => U => U => U => U => U
=> U => U => Gate
type p = Game.player_start
end;;
Once this path constructed for the first level, you can apply the Lvl2 functor to obtain the Lvl2 version of the path type constructor
module Lvl2 = struct
include Game.Lvl2 (Lvl1)
let trace = start => ...
type p = ...
end
Then it is a matter of building paths for each level until the last level.
The state of the world gets displayed when you play at least one move. It’s not very easy to read, which is par for the course for TRPGs For example, here’s the state of [] => R:
$ roguetype # or "rlwrap roguetype"
# open Roguetype_lib;;
# open Game.Lvl1;;
# open Rules;;
# open Inventory;;
# open Cases;;
# let (=>) l x = x :: l;;
# [] => R;;
- : < init : player_turn; lvl : t; player : Game.player_start;
world : < dw : < l : f -> f -> forest -> forest -> f -> m -> m;
m : forest; r : f -> forest -> f -> m -> m > ->
< l : f -> forest -> f -> f -> f -> m -> m; m :
forest; r : f -> forest -> f -> m -> m > ->
< l : f -> forest -> f -> forest -> forest -> m -> m;
m : f; r : f -> forest -> f -> m -> m > ->
< l : f -> f -> f -> forest -> Case.elixir -> m -> m;
m : forest; r : f -> f -> f -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m >;
m : < l : none floor -> f -> f -> forest -> f -> m -> m;
m : f; r : f -> forest -> f -> m -> m >;
up : < l : f -> forest -> forest -> forest -> f -> m -> m;
m : forest; r : f -> forest -> f -> m -> m > ->
< l : f -> forest -> f -> f -> f -> m -> m; m :
forest; r : forest -> forest -> f -> m -> m > ->
< l : f -> forest -> f -> forest -> forest -> m -> m;
m : forest; r : forest -> forest -> f -> m -> m > ->
< l : f -> forest -> f -> f -> Case.axe -> m -> m;
m : f; r : f -> forest -> gate -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m > ->
< l : m ->
m -> m -> m -> m -> m -> m -> m -> m -> m -> m;
m : m; r : m -> m -> m -> m -> m -> m -> m -> m -> m > > >
path
= (::) (R, [])
Your current position is the field world.m.m, which contains an empty floor:
< ...
world : < dw : ... ;
m : < ... m : f (* you are here *) ; ... >
up : ... >
... >
The cells to the left and right can be found in the first argument of the functions types in the l and r fields:
< ...
world : < dw : ... ;
m : < l : none floor (* to your left *) -> ... ; m : f ; r : f (* to your right *) -> ... >;
up : ... >
... >
Similarly, the dw and up contain the rows below and above you, with the closest ones as the first argument of function types. The cells below and above you are the m fields of those rows.
< ...
world : < dw : < ... ; m : forest (* below you *) ; ... > ->
... ;
m : < l : none floor -> ... ; m : f ; r : f -> ... >;
up : < ... ; m : forest (* above you *) ; ... > ->
... >
... >
You can also find the maps in a more readable format in lib/game.ml, that makes it easier to plan your moves.
For example, here’s the state of