Archive for the Gameplay Category

The Sacred Mechanisms

Posted in Dungeon Generation, Gameplay, Graphics, Rambling Tangent, Room Connectivity, Screenshots on December 5, 2011 by sfahy

At the moment I’m working on developing the basic combat system. Combat is largely predicated on player attributes and equipment, but I want to introduce a level of more immediate strategy. By allowing the player to execute resource limited special moves during combat, the focus is shifted towards the strategy employed in each encounter, rather than just a long term min maxing of stats.

Another area I’ve been doing a lot of work on recently, and am particularly excited about, is the variety of mechanical devices that will be littered about the dungeons.

The machines can be interacted with in different ways. For example, the Translocational Impeller pictured, at it’s most basic mode of interaction, teleports the player to a random location in the dungeon. More advanced modes of interaction are possible, such as teleporting an enemy, teleporting to a specified location, charging an item with a teleport spell and so on.

The advanced modes of interaction are opened up as the player’s character and the game progresses, and allow the dungeons to gradually increase their depth of interaction without dumping complexity on new players.

The machines create the potential for emergent interaction with the dungeon itself. For example, there could be machines that flood rooms with poison gas, or heal everyone in a certain radius, or enchant a weapon according to what item is fed into it, or really do anything that can be done within the bounds of the gameplay system.

The machines will also allow the game to add twists to existing mechanics, for example a machine that suppresses spell effects in a radius, that can be modified by the player to amplify them, or to only suppress enemy effects.

The temptation is to go full on dwarf fortress mode and create a vastly complex system with incredible depth that inspires fear and trembling in all who behold it, but I think that by gradually introducing new interactions with character progress, and above all presenting a clean and context aware interface, the depth can be captured without the complexity. I think the most important rule of thumb for this and all the gameplay systems is that the player should not need a wiki in order to use this.

Once gameplay becomes tied to specific areas in the dungeon, however, the danger arises that the player will attempt and fail to navigate. For example, with the spell suppressing machine example, an obvious strategy for a combat oriented character would be to lead spell-casting enemies to it and attack them. But the player doesn’t have the same high level overview of the environment as in a traditional roguelike, and the absolute last thing I want in the game is to have the player wander aimlessly through the level, endlessly searching for a visited area.

The level generation process uses square rooms as it’s unit of synthesis, maintains a directed graph of parent to child room relationships, and only connects, combines, populates and furnishes rooms once every room has been placed.

Structure could be introduced at the graph level, for example creating a chain of rooms with one entrance and exit at either end. At the moment, every room is connected to every room that shares a wall with it, which creates an environment that is relatively easy to navigate in any direction, but that is formless – It can be difficult to identify landmarks and backtrack.

A lower level solution is to attempt to introduce texture rather than structure.

2D Perlin noise is generated across the level and used to modulate the dimensions of any rooms generated at a given location. This results in a sort of compression and rarefaction of room size across the level, with smaller rooms clustering together and creating a kind of ambient structure in the level that makes orientation easier without attempting to impose rigid patterns.

A combination of both these approaches should hopefully make directed navigation  possible without encouraging it.

On the graphics side, I’ve been experimenting with the idea of using a simple directional shadow map that would anchor the scene together without being an accurate reflection of the lighting. This would save a lot of the resource and complexity overhead of omnidirectional shadows, but the downside is that it’s horrible and it looks horrible. Horrible.

I think after a lot of intense graphics programming I feel a lot more confident that I can get a decent implementation of dual parabaloid shadow mapping into the game. Light sweeping through doorways into the darkened rooms beyond is a really cool effect and adds to the vibe of being alone in a hostile environment. Also it resonates with the torchlight effect used in so many roguelikes, and if this game is about anything, it’s about heritage.



Posted in Gameplay, Graphics, GUI on November 25, 2011 by sfahy

I’ve been working pretty constantly at the game and I’m starting to make progress on the gameplay systems. My current plan is to have three high level attributes – Power, Grace and Will, that direct the gameplay in different ways. The idea is not to have particular strategies hinge on the these attributes, but rather to affect the style of play. For example, a spell caster who is powerful and willful will have a significant boost to the power/ duration/ effects of spells, but due to the lack of grace, spells will be cast slower and be less accurate. A combat oriented character can be a swift duelist or a tank.

This will hopefully allow the player to define their own style of play intuitively. The attributes that dictate success at a particular action will be controlled by secondary attributes, probably a skill system.

I wanted to come up with a cool way to display the three characteristics, rather than the standard stack of integer values.

The idea here is that each color corresponds to an attribute, and each time you increase it another ring is added.

The cool thing about this is that it gives you a visual indication of the ratios between attributes, and also it records the history of  what order they were increased in. For example, in the above picture, the red attribute was the last to be increased, and was increased four times consecutively.

It couldn’t hurt to provide integer values as well, but hopefully this will be a cool way of recording and display character growth over time.

Other than this, I’ve been working on some AI stuff like path finding and steering, as well as making some better quality character assets. I’m arriving at a pretty clear overview of everything left to be done and I think I’m successfully avoiding feature creep.


Targeting, Combat and Colours

Posted in Gameplay, Graphics, Screenshots on November 3, 2011 by sfahy

Boom !


Things have progressed a lot since my last post, and it’s really starting to take shape as a game.

I’ve added a targeting system, which takes into account both proximity and what direction the player is facing. So if you’re closer to enemy A, but looking right at enemy B, you’ll target enemy B. unless enemy A is right beside you.

It will be possible to switch targets quickly when this system fails to target the enemy you want.

