Enjoy:
https://sgibber2018.itch.io/dungeon-under-grindstone

Deckbuilding

Your character is your deck of cards.  You start the game by drawing a hand of four cards.  When you encounter an enemy, you can play as many cards out of your hand as you want (attack, defend, and other types of cards) and then discard the rest.  Then it is the enemy's turn to play a card.  Then you draw another hand of four cards, and the battle continues.

When the enemy manages to hit you, you take a Wound card.  And every time you reshuffle your deck to get a new draw pile, you shuffle in an Exhaustion card.  If you ever draw a full hand of "deadly" cards like Wounds and Exhaustions, then your hero has fallen and it's game over.

Over time, you can build up your deck to be more powerful by buying new cards from the trainer, the blacksmith, etc., which allows you to delve further and further into the dark forest before having to return to town to get healed (to remove Wound cards) or rest at the inn (to remove Exhaustion) cards.

Screen Reader Support

The game is written in HTML5, and I set myself the challenge of making it screen reader friendly.  It turns out that there's not a lot of information out there on the internet about making web games work well with screen readers; the closest thing I could find was how to make web applications work, but most of that was in the context of making, essentially, web forms navigable.

So I ended up having to do a lot of experimentation and testing, but I eventually got a "Hello World" app working with VoiceOver, and I was able to apply that to Battle Weary as I developed it.

But the technology for making an interactive game wasn't the main hurdle; it was trying to adjust the gameplay of a traditional roguelike to make it understandable and enjoyable when used with a screen reader.  For instance, having to listen to something like "There is a snake four tiles west and two tiles north, there is a door six tiles east and seven tiles south, etc." every time you take a step to understand the environment would get tedious quickly.  So I changed the game's movement to be room-by-room instead of tile-by-tile, a'la Telengard.  That preserved the basic gameplay of roguelikes while making it easier to describe the player's situation in text.

Overall, I feel the game turned out pretty well considering the challenges I had.  I haven't gotten any feedback from anyone who regularly uses screen readers yet, but I'm hoping that the manner in which I exposed the gameplay works well in practice.  If you have access to a screen reader (particularly one other than VoiceOver) and are willing to test the game with it, I'd love to hear how it goes.

Premise

Double Blind is designed around the idea of "local versus with imperfect information." If you can imagine the playing Go Fish Battleship on a single screen everyone sees, you can understand the challenge. In Double Blind, player input is the hidden information. This can more easily be achieved via networking, but I believe keeping it local will enforce a novel feeling for the players.

In Double Blind, you play as a notorious Rogue adept at navigating the dark. When in the dark, characters are completely hidden on the screen. Players have to remember where they are based on what actions / movements they take. The Rogue has several tools at their disposal when in the dark like throwing knives and laying decoys. The goal is to find your enemies in the dark, before they find you.

Rooms

A room is where this cat and mouse game takes place. Rooms are somewhat procedurally generated. They will be of some predefined blueprint with random obstacles thrown about depending on the room type. When entering a room, you will be able to see everything for a few seconds to get your orientation.

Controls

This is where a lot of the challenge lies – I have to keep input hidden. The Rogue is controlled with four arrows: Up, Down, Left, and Right. And two buttons: O, X. The Rogue also has a currently selected move, which defaults to "Move". When using a directional key you will spend a Move Point (MP), and use it in that direction. Some move don't require a direction, so any direction will work. 

In order to change your selected move, you open the move select menu with O. From there you will be presented with a menu that requires two arrow key inputs.

In-game controls:

• Up, Down, Left, Right – use current move in direction
• O – open move select (see below)
• X – undecided, thinking information menu or allowing more complex directional input

In move select menu controls:

• Up, Down, Left, Right – input sequence to select a move
• X – exit menu without selecting

Moves

Moves have feedback in the form of success/failure indications. Rogues also have 2 or more MP per turn and will see their MP drop. Some actions create noise, this noise will be displayed as a noise animation in an area with a random center on the point of origin. Loud noises will have a smaller area, quieter noises will have a larger area.

Noise levels:

• Loud – radius 0
• Normal – radius 1
• Quiet – radius 2
• Shushed – radius 3

Noises are shown graphically, in addition to an actual sound, to indicate where they are. They are fuzzy, but can give some information. A noise will have a point of origin, the noise area will be placed randomly so that part of the area is over the origin. An example with a loud noise:

X = origin, * = noise
.*.
*X*
.*.
or
.*.
X**
.*.
or
.X.
***
.*.
etc.

And here's an example using all of the above. The Rogue moves normally one space at a time, both times a success (green indicator), selects "Dash" and runs into a pillar on the right creating noise as a red animation and a red failure indicator. Some of the colors and indicators will be polished.

On the to-do list:

• More Moves, like sensing, throwing knives, flash bombs, decoys, etc
• More objects, like chairs to push and stumble over, tables to hide under
• Sound, music
• NPC enemies, like dogs, guards, dummies
• Multi-room connections for single player mode
• Others

Good luck everyone!

The tech stack is my own engine built on top of Monogame and the Nez library, which I've slowly been replacing with my own code over time. I'm still not sure how I'm going to handle the graphics. There's a tileset I've been using for prototyping for a while and I may stick with that or switch to something else.  But I want to stay with a lo-fi esthetic so I can add custom sprites myself if I need to.

No screenshots yet, but here's a short story I wrote to help me establish the mood of the game and work out a bit of the initial gameplay...

You start the game on a random spot on the outer edge of an island. Most of it is hidden from sight, with only a small patch visible around you. But you don't know how you got here. The only thing you can recall is searing pain and then blackness. You look down at yourself and immediately find that your left hand and lower arm are encased in some sort of gauntlet covered with numerous gears and pistons.

You can move your fingers and turn your wrist, but no matter what you try to do it won't come off. Looking closer, you see two distinct recesses in the back of the "hand". They look like empty sockets, waiting for something to be attached.

You don't feel any pain now, but you do feel something. A strange kind of energy who's source seems to be the thing enveloping your hand. Acting on instinct, you pick up a rock with that same hand and close your fist. The rock explodes into dust. Amazed, you try again with the same result. Somehow, this… thing has incredible power that you can now tap into.

As you explore the island, more of it is revealed until you find the massive volcano at its heart. But the inside of the volcano is another mystery for another time.

You continue to explore, finding many clearings scattered across the island. In some, you find creatures skittering around what look to be groups of crystals growing out of the ground. As you approach one of the crystals to take a closer look, the creatures close in on you aggressively and you back off, thinking better of it. Even with your new found strength you don't think you could take all of them at once.

During one of your many excursions, you come across a strange machine. It appears inactive and you can't find any way to turn it on. There's a large opening on one side with a fine layering of dust over it. As you move around the machine, the dust sparkles in the light. Looking closer, you can see that the dust is made up of finely ground crystals.

The machine reminds you of something, and looking down you see the connection between it and the thing covering your arm. They look like they were made by the same person, or have at their base the same underlying technology. You've never seen anything like either one.

Exploring some more, you finally come across some unguarded crystals and gather them up. Each clump is a specific color. There's red, blue, a pale yellow, and a sort of amber color. An idea forms in your mind.

You make your way back to the machine and take out one group of crystals, the red ones. You drop them in to the opening and suddenly the thing springs to life. Internal gears start turning, plumes of vapor rise from pipes scattered across it. Heat begins to emanate from its surface and you take a couple steps back.

Finally it stops and something drops out of an opening that you hadn't noticed before. It sparkles on the ground and you go to pick it up. You have to wait until it cools, but holding it close to your face you can see that it's a large gem of the same color as the crystals you had dropped in moments before.

You do the same with the other crystals you've collected and after a bit of time you find yourself holding four perfect gems, all exactly the same size and all flawless.

You wonder what this all means when you glance at the gauntlet on your hand, as you've found yourself doing more and more over time. Your eyes come to rest on the two sockets. Again, acting on instinct, you place one of your newly acquired gems, the red one, in one of them.

Gears spin and lock the gem into place. You feel a wave of heat flow through you as steam issues from the gauntlet and the gem begins to glow with an inner light.

There's a rustling sound behind and you turn to look just as something lunges at your head. Your arm comes up and strikes out, a solid blow. You've tried fighting one of these before and barely escaped, but this time the thing falls back away from you, a smoldering hole where your fist connected with its body. It lunges again, and again you strike. This time you're not caught off guard and watch as the gem glows brighter and the gauntlet turns white with heat. The thing that attacked you lies at your feet, dead.

