This is a minimalistic roguelike set on a spreadsheet where typing attacks your enemy and heals you at the same time. It was my entry in the gamedev.tv jam, and ranked #32 in mechanics and fun out of 1000 entries. Since it received a lot of positive comments, I've decided to keep working on it, unlike my other jam games.

Features already in-game:

• Brief introduction/tutorial via dialogue
• 16 levels of increasing difficulty
• Win and lose screens
• Basic timer
• Enemies which attack every second. Their length and number of "special" characters determine their damage.

Features I'm aiming for in the release:

• Multiple difficulties (Implemented)
• Better level generation (Implemented)
• Better UI/UX design (Implemented)
• A more fleshed-out story (Implemented)
• Highscores/savegames (Maybe)
  

Play here: drhippo.itch.io/grid-of-yendor

I've already made some QoL fixes, but I want to integrate the game with git and butler and do some refactoring before I add any content.

Here are some screenshots:

Thanks for reading and I hope you have a great day.

Just set up both butler and git for my project and reorganized files into folders (it was a big mess). Nothing visual to show yet, but I'll be working on that next week. Super excited about butler as it apparently repairs macOS and linux file permissions, which should let me publish proper builds to those systems from a windows machine (Unity just can't build from windows to mac).

Added a pause screen with volume sliders and an option to disable post-processing, which should speed up the game on slower computers. Pretty basic right now, but it works and even saves your settings between sessions! Now working on improved level generation. I'll post more details about this after I get something done.

Worked on level generation a bit more. Since I don't have anything visible yet I'll explain how it works instead:

A level is represented by a grid of cells with set width and height. Each cell can be an enemy (red; attacks, and player can't leave until it's killed), boss (purple; currently same as enemy except for colour), health pickup (green; doesn't attack and can be exited at any time), or exit (yellow; the player goes to the next level after typing it). The player always spawns at the top left of the level. When initializing, the game reads from a JSON file and loops through each item in the list, spawning and configuring cells based on the properties. When it finds an empty string it generates a random enemy to fill it based on level difficulty (also in the data file). The exit/bosses/health pickups of each level are manually defined. 

While this was the easiest option for a jam game that most reviewers would only play once, it quickly becomes repetitive and replaces actual gameplay with memorization.

In the new system, the game will first select the spawn, then place an exit a set distance away, then place health pickups and finally fill in the rest of the cells with enemies. The health pickup and exit names (what the player types) will also be randomized. This increases replayability a lot without noticably changing the game feel or pace.

As for other progress, there are now gutters to the top and left of the "spreadsheet"! Ive also added a button to skip the opening dialogue and a few more enemies/adjectives. Here's a gif of current gameplay. (Turns out not having graphics makes gif files small as hell, so this 16-second gif is only 2.5mb)

TLDR: The current level generation is a band-aid solution because all the interesting stuff is hard-coded. I'm working to make it slightly less bad.

Today I finished adding bosses to the new level generation system. Also implemented a difficulty system, so players can choose from three different difficulties when starting a game. Most of the jam reviews said that the game was too hard (it was; I didn't playtest enough), and I couldn't even beat it when I tried XD. The difficulty of the jam submission was probably harder than the current "hardcore" mode. Some jam reviewers really struggled because they don't type often or because of disabilities. This system should allow everyone to have fun while playing. 

All major release features are now implemented. The remaining work is fixing bugs, code refactoring and reorganization (a lot of it...), and increasing the visual appeal of the game (let's face it, it doesn't look that fun at first sight). Once most of that is done I'll upload a demo and get some feedback from real players. The big release will come a few weeks after that once I'm satisfied with the game.

Here's the new (very placeholdery) difficulty selection screen:

And here's me fighting the iconic Gunnar Gunnarssonsson, now moved down to floor 12:

I did procrastinate about this, but I finally refactored my code from the jam ;). It's now more extendable and ready for further development. Unfortunately I now have merge conflicts in my repository, so I'm gonna have to learn how to resolve these. I'll upload the demo tomorrow if all goes well.

On the visual side of things, I've increased contrast throughout the game and added post-processing to more scenes. Here's the improved difficulty select screen as an example:

Demo is now live!

What's new:

• Multiple difficulties
• Better level generation
• Pause/settings menu
• Credits screen
• Many visual improvements
• Mac build for the first time (thanks butler!)

Many things (especially audio/visual cues) are still placeholder or not implemented. I'm looking for feedback, so please leave comments on the game page.

The demo went well, and I got enough useful feedback to re-evaluate the game. What I found is that the core loop (type -> gain health -> enemy die) is fun, but it's drilled too explicitly into every encounter, so it loses its appeal fast.

Main issues:

• Enemies all have the same stats, so each fight feels the same
• Bosses are too similar to normal enemies, so boss fights aren't that interesting
• Each floor feels the same, and searching for the exit is boring

What I'll do to solve them:

• Adjectives attached to enemies will modify their stats, instead of just being something else to type
• Make boss fights memorable with dialogue/camera zoom/healthbar etc.
• Distinct "biomes", each with unique enemies, adjectives, and maybe even appearance. Each floor is randomly assigned a biome.

Minor things I found were needed when playtesting:

• On-screen indication that capslock is active
• Tab/enter movement hints for players who don't work with spreadsheets

Other features like highscores and juice are still on the roadmap but at a lower priority until I implement these fixes. I'll also be pausing development as I'm participating in the GMTK Game Jam this weekend. Have to stock up on sleep beforehand so I can spend more time jamming ;).