The targeting system is critical because it’s the mechanism for engaging in combat. Combat will be abstracted – you target an enemy, and hold down the attack button. The frequency of attacks, whether you hit or miss etc. will all be functions of your character data.

The idea is a kind of pseudo real time that won’t be dependent on reflex but won’t be immersion breaking. I think turn based gameplay works best when the gameworld is largely abstract. When you see textured 3D models just standing there looking at each other, your mind automatically asks the question “Why?” and the immediate answer is that it’s just a game and they’re just textured 3D models.

Also, a roguelike that requires reflexes for combat is blasphemy, and I’ll have no truck nor traffic with such travesties.

I’ve added hue shifting to the shader, so armour and weaponry can have their colours changed with a shader update. There is a mask texture which allows regions of the textures to be exempt from hue shifting which is good for preserving skin colour and specific materials.

I am undecided as to whether an item’s colour should be a reflection of its game properties. It looks really cool to see a bunch of people with different armour colours, but making colour a purely aesthetic attribute would be passing up an opportunity to provide great intuitive feedback.

Enchanted equipment would be comparatively rare, especially at first, which would mean that a lot of armour would look similar. This would put more weight on different texture variations as a means of keeping things interesting. Also, there will be a lot more variation in the kinds of enchantments than colour can reliably express.

I think a viable solution may be to create several textures for each armour type that correspond to its function, so it’s easy to identify enchanted chain mail by the runes inscribed on it or whatever, and keep colour variation across everything.

The animation system is largely developed and integrated and I can spawn a bunch of enemies to stand around the dungeon doing nothing. At the moment I can have more enemies on screen than are likely with no framerate impact, so all is well in that regard.

Animation objects are fed Actor objects, and update themselves to reflect the Actor’s state. Actors have Controllers which update their state – an actor can be assigned a controller which updates it based on player input, or AI, or conceivably network messages. This system keeps state, logic and rendering code nicely encapsulated away from each other.

I’ve added a resource manager which does a pretty good job of keeping resource fetching abstracted from game logic.

Every game resource is marked up in a textfile, and is basically marked up as a keyword (“stone_block”, “padded_armour”) and the resources it uses (“diffuse:  stoneTex2” etc).

If the game needs an iron sword model, it can call something like GetStaticModel(“sword_2”) or whatever. Everything the game needs to load from disk is reduced to a text key, and the messy interrelations between assets are contained in the textfiles.

This can be extended to game data objects as well, for example items and enemies can written directly in mark-up, with all the data objects necessary to render them specified by a single keyword.

It’s very easy to change the look and feel of a level by simply loading a different textfile which maps keywords like “stoneBlock” and “floor” to different assets.

I’m resisting the urge to overgeneralize this system, it already covers the games needs so far and what’s important is that it remains flexible and extendable rather than catering to every possible necessity.

Anyway, that’s it for now, I’ll try to update this blog a bit more frequently. Thanks for reading !

GUI, Gameplay Stuff

Posted in Dungeon Generation, Gameplay, GUI on June 8, 2011 by sfahy

I’ve started developing the data structures that will underpin the gameplay. At the moment I’m trying to keep things as flexible as possible and I’m only implementing simple things like health and basic attributes.

Iv’e developed a root Actor object, which the Player object inherits from and Enemy and NPC objects will inherit from. The Actor object contains an attributes object, which will be common to all game entities, as well a gamestate object that keeps track of information that relates a specific instance of that actor (with stuff like inventory, current health, effects applied and so on). Actor objects will be handled by an Actor Manager system.

It’s very important to the game that all game entities share common data and inherit from a single class. Not only does it make for a more elegant system, but it makes it a lot easier to do things common to roguelikes and RPGs, like gain a monster as an ally through magic, or raise them as a zombie or whatever. It also means that things like effects can be handled a lot more elegantly as well.

There will be a very robust system developed for simple effects (such as strength +1, fire damage etc) as well as for effects that require more nuance (polymorph, walk through walls). The plan is to have effects agnostic to to how they’re being applied.

So for example, lets assume an effect, weakness,  that temporarily lowers strength. A potion of weakness will act as a poison that lowers strength for a period of time. A sword of weakness will temporarily lower the strength of whatever it hits. Armor of weakness will be cursed armor that lowers strength until it is removed.

In each case, the exact same effect data will be used by the item. It is left to the item itself to handle the effect. This makes it easy to do some cool stuff, like let the player enchant items with specific effects, or for example, combine a poison of weakness with a sword, with the result that the sword temporarily conveys that effect.

Effects will be modulated with a balancing variable, so for example an agility reducing effect will be far less potent as a sword enchantment than a one shot spell.

Spells will also employ effects in a similar manner, for example a fire damage effect can be applied as a bolt spell that damages enemies, or used with enchant weapon to temporarily give fire damage to the player’s sword.

(I’m just using random examples here, I’ve always found “elemental” damage types wearying and pointless and I have no current plans to implement such a system).

As I am now starting to work with the underpinning data, I have also been developing GUI elements to provide feedback. You can see the basic debugging information outputs in the screenshot, as well as a bar indicating the players health.

The bar inherits from a UIElement object that all GUI elements will inherit from. It is agnostic to the data it’s representing, it merely shows a bar representing the relationship between a maximum and current value, in this instance set to the player’s health. This bar is neither in it’s final position nor using it’s final graphics, it’s just there to be tested and provide feedback on the player’s current health.

One other cool little feature that’s been implemented is the ability to generate levels from text strings. The idea is to have special portals, spells or magic items were the player “speaks an incantation” that creates a dungeon. Text strings that lead to particularly interesting dungeons can shared among players … assuming there’s more than one of them.