Your hand should be on fire right now, but there's no pain. And the gauntlet reverts back to its normal color, smoking a bit as it cools down. You look closer at it, examining it for the 100th time. It looks like a bunch of gears and pipes and metal plating, but there's got to be more to it than that. This is no ordinary machine.

You look back at the creature on the ground. It's not moving. You lean closer and notice a glint among the still smoldering flesh. Where you expected to see bone, you see metal. More gears and pipes. Just like your hand. Just like the forge. What is this place? Why are you here? And there's still one more empty socket on the gauntlet. What if…

Setup the itch.io project page today, will actually start the dev-work and challenge tomorrow.  I'm taking the 'kill the rats in the basement' trope and running with it.  Play as a rat catcher hired to clear out the castles of the kingdom.  But don't forget your place in society, guards will kick you aside if you get too close, royalty will call guards to have you removed. 
All the while you been paid to do a job. Kill the rats. Destroy the nest. Move on.

I'm starting with a hobby game engine I've been tinkering on for almost 2 years.  My dev time is usually constrained to a 40 minute train commute so dedicating a larger portion of my free time to this should actually turn this PoC engine into an actual game. Hopefully =D

Inspired by a throwaway line in one of my favorite sci-fi books. I was going to go with a wholly different game plan, but then I reread that book, read a neat line commenting on an alien species that doesn't consider gold a valuable substance at all, and thought "That would be a cool roguelike to make someday. Steal gold from an alien species who think it's nothing special and have massive stockpiles of it. Hey, actually it's like one week before the 7DRL..."

I wanted to do a more "classic-rogue" style game this time around, i.e. one where score was a focus, rather than achieving objectives. So the premise of the game is that you're trying to pay off your debts by earning (or rather, "earning") space-buxx, and that gives me a nice simple score mechanism to work with-- your score is just how much cash value of stuff you've collected, and just collecting the items isn't good enough, you have to stow them in the cargo hold for maximum value. It's a little too easy to "win" at this point, and needs some numerical tweaking that I didn't really have time for because I was fixing bugs right down to the wire.

The intention was always that you could keep playing after "winning" the game, in order to amass more and more cash, and strive for the high score. To that purpose, I implemented a little microservice for recording high scores, and was planning to put together a webpage to display the high scores. But I discovered that for technical reasons around publishing on itch.io, the version running on itch.io can't send your scores to my service (your browser forbids it for security reasons). So instead, to make sure I have something playable and winnable for the 7DRL, I currently have the game end in "victory" when you have enough money to pay off your debts and have escaped to the safety of deep space. If I can figure out in the near future how to get the score submission working from inside itch.io, I'll be sneaking that in as an update.

There are a few oddities in the map system I can't quite track down yet, but aside from that I'm pretty happy with the result. There's definitely some enhancements I want to make to the game going forward (more level generator types, number balancing, more ships for you to play with, &c), but I'll be leaving the 7drl version as-is aside from bug fixes-- and I'll probably run the updated versions off my own website instead of here on itch.io, anyway, so that they can talk to the highscore service.

The premise is that you cast spells by moving in specific patterns, thereby making positioning extremely important. Other than that, there's a bunch of spells and each enemy is fairly unique. As apparent from the gif, there's also some freaky stuff going on with the tiles.

You can grab it here.

Hope you enjoy.

You are Moop; Moop is Bear; Moop have "junk ship".

Moop's junkship can detach junk from space wrecks and up to 8 objects will orbit his ship, rotating anticlockwise one cell per turn. Junk can be fired at enemies or it can block shots from enemies. One time powerups and items that give permanent boosts are treated just like the rest of the junk Moop has collected.

Each level has dead spaceships, strange micro nebulae, enemies and surprises.

The game will be written in C# and will use the SDL library. The sprites will be the familiar lovable shitty 16x16 sprites that are one of the hallmarks of The Broom Institute.

Will fill this with more info probably.

I'll use rot.js.

This year, I'm working on the roguelike about robbing Old West trains. I don't know if I'll manage to add all features I'd like (dynamic backgroud rendering, for example), but as the minimal product I want to create features interesting ranged combat mechanics, good procedural level generation (based on prefabs and templates), and win condition.

 Game will be build with use of Go 11.5, BearLibTerminal 0.15.7, and GCC 8.1.0.

I'm using roguelike template I'm working on since August. It means that I have lots of systems already done - collisions, rendering, sarializing, etc. You can find RAWIG here. It was meant to be clean, easy to expand and modify game template... But it isn't very clean already :F Anyway, it's great help for me.  

Yesterday, ie day before start, I set repository up, and made some small changes to RAWIG codebase. 

Even with advantage of existing architecture, I didn't manage to tinker with content during first day of competition. But there was good reason for that: I spent whole day working on ranged combat. Since game theme is Old West, I wanted to use classic revolvers that need to be cocked before shoot, and that take some time to reload. The player-side of mechanics was rather straightforward, but adding all these cocking, uncocking, reloading, etc. mechanics to AI, and making sure that AI behaviour will remain sensible, wasn't that easy. But - it works now, so I could be proud of me. But, you know, I won't. I'm still, if working under time pressure, terrible coder, and my AI function is monstrosity. I'm gonna go to hell because of code duplication in func HandleAI().  

After first day, my game still uses generic samples as game levels and enemies names. It still looks kind of cool:  

Update 20190303T0155+0100: 

I'm planning to release windows and linux builds. Anyone keen to build RRT for Mac is welcome! :)

My entry is available at https://benob.itch.io/expelledrl. You play as a hero who just arrived in front of the amulet of Yendor after battling and levelling for the length of the dungeon. This is when everything derails... 

I couldn't figure out how to make working standalone executables out of python+tcod, so you have to deal with the source code download. This post is full of spoilers, so start by playing the game.

I had to battle a lot of bugs at the end, and some I was not able to squish. The game includes a story, a tutorial, a whopping 13 different endings. The main innovation is the possession spell, at the heart of the game-play.

You cast the possess spell  by pressing 'p' while there is exactly one enemy in your field of vision. You take control of it and let go the control of your previous host. The host either dies, suffers or starts following and helping you. There is a cooldown period which depends on the value of the host so that you can't jump from body to body. The possess spell is implemented by being able to the AI controller of a creature by a controller based on player input.

In addition to the restriction on enemies on screen and cooldown, the other mechanic that pushes you towards swapping hosts is that there is no healing.

Once you possess a creature, you gain access to all its buffs and spells (press the 'a' key). Some can launch fireballs while others can summon rodents. Terrain buffs help you cross rivers.

Since I did not have time to implement an inventory system, there are no items. With possession, this makes monsters the items as they provide the bonuses that you may get from items. You find yourself exploring levels to find a certain type of monster.

Combat is quite brutal and quick escape is vital because of those features.  There is no time system, so all monsters move at the same speed. The only way to outpace a foe is to leave its field of vision, thanks to a loosy AI;)

The game is composed of 9 levels. The first is the outside of the dungeon, just a cosmetic level with no challenge. Then, each level presents a new enemy or new feature of the game. The generator is the original generator from the tcod python tutorial. The last level is static and contains the boss. The boss itself is an overpowered caster who can summon any creature from the game. So, the basic strategy is to isolate one of its summons and possess it. Hit, get hit, rinse and repeat. The ending depends on who you possess when you kill the boss.

Implementing a RL based on the possession mechanic has several challenges.

• The first one is that anything that the player can do, everyone must be able to do. That includes vision, items, spells,... This suddenly adds a lot to the TODO list.
• The second one is that players will try to bring with them a whole family of useful hosts to be able to use them at anytime, or they may try to stick to a universally useful body. The game has to impose restrictions to limit that behaviour.
• The second is that the certain challenges depend on the availability of a monster in the area. Making it fun for the player to find that critter can be difficult, it it is easy to create frustrating dead-ends by letting the key monster die.
• The last one is that you need to implement monsters with quite a variety of capabilities to make the dungeon interesting. It requires a lot of development time, and balancing is much more complex as if you want to overpower the player, you also overpower an enemy.

In term of restrictions on possession, I opted for a cooldown timer, no healing, and a single foe in view. I could also have explored a decay which removes hp with time which would act as a hot potato which kills you after a timer. I also though of underpowering high-power monsters when they walk stairs (by alternating element themes such as water and fire).

I didn't have time to implement items and inventories, but I had, I still wonder how to prevent the player from systematically dropping all its equipment before possessing another monster. Maybe single use items which "fuse" with the critters could be a reasonable option.

The game is developed with python and libtcod. I have quite some experience with rapid prototyping in python, and that makes it a good language for those kind of projects. I had never tried libtcod before and therefore I started with the tutorial. The first problem was python2, which nobody uses anymore (really). I found some ports of the tutorial but it was a bit late. A more serious problem was that the data structure and design choices in the tutorial turned out to be counter-productive and I had to refactor a lot of the code. Lack of time quickly made it look like a plate of spaghetti. I really wanted tiles (and bought an Oryx set), so I was disappointed to learn that tcod cannot stack transparent tiles on top of eachother.  I wrote a pysdl2 renderer in one evening to replace the functionality which also allowed me to use non-monospaced fonts. But handling the mouse turned out to be too complicated so I dropped mouse support. I also developed a tool for rearranging my tileset although given the number of tiles I have used it was not necessary. 

All in all, I had a lot of fun to participate in a 7DRL, my first. I had explored RL dev before, but never made a complete game. I am glad I succeeded.

Still kind of figuring out the twitchiness.

This is the link to the game:

https://dawnreaver.itch.io/search-for-vinland

The premise: A viking and his crew are embarking on the search for vinland.

This was built entirely from scratch for this challenge.

Software used: Unity 3d 2018.3.1f1, MagicaVoxel-0.99.3, Maya 2012, Photoshop CS5

Feedback is greatly appreciated :)

Ok I'm done. Playable in browser.

These were my stated goals this year (from my design doc)

Goals:

• Incorporate one of my recent favorite activities in rpg games, team building.
• Be 3/4 roguelike: keep permadeath, keep hunger, keep grid based dungeon crawling, ditch item id and inventory.
• Smooth out the pain of permadeath while still keeping it as a way to keep the stakes high and give weight to the players actions.
• Be fairly quick to play while giving room for repeat visits.

I think I got close on most of those. It's not perfect, but it is what it is.

Drag your @ to move.

It's buggy and there's no actual gameplay (can't even kill the monsters), but it's definitely already something weird.

Edit: Started at 3pm Pacific

Edit: The link above goes to the latest version, not the one described in this post.

For full disclosure, I will be basing this project on my roguelike/roguelike engine that I've been tinkering with since 2012 without ever getting far enough to be considered more than a tech demo.  The source code is on BitBucket at https://bitbucket.org/Balmonec/caves-of-the-dragon-age under the name of the engine: "Caves of the Dragon Age".  I'll be continuing to update this repository as I continue development, and figure out how/if I want to split it out into a separate repository after the week is over.

More to come, so watch the devlog on the game page (https://balmonec.itch.io/spellforger01)!

Note that this image and game is just a reference for me, and I will be doing all new art and code in a completely different framework (Pico-8) for this challenge. I just liked how the mechanics worked out, and think there's potential in the concept for an expanded, somewhat puzzle-y roguelike too. Wish me luck, and I'll keep this thread updated with progress shots as I go. Starting my jam at the top of the hour...

Started 02/03/2019 13:00 GMT, submitted 09/03/2019 about 09:00 GMT.

I based this 7DRL around a few themes:

• The combat is decided by random numbers, but the next random number that each creature will draw is known to the player. There is a a simple mechanic (swapping) to reorder the random numbers in their favour.
• The aim is to swap low (good) numbers to yourself while keeping high (bad) numbers on the enemies. You can swap and use items as much as you want without ending your turn, but you are limited by the numbers visible on screen.
• The combat results are shown in multiple places. As well as the panel in the top right, the next random number for each visible creature is shown and colour-coded by whether they will miss, hit or critically hit. The creatures are also colour-coded on the map.
• All corridors are two tiles wide, making it more difficult difficult to engage one enemy at a time.
• The use of smoke bombs as a panic button, reducing the accuracy of all visible enemies to zero for a few turns.

I used Python + NumPy + tcod as with last year. This time I used GitHub for version control.

This year I tried to separate out different systems in an approach that is part ECS (based on this tutorial). However, I ended up redoing the action queue and map generation part-way through (which cost me about a day and a half) so the code is not as clean as I would have liked. I may come back and clean up the code in a post-7DRL update while fixing any bugs that emerge.

Fly the 'Gryphon' starship into hostile space. Warp to star systems and explore a procedural generated galaxy.

Drive the Cyclops (ATV) and traverse planet/moon surfaces to discover their secrets.
Infiltrate hostile stations and bases as Cynthia, a heavily augmented cyborg killer with a personal agenda...

End a desperate, corporate war in a dystopian future.

Core Mechanic:

The game explores the question: 'Skills/Stats' versus 'Items', which is more important?
You start with high skills (due to permanent augmentations), but can one compensate their (augmentations) loss via better items (or other means) and survive to the end in a game that progressively gets harder?

Level  design:

Proc-gen galaxy contains x amount of star systems you can warp between,  each with the following level types:

• Star System (You fly in the Gryphon and see a star and some planets, moons and stations)
  • Planet surface (Cellular automata - large)
    • Base (Rooms/Corridors algorithm)
  • Moon surface (Cellular automata - small)
    • Base (Rooms/Corridors algorithm)
  • Station (Rooms/Corridors algorithm)
  • Gryphon and other key levels are static tiled levels

The game concept has been explored as a failed  2d action game a few years ago that I have since parked.

I'd like to revisit it as a pure rogue-like with a traditional ASCII tileset where I can focus on the core game-play mechanic instead of aesthetics like in the past. 

It will be built with:

• Domino, my unity-based game engine.
• Glift, the font extrusion utility by Solstice333.
• Chronobase, the in-memory journaled database by Stradivast.

I'm building off the demo project which shows off the graphics, and shows reverting to past game states. Now, I just have to make it into an actual game!

My plan:

• Turning the reverting into true time-traveling; the demo shows reverting to a past state at a mana cost, but I'll be adding the "Time Shift Clone" which does the same things you did "back then", so you can cooperate with your past self. It will involve saving a script of what the player did, and making some AI for the clone that tries to follow it.
• Add some enemies. I'll be taking out the ones in the demo (Goblin and Irkling King) and replacing them with ones that play and look more interesting.
• Add a final boss!
• Generate better levels! I'm hoping to have a lot of slopes and interesting terrain, and some caves inside the falls.
• Add a ranged attack of some sort for the player.
• Add a "landmine" attack for the player, to leave timed traps on the ground for enemies to die on.
• Upgrade Domino a bit: Make the "look bar" show items.

Wish me luck!

This is my first participation to 7DRL. My game is quite autobiographical: to win the game, you have 7 days to create your first RL!

Core mechanics:

- You have no hit points but 7 days to make your game. Try not to lose too much time!
- You can control the spawn rate of the bugs by choosing how many unstable features you equip at the same time.
- Weapons and features have ego: find the combinations that work best!
- Depending on the feature that generated them, bugs have special skills. Mapgen bugs can phase, RNG bugs rarely fail their attack.

This game is based on python-tcod. For the record, I use a mapgen algorithm I wrote a few weeks ago to learn how to use tcod. I started to work on Saturday 9a.m. CET.

You can follow the project on my github page : https://github.com/PFGimenez/1rl

Merry 7DRL to everyone!

Sorry I'm only finding this message board now but I have been working on my entry since 2 March.

My idea is to let you explore the dungeon backwards. i.e. You already have the MacGuffin that you were originally questing for and now you are at the bottom of the dungeon and need to make your way up.

This means that I can put all the nest/coolest monsters, items and other mechanics in the "first level" the player interacts with; rather than trying to build up to it; and I think most players (at least, my friends who don't often play rogue-likes) can see what's at the bottom of a dungeon. The end screen shows how much was explored and anything interesting the player might have missed.

As of writing, the player can navigate and escape the 10-level dungeon and get the end screen. There are also hidden tiles and fog-of-war. There is a message log. There is a single, un-acting monster type which the player can damage and kill and healing potions which are automatically picked up but cannot be used.

I'm currently implementing a scheduling system so the monsters can move and attack back.

Using lua/löve2d for everything.

My game is a fairly traditional, but pared down roguelike.  It's turn-based and grid-based has permadeath and dungeons yay!

The basic idea is that you are the hero, but on your own you are a fairly weak human.  In order to succeed in your adventure you'll need to make use of "Symbions" which are magical parasites that you can voluntarily attach to your body to grant you special powers.  While they're attached to you your actions slowly drain their life force.. so you need to be careful.  If you drain one all the way then they die and you lose them forever!  While they are unattached they gradually gain back their life force so that they can be attached again later.

You can only have one Symbion attached at a time, and they all have different sets of abilities so you'll need to decide which one you need at a given time.. for example you might have one that allows you to shoot fireballs, and one that greatly increases your speed... so you can use the fireball one to blast a few monsters from a distance and then switch to the speedy one to run when the monsters get too close!

I'm using tiles for a somewhat modern look.

I'm obviously starting a few days late, and this being my first ever game jam, I'm trying to be very wary of scope creep. I already have more specific ideas than what can reasonable be accomplished in the remaining time but I do also have a pretty rough foundation of a sort of general roguelike engine thingy which I've been tinkering with so I'm not starting completely from scratch. It's really only a subset of what something like libtcod would provide anyway so I don't feel to bad about using my pre-existing work. We'll see where I end up I guess!

Pushing your enemies and dealing collision damage is awesome. How about pushing your enemies (physically) and dealing collision damage (physically)?

https://dicehatesme.itch.io/flicking-heroes

Changelog:

v0.01 (19/3/2): A demo with 4 fixed levels

v0.02 (19/3/4): Trait

v0.03 (19/3/6): Random levels

v0.04 (19/3/7): Artwork and music and more enemies

v0.05 (19/3/8): New heroes: Monk and Magician

v0.05d (19/3/9): Warrior redesign, bug fix, renamed into Dungeons & Disks (formerly named Flicking Heroes), also renamed myself into Artless.

Story: Descend the stairs of the evil djinn's lair and gather the 5 crystal gems to earn your freedom. Be careful, the gems seem to have a strange effect on your mind. Make it out of the lair with as much gold as you can!

Controls:
HJKL (YUBN) - Movement
Space - Pickup item/Down stairs

About: Made with Game Maker Studio 2. Graphics by Oryx Design Lab. Uses some code from /u/riotpopper and Mfzz99 as a basis (Generator and AI). Sound from SFXR & BFXR. Also utilized GitHub Desktop to be able to work on this at home and work.

I began work on this game on Saturday, March 2nd, 2019 and completed it on Thursday, March 7th, 2019 PST.

I had to submit this early as I will be out of town this weekend.

https://hoofedear.itch.io/sands-of-delirium

Let me know what you think!

Dev blog: https://gridbugs.org

For now, I have started the python tcod tutorial to get my hands on the library. I'll be working on evenings only so don't expect anything great ;)

-- edit: changed title to reflect new name

For the Mad Wizard's Maze, players explore a procedurally-generated dungeon with the goal of finding a set number of treasures and then leaving. The commands, UI, and interaction are all in the vein of Interactive Fiction (i.e., text-only descriptions of things, and an abstract space to explore). The procedural part is straight-forward, but I'm trying to make the game as content-driven as possible. This way there is greater opportunity for interaction between various elements to occur, and hopefully that will contribute to more of a roguelike feel. I plan to add other things that are usually not in interactive fiction but would give more roguelike-tactical opportunities, such as sensing nearby things (hearing enemies in adjacent rooms, or seeing light or fire to hint at the next room), different types of attacks, and a chance to evade enemies in a room for X turns so that avoiding combat to trigger a trap (or something) is viable. As I said, this is an experiment.

As my day 1 draws to a close I managed to get an ugly UI working and a basic structure for the game. Players can start a game, get a predefined location with certain items, and do some basic clicking on the UI to indicate what should happen. The next two days will involve making the basic actions and interactions work, which will hopefully result in a "complete" game (i.e., you can start playing, can pick up the only treasure, go to the exit room, and then win). Screenshots will come tomorrow, after the UI doesn't have a bunch of placeholder text everywhere.

The basic premise of the game, is you are a spirit with the ability to swap souls with an enemy. This allows you to transfer all of the enemy abilities to yourself, and vice-versa. The idea is that you will start with no way to attack, and must swap with an enemy to gain their attacking abilities. You will only be able to hold onto the new abilities for a limited amount of time before you will need to swap with another enemy.

So far, I've got the basics for swapping implemented, along with an ECS to make this easier. I'm writing my own engine for the game, using ClojureScript.

Not much to show at this point, but here is a screenshot of my testing room.

I'd like to make a more traditional rogue-like here. I'm severely constrained in terms of time, so we'll see how this turns out. I'll be using rot.js as the basis for this project.