Submitted successfully to GMTK and planned the new enemy modifier system after I took a break from development.

Each enemy would have 2 modifier slots, an adjective and an element. Adjectives act on enemy stats (just attack speed and damage, for now) directly, and elements (rarer) give special abilities, which are cast every so often when in combat. I focused on uniqueness rather than number when creating them, so there are only 4 right now:

• Leaf: regenerates letters every few seconds
• Fire: Burns player for a percentage of enemy's damage (when the ability was cast) periodically for a while
• Dark: Poisons player, dealing a small amount of damage periodically until they reach a healing/exit cell
• Blinding: Makes player unable to see neighboring non-empty cells until they move into one

 I'll see if only having these elements is interesting enough, and add elements which combine two basic ones if not.

There's now basic CSS on the game page, but I'm still working on it. (still, check it out!)

Also redid promotional art. Here's the new cover: (work in progress)

Today I restructured the enemy initialisation/level generation code to allow access to individual adjectives (they still aren't implemented though, as I'm still looking for a way to execute functions from strings in C#).

I also started making a change that's been planned for a long time now. Since the first versions, the character counter was always in the bottom-right, but it was hard to see when fighting. I decided to move it to a flap beneath the current cell. This also means there's more space on the bottom bar for other UI (like a WPM counter).

Here's a mockup of the new cell highlight:

I was pretty busy this week visiting family, but I made modifiers affect enemy stats and appearance, and started adding a health bar for boss fights. Worked on the cover some more as well. With one more mystery mechanic to implement, the beta is coming along pretty well!

I'm still working on the mystery feature, I think it will be ready to reveal some time next week.

I've added a zoom effect  and a health bar when fighting bosses. Also added new UI sprites to the main menu.

Introducing wards!

What's that? A ward protects you from attacks, blocking 50% of damage (20% for bosses), consuming itself in the process.

You collect wards by killing enemies without being hit. Tough to do with normal enemies after the first few floors, but manageable with "slow" and "sluggish" modifiers (look out for them!). Wards are much harder to get later on, so you have to choose between rushing to the exit or collecting as many wards as you can on the first few floors. A fast completion depends on how well you can judge your typing ability ^_^

As for other development progress, I've finished the boss fight health bar and improved the UI all-round (although there are still some issues in builds). Now the game is almost ready for beta testing!

It's been a pretty productive week :)

Worked on the title screen: now it looks much more interesting! The falling letters hint at the word-based gameplay and make it dynamic.

This really should have been added much earlier, but the game now plays sounds when a cell is emptied. I've also added many new monsters and balanced the order/difficulty of bosses. 

There aren't many issues left to fix anymore, so the beta will release tomorrow if I don't find any more gamebreaking ones.

GoY Beta is out now!

What's new:

• Adjectives now change enemy stats/appearance
• Ward system
• Improved UI
• More sound effects
• Health bar/zoom effect for boss fights
• Lots of behind-the-scenes balancing

I've fixed most of the issues that were brought up in the demo. The gameplay is much more fun, the UI is better, and the game is more responsive in general. It was a lot of work but I'm proud of where the game has come. In the future, I'll try to update it regularly so I can get quick feedback about features as I implement them.

Just made a small update which fixes some bugs and adds some features that players wanted.

In terms of gameplay, the engagement issues from the demo haven't changed. The game loop is well-defined (maybe too well-defined), but there isn't anything else to motivate players. Right now, the unconventional gameplay is the only thing that draws players in. Once they get used to that and win a game, there's no reason to keep playing.

A few players mentioned that the game could be used to teach typing in schools, but it doesn't have a WPM or accuracy counter yet. A persistent score for each successful run, calculated from completion time, accuracy, WPM, and characters/wards remaining could be enough to motivate players. Achievements are popular in other roguelikes, but I'm not sure how to implement them, so they'll have to come later.

Now comes rewriting game code (hey, at least I left comments) to accomodate these features.

Had a busy week, but I'm still working on the accuracy/WPM counter and a better results screen. I will post a full update once I finalize the design.

For the last few days, I've been working on the WPM calculator, which would be one of the most important features if players use this to learn typing. Making the value change smoothly was a real challenge (the interpolation step is pretty complicated to say the least). It did teach me a lot about C# features and maths though, both in failed attempts and the final implementation.

Here it is. Ta-da! (look at the bottom right ^u^)

The accuracy display and the results screen are also ready.

 I will wrap this update up and upload a build shortly.

Honour - a new score system

In the jam version of the game, the run time was the only stat tracked by the game and the only one that mattered. Now with the game expanded so much, I want to reward players for being accurate and playing on higher difficulties. 

The new equation takes accuracy, WPM, and total (correct) characters typed into account as well as run time. This aggregate score system is called honour. For now it's just a number on the results screen, but I have many ideas about expanding this.

As you can also see, cells now show their coordinates when emptied. This leads into a planned navigation update.

GoY v0.1.2: Get better at typing!

This small update focuses on the typing aspect of Grid of Yendor, and prepares for future releases with behind-the-scenes refactors.

• Added WPM and accuracy measurements/display
• Added honour - an aggregate score system based on WPM, accuracy, completion time, and characters typed
• Results screen shows more stats
• Cells show their coordinates when emptied

I'm planning to expand many of these features in the future, but for the next week I'll be taking a break from development to focus on real life. Thanks for all the feedback from the community, which has been a great help in finding bugs and expanding the game.

I took a break from programming, but that doesn't mean I stopped working!

Promo art has always been a weak point in my games. Mechanics don't matter if no one plays it. I'm redoing all the art on the game page (especially the cover) to make new players click that download button.

This was the old icon. It shows the name of the game but not much else. It's better than nothing, but it's uninteresting and won't attract players.

And here's the new one. It's a bit more complex, but it's still recognisable and shows the core game mechanic. Much nicer!

I also worked on BGM by changing some of my old tracks to fit the game. This is still in progress, but once I'm done there will be more variety than the single looping track in game right now.

I've mentioned elements before as a way to improve variety, but they haven't received any attention since. I did make some structural changes beforehand to make implementing them easier, but I was more focused on modifiers and wards, which were simpler to implement and explain to new players. I was also worried they would find elements too complex and quit the game. But now that the other features are done, I figured I'd get back to it.

Here are the (semi-)finalised list of primary elements and their effects:

• Fire: damage increase by one each attack (Implemented)
• Water: cell switches state from unfrozen to frozen (and vice versa) every attack. Invulnerable when frozen. (Implemented)
• Leaf: cell regenerates a character every two attacks (Inplemented)
• Dark: cell darkens making text hard to see (not sure about precise values/patterns yet)
• Lightning: casts a ward-piercing double-damage bolt every three attacks

These primary elements can also combine. I won't list them here, but that makes a total of 15 elements, which makes gameplay much more interesting, and less about typing speed as it's about choosing which enemies to fight.

As you can see the effects all depend on the number of attacks, and not an objective time unit. It did make implementing a bit easier, but it was primarily a design choice to make speed adjectives impact elemental effects, which adds dynamic complexity to the game.

There's still a lot of work to do adding animations and icons to properly show what the effects are, and I'll have to change the tutorial to include an explanation of elements.

Also added "drunk" and "chaotic" modifiers for enemies, which both randomise attack speed. I'm still working on the new cover for the game as well.

Updated the cover image to something much more interesting. I might retouch it before release but it's done for now. Also, all five elements are now functional.

Unrelated, but the game had a spike of views and plays in the last few days ;) It's even close to the top of "popular" for the dungeon crawler category now. Not sure if that's the algorithm pushing it up or a staff member adding it to some kind of verified list. But hey, it's nice no matter why.

