This is from the finished 7DRL version, in fullscreen mode.
This is from the finished 7DRL version, in fullscreen mode.
The tutorial, a hand-designed level where (hopefully) helpful messages appear every time you enter a new room.
Between levels, you get to choose what house to break into left. You don't have more than eight possibilities, though, so at times you won't find any ideal targets. (Note the consonant-vowel-consonant-vowel-... pattern for the names! In my opinion, it works rather well for a "Newspeak" flavour, even if this screenshot shows a less than excellent batch.)
This is the sort of level where you've had a bit of bad luck with the generation: you start in a room with lots of robots, with no obvious means of escape. You'll run into these on occasion. While you can always turn and run, taking on the challenge of trying to figure out a way to carry out a successful operation can sometimes be tempting...
A lucky escape, with not a second to spare. The robot directly south of the player is an "observer-bot", which means that it has no weapon and that it can be quite safely ignored when an alarm has already been triggered and you're dashing madly towards an exit.
This is an early prototype; I'd come about this far after one day of development. There's still only one viewport, and no hazards at all.
This, of course, isn't my 7DRL at all, it's gvim. The file that's open, though, shows that the level file format is human-readable. (I used a normal text editor to make the tutorial level.)
Hello r.g.r.d!
I'm a long-time-lurker, first-time-poster who has made a 7DRL, or at
least a roguelike in seven days.
I started Friday the 13th and finished on Thursday the 19th. I didn't
find time to actually release until now, but I haven't touched the
code after the deadline ended. This post was typed up outside the
limit, so this is half release notes, half "missing manual". (As such,
it's a bit lengthy: just scroll down to the download links if you get
bored and want to try the game. It might be a bit unfamiliar in a
number of ways, but there's a tutorial.)
I didn't announce this beforehand because I frankly wasn't sure if I
would finish the challenge; this is my first roguelike and I'd decided
to work in an unfamiliar language with an unfamiliar IDE(as a
"learning experience"- famous last words for a roguelike project, I'm
well aware).
After having spent seven days coding, though, I find myself reluctant
to call it a "pseudo-7DRL" for this reason as I originally planned.
Following a proud tradition of roguelikes, this is a game about a
thief. Taking this concept to its logical extreme, it puts a heavy
emphasis on stealth and advanced forms of movement. In fact, it
contains no winnable combat, and the only enemies comparable to
monsters in normal roguelikes should generally be avoided at all
costs.
The setting is science fiction, mostly because the "guards" had to be
simple and predictable for the gameplay to work, and if you don't
think too hard about it, it's easy to explain that away by making them
robots.
The game was programmed in Java using Eclipse, until 164 hours into
the challenge, at which point I apparently hit the wrong key and
Eclipse changed things around a bit and deleted a few strategically
chosen source files. (Luckily, I had versioned my files - all except
one which, by Murphy's Law, I had neglected - and I was able to finish
the game with gvim and javac.)
The game should work on most any platform that runs Java and AWT, but
it has only been tested on Windows. It keeps data files in its own
directory, so it needs permission to read and write files in its own
directory(and subdirectories).
As noted, this is a somewhat specialized and strange roguelike, and
it's probably not very well balanced. Nevertheless, if any of you are
willing to try it out, I'd be honoured to get some feedback on it from
rgrd. (I have no Grand Roguelike Project in the works, but I might
very well do another 7DRL sometime in the future!)
The main game consists of seventeen burglaries in randomly generated
houses with features partly selected by the player, where the object
is to make a successful exit with as much loot as possible. If the
player does _not_ make a successful exit(with or without loot), the
game ends and the score is tallied.
There are no random elements in the gameplay itself, and the PRNG in
the meta-game may be seeded by the player, for "competitive" play.
(Comparing scores in single games might otherwise be somewhat
arbitrary, because level generation is a potentially very strong
random element.)
There's a high-score list and automatic savegames between each break-
in; both of which I suppose are fairly standard for roguelikes.
There's a tutorial, which I like to think provides a touch of class.
It also hopefully helps to offset some mechanics that might be
incomprehensible at first sight. The player can move not only by
running along the floor, but also by climbing walls(near the floor or
near the ceiling), climbing ceilings, crawling along the floor, doing
a standing jump(sadly rather useless), or doing a running jump.
There's no proper line-of-sight for the player; the hero explores
whole rooms at once. Guard robots _do_ have sensor ranges and line-of-
sight calculations(the visual calculations are marred by the artifacts
of a very strange algorithm, but this isn't too noticeable in the
standard levels because the rooms are all rectangular), and the player
can see these if the robot is visible. (I explain this apparent
omniscience by assuming that the hero, as an experienced cat burglar,
is constantly scanning the room and has an intimate knowledge of guard
robot sensor systems.)
Robots are largely tricked by either avoiding the rooms they're in
completely, or by making sure they you're not visible to them by using
all your fancy movement modes. Most of them take a short while to
notice you even after you've entered their range, but when they do
notice you, most of them will be able to neutralize you very quickly.
One model can literally kill you in one shot. They can also call more
robots to the position where they spotted you(I suppose this could
_theoretically_ be used to your advantage), or trigger alarms.
The other part of the futuristic alarm systems is the brightly
coloured, cinema-friendly detector beams. You'll have to take care to
avoid these, or you'll trigger alarms, call nearby robots, or fall
victim to gas traps.
If you trigger an alarm, a countdown will become visible. (I suppose
our hero carries a police radio.) If you let the time run out, the
police will arrive, and you'll lose. If you escape before the time
runs out, there are no consequences. Beware: the countdown times are
MUCH shorter in high-security facilities.
CONTROLS
Number pad: general movement
u, d: "up" and "down", use when climbing walls, to crouch or stand up,
or to fall (painfully) from the ceiling
x: explore the next room when standing next to a door
:: (the colon key) scroll the map, VERY useful
j: jump, move twice in the same direction first to make your jump a
running jump. You'll need to "wait" to make the time pass while in the
air.
space bar: wait (can be used while scrolling!)
l: loot, in honour of NetHack. You'll need to move over the $ and !
symbols and then press this key to earn any points in this game
Q: leave a level. Can only be used when the level has "ended"; use
your OS's "close" or "kill" function to end the program quickly.
HINTS
Use 'x', ':' and wait(space bar) to familiarize yourself with rooms
before entering them.
Use ':' (look-mode) and center the screen on a robot to display its
name. Notably, ceiling-bots hang from the ceiling, observer-bots are
unarmed, and battle-bots will instakill you if they fire. (There are
two different kinds of guard-bots; one variant reacts faster, but has
a smaller weapon.)
You can crawl through doors, but you can't use 'x' while crawling.
Hanging from the ceiling is VERY helpful to avoid most robots. Watch
out for ceiling-bots! (Note that you take up more vertical space
hanging on a wall-even near the ceiling-than hanging from the
ceiling.)
If you need to drop to the floor quickly when hanging from the
ceiling, you can do so with 'd', but you'll take 10 damage from the
fall.
If you're in a square, you can loot it - even if you're, say, jumping
through it, hanging from the ceiling, or crawling on the floor.
SCORES
If you get a score above one million, I'd say you've done impressively
well. (If you post a high score, please mention the seed you used -
even if you used a random seed, it's listed on the high-score page -
to allow for "fair competition".)
KNOWN BUGS
-There are probably some rogue println() calls around, meaning the
console will print out meaningless stuff at times. The entire game -
except for a few fatal error messages - is restricted to the graphical
window it creates. (Most embarrassingly, the game prints out a lot of
stuff related to robot movement. This isn't meant to be visible, so
using it should be considered cheating.)
-I forgot to change the version numbers before I'd packaged the final
version, and out of a perhaps misguided sense of honour I have not
changed it since. The game will identify itself as "Seven Weeks 0.9,
pre-7DRL", but the JAR file with the MD5 checksum
2ab4e17c5607625fe8ff51b0859a1c1c is indeed the version of the file I'm
releasing as a 7DRL, and as such meant to be version 1.0.
-The main menu screen prints the title as "Seven Weeks in the City".
The title was originally planned to be "Seven Weeks in ",
but since I couldn't think of a suitable fictional name for , and it felt wrong setting-wise to use a real city, I shortened
it. The name that stuck on the main menu was this rather horrible
compromise.
-There are undoubtedly problems with the game balance. Hopefully, the
fact that there's nothing to "beat" except your own scores(or other
people's scores!) offsets this problem somewhat.
-There MIGHT an "alarm" bug which triggers an alarm unprovoked, which
would be fairly critical. Most likely, any such effect seen is just
due to observer-bots and ceiling-bots, both of which trigger alarms
and have heat detectors, so they can detect you through walls. Perhaps
unfair, but not actually a bug.
-The number (above zero) of times a detector beam is broken when
moving through it is a bit arbitrary. This is largely cosmetic,
because repeating any of the three available effects should have no
effect at all.
SOURCE COMMENTS
Some of this code is unspeakably bad. What can I say - I was working
under pressure here. It works - mostly.
The game isn't packaged properly as a Java application should be(this
was probably part of the reason why Eclipse choked at me): I'm a C++
programmer at heart and a Java programmer by "academic experience"
only.
Have fun! Any feedback would be very welcome.
-Kadwiell