Post news RSS Designing Survival Stashes

This time we check out what we did to improve the environment exploring: this time Survival Stashes.

Posted by on

Sticks & Stones' a Roguelike. Therefore, high-difficulty and Permadeath are part of its core, promising hours of fun on the idea that the player will need to play a lot before he finally wins.

Now, the basic idea behind what he'll do for those hours in Sticks & Stones is planning + combat, planning + combat. That's it. How do you keep players engaged when all you have to do is planning + combat? How do you turn that into a satisfying experience? Combat's a fairly easy issue to solve: good mechanics and eye-candy (animations, special effects, cut scenes and whatnot) and you're pretty much set. But, if combat's supposed to be fast paced, arriving in short bursts of tension, then planning should be the opposite: an opportunity for the game to slow down the rhythm and give the player a chance to catch a breath. Of course, that poses an important risk: slow paced can't mean dull, or boring. Too slow and the player's out the door.

CircularArrows 1


How do we handle that slowing down in Sticks & Stones? The most immediate way is with thirst and hunger, which, although not too important for gameplay, allow for keeping the player in his toes, at least for a while. The planning itself requires also for active attention from the player as he needs to explore the environment for ingredients from which he'll craft. However, given that we've surrendered some control in how the maps are made, what can we do to improve the chances of not only fun but also of motivating flow states?

Enter Survival Stashes

Stashes are a small mechanic which aims to improve the exploration, by giving the player benefits between runs. In the context of Sticks & Stones, they're created by the same contestants as a way to help each other. Something like karma maybe: the more you help other players, the more chances you get of being helped with items that may cost you too much to craft or had no idea were even possible. The idea being that if you stash something of value, the next time you play, you'll find something different of equal value.

This is one of the few mechanics that leaks between runs, and that give the player a way of helping himself in the future.

How We Do It

The Central Zone is where the player can prepare himself. He'll explore, collect and craft most of (if not) all... The stashes will be found through a small glow in the ground, from which the player will dig out whatever the game decided would be equivalent for what he stashed before.

Each of a Sticks & Stones item (be it a piece of meat, weapons, rope, whatever) has a "value" attribute.

 public interface IInventariable
    {
        /// <summary>
        /// Inventariable object type. Acts as sole identifier.
        /// </summary>
        InventariableType InventariableType { get; }

        /// <summary>
        /// Object weight (in grams).
        /// </summary>
        float Weight { get; }

        /// <summary>
        /// <para>Tells if the object can be stacked in the slots of inventory container </para>
        /// <para>For example, weapons, usually, can't be stacked on the same slot</para>
        /// </summary>
        bool Stackable { get; }

        /// <summary>
        /// Value that the object has
        /// This allows for knowing if an object has a greater value than other
        /// </summary>
        short InventoryValue { get; }
    }

We can, from a given object, obtain a list of equivalents:

public static List<IInventariable> GetSurvivalStashArticles()
        {
            List<IInventariable> articles = new List<IInventariable>();

            if (Persistence.Exists(CustomPersistence.INDEX_SURVIVAL_STASH))
            {
                float stashValue = Persistence.GetInt(CustomPersistence.INDEX_SURVIVAL_STASH);

                if (stashValue > 0)
                {
                    int currentValue = 0;
                    List<IInventariable> validArticles = AvailableStashArticles
                        .Where(article => article.InventoryValue <= stashValue)
                        .ToList();

                    if (validArticles.Count > 0)
                    {
                        while (currentValue < stashValue * 0.9)
                        {
                            IInventariable article = validArticles.ElementAt(MapWorld.rand.Next(validArticles.Count));
                            currentValue += article.InventoryValue;
                            articles.Add(article);
                        }
                    }
                }
            }

            return articles;
}

For example, a stash of value 18, will contain objects which sum 18. Simple! Like:

indiedb survival stash examples

But the game will choose! You could get a stash with the same 18 value, or you could get one with 12 (which will probably mean, not that you got screwed over, but that you haven't been too good helping other contestants.)

And that's it. That's how we've done the survival stashes. If you like it, tell us and share, if you don't, tell us, we want to know.

Be sure to vote for Sticks & Stones on Greenlight.


See ya!

Post a comment
Sign in or join with:

Only registered members can share their thoughts. So come on! Join the community today (totally free - or sign in with your social account on the right) and join in the conversation.