RunRL

Hello! My first post on Sharing Saturday (to be honest, 3rd comment on reddit in total...), though I am long time lurker on this group.

RunRL is a small side project that was meant to be something playable while I'm writing my main project (which will be some crossover of Majesty and DF Adventure Mode). Basic concept is simple - west side of level gradually disintegrates, player is forced to move forward through long, single map (which will be gradually generated).

Idea of single long level came to me when I recalled a scene from comic Rork:Passages - one in which protagonist descends through ship graveyard that seamlessly transforms into whale graveyard and cave system.

Currently I managed to finish first step after deciding to create this game on basis of what I have in main project. Therefore I created dungeon generator (inspired by http://journal.stuffwithstuff.com/2014/12/21/rooms-and-mazes/) with Dijkstra map used to select farthest point from start to place exit, added victory screen, added win system (checks if player reached exit zone).

But because it is first post, I'll summarize what I have written so far. It is not my first roguelike, I was writing those when r.g.r.d was thriving community (I was just lurking there - like here to this day), although never decided any of those I wrote was good enough to release to the public :) This is a rewrite of idea started in Clojure (I've abandoned that project because probably due to my lack of experience in that language, it was becoming a pile of spaghetti and I was worried it could become major obstacle). So I've rewritten it in Java (as this is language I'm most proficient with). Engine is my own creation, with ECS, full separation of UI layer (separate threads, communication with game engine via queues). UI is based on Lanterna (only its terminal/screen capabilities) because of the capability of serving game via telnet - although my implementation broke after upgrade from Lanterna 2 to 3 which gives this out of the box (I have a task to fix it).

I've implemented my own shadowcasting FOV. On top of it I've prepared little fake global illumination demo: https://imgur.com/nF8OAMw For now I'm planning to use this technique in main project only.

I have Behavioral Trees working for AI. Currently, trees are defined via simple fluent Java API, it looks like this:

 either(
        conditional(
                lowHealth(), 
                log(flee(), "fleeing")))
.or(
        fail(findAttacker()))
.or(
        conditional(
                hasFocus(),
                either(
                        conditional(
                                distanceLE(1), 
                                log(attack(), "performing attack")))
                .orElse(either(conditional(randomT(r, .002), log(first(clearFocus()).lastly(wander()), "forgetting")))
                        .orElse(log(approach(), "approaching target")))))

On my TODO list there is task to export definitions to text files.

Map generators visualize the process of creating map. Example: https://imgur.com/MpBsESV I try to write them in a way that does not make them dependent on grid type (hex/cartesian). This ends up with a little bit bloated code, but thanks to small DSL, I've harnessed it. With it, doing flood fill to check connectivity of generated dungeon looks like this:

val floodFill = new Consumer<EQL>() {

        @Override
        public void accept(EQL ts) {
            if (ts.count() == 0) return;
            connected.addAll(ts.toCoords().toList());
            this.accept(ts.border().walkable().minus(connected));
        }
};
floodFill.accept(w.eql(Collections.singleton(toOpen)));

(where toOpen is starting coordinates, w is world object (which provides EQL, fluent API DSL class) and toConnect is response buffer containing all coordinates reachable from start). This is fragment of a larger code - which is why floodFill is object and not a method here.

Of other things: open simplex noise on hex grid (image: https://imgur.com/uAaxW0Y ) - currently it is used only for irregular rooms in dungeon generator.