OMG I loved it! It was a genius idea to take spreadsheet navigation to exploring dungeon type of game

Keep up the good work!

Currently the only way to discover the level exit is to enter an adjacent cell. This is fine on smaller levels, but searching for exits gets frustrating as level size and difficulty increases. With that in mind I decided to add two new cell types to the game:

These are the navigation cells, and they solve the problem by hinting where the exit is. Inscriptions reveal the exit’s row or column number, and signposts point to it (but don’t show distance). I think there’s great potential for dynamic gameplay here, and the skill ceiling for using these cells to get to the exit faster is very high.

Some situations in larger levels:

• A player finds a signpost which points back towards where they came from. They find the exit is just out of sight from where they’ve explored, saving precious seconds.
• A skilled player finds an inscription and a signpost. With this info, they work out the coordinates of the exit and are out of the level in less than a minute.

Movement should be less monotonous now, because a quick run doesn’t just rely on typing fast but also on using these hints well. To compensate, the average distance to the exit has been increased.

Elements are a great addition to the game, but their effects aren’t obvious, especially when the player is focused on fighting. I realised I had to show what they did in a simple way. I decided to use an icon approach with simple animations. Designing the icons and animating them took time, but it was worth it in terms of clarity and simplicity.

Here are the five element icons. I went for a simple look emphasising diagonal lines to fit the game’s style.

And here’s how they look in actual gameplay:

Cells can have multiple elements at once, and the icon system represents that as well.

I’m hoping to release this update next week, so fingers crossed that it’s happening.

The v0.2 update is finally out after more than a month of development! Really big milestone for the game, as it's now (somewhat) of a complete product.

The full release notes are here, but to summarise:

• 5 elements which which make enemies stronger, for that extra challenge!
• Signposts and inscriptions to guide you to the exit
• A new tutorial system for new player

Check it out!

Took a break from development and focused on the new player experience. I changed some potentially confusing labels and polished some visuals.

I’m really not sure if I should keep making web builds for the game. Obviously, browser games have less resources and can’t perform as well as native executables. The audio quality is worse and there’s input lag, to name two obvious issues. I’ve also had reports of the browser build lagging (which should make people download, but the stats show they don’t :&).

Despite the bolded disclaimer to download, the game has 10x browser plays compared to downloads, and many hits are from play-in-browser searches (so people wouldn’t even have found my game if I didn’t have a web build). I don’t know if I should let more people play a worse version of the game (which they do enjoy however judging by the reviews) or force them to download and get the best of what I made (but then some people won’t discover/play my game at all). Won’t get rid of the web build for now but if people stop enjoying it I’ll rethink if it really needs to be there.

A big announcement to make: I finally came back (yay!) and GY is being rewritten from the ground up to accomodate new features. I took the break because of exams, but those are mostly done now.

In hindsight, the jam version’s code was badly written, and I should have started back from scratch afterwards. Many features I want to implement require refactoring, which will only take more of my time as I update the game. Better late than never at least ;)

On the bright side I can reuse the art and sound effects, and adapt (better) code from the old codebase instead of completely rewriting.

You guys know how accurate update time estimates are, so I won’t make any right now. I should be able to add most existing features during the next week though.

In terms of new features, more exciting boss interaction (minigames?) is the priority. I also want to add comprehensive in-game help and start on permanent progression to retain players.

Core mechanics will stay the same, but there are some visual changes to make gameplay more engaging. More info on that, and more, coming next week. Until then, have a nice weekend!

Just posted a devlog entry marking one year since GY was published on itch. Time really flies ;)

I changed the font to a more angular one to fit the rest of the game, and added an in-game help screen so people won’t get too confused on how to play.

Here’s a screenshot from the new version, which I plan to release next week:

(Re-)implemented cell modifiers, bosses, and most of the GUI. Worked too quickly last week and was burnt out, but I’m back to normal now.

Features that still need to be implemented:

• Elemental effects
• Settings (i.e. adjusting volume)
• Score
• Background music changing depending on environment

One thing that has consistently surprised me is how small the new codebase is right now, even with most features implemented, which is an encouraging sign and shows how bloated the old version was.

Every feature listed above, and plenty more, are now implemented. Just some testing and last-minute polishing to do before I can release the game, which will likely happen tomorrow. Too tired to write anything else right now, I’ll put full details in the release devlog post.

v1.0.0 out now!

Full release (finally!) after a month of work starting from zero. Apart from the score system, there aren't any major new mechanics, but almost every part of the game's interface has been improved in some way (I did start from a blank project, after all). My experience in developing the previous version helped me avoid pitfalls in programming and project organization. I was able to redo 5 months of work in 1 both because I had a direction (re-implement all existing features, but better) and because of the projects I worked on during the hiatus. Here are some ramblings that I'm finally writing down. 

Font

The previous font, Roboto, was a good choice as it had variants for different font weights and italic text, which I used to indicate enemy size and attack speed. However it looked too generic, so I replaced it with Tomorrow, a more angular font, to give the game a distinct character. I'm honestly surprised that it had as many variants as Roboto, as most fonts I found didn't even had separate bold font file, let alone all the different font weights I needed. It fits the rest of the UI really well and is readable and stylized at the same time.

Sound effects/animations

One thing I realized during development was how important a game's presentation is. After all, mechanics are meaningless when no one plays your game.

I wrote a script to fade between soundtracks, which allows me to change the music smoothly. Menus, win and death screens, and gameplay now all have different background music. A big improvement from all previous versions, where there was one infinitely-looping track. As for sound effects, all five elements now have unique attack sounds, and I've added many other gameplay sounds as well to give feedback to the player.

Most developers want their players to win, so they pay attention to their win screen above everything else. But a game that most players win first-try can't be fun. I added a proper death animation and sound effect, as well as a unique soundtrack for the lose screen. A new player will probably see that much more than my win screen, so I prepared by putting more effort into designing that.

Had to adjust some sound effects over and over again because they didn't sound right, but eventually got them to a place where they were half-decent.

Code changes

The least glamorous but most useful change by far is the code restructuring. It won't go on any changelog, and players will never see it directly, but with a well-organized project I can actually add features and fix bugs without having to rip everything apart.

Wrestled for a few hours with the script execution order to fix cell values/modifiers not being set properly during floor initialization. I had to wait for the code to recompile every time I changed it. Learnt a lot about function execution orders from this. While it was frustrating, I solved the problems by refactoring so each task was done on as few scripts as possible, accessing values from others if needed, and resulted in much more modular and extensible code.

Finishing with a quote from a friend:

"it seems like an actual game now"

Really encouraging!

Changelog/more formal announcement here

Released a small update focused on polish and better game balance.

I've got some plans for future updates, but I think I need to learn more about how to implement them first before anything can appear as code. Also have to smooth out some unintended behaviours/minor bugs currently in-game.

Worked on giving the player a sense of progression for this update. As the developer, I understand game mechanics and progression extremely well, but players don't. I've learnt to show them to the player many times to make sure they understand it properly.

• Added a bar at the bottom of the screen to show playthrough progress, complementing the preexisting text. 
• The game now plays an animation that shows the current floor number at the beginning of each floor. It shows the floor number and the presence of bosses.

How it looks:

Because of playtester feedback, I buffed the fire element to increase damage by 3 instead of 1 every attack.

Also made a few smaller changes to cell colours and UI layout, but those aren't too important in the grand scheme of things.