Showcase Saturday - The Banner Saga 3

As a team that’s making our own turn-based tactical RPG, you can probably guess that we’ve played several games in the genre. One favorite that both Robby and I share is Stoic Studio’s Banner Saga series. The first and second installments of the Banner Saga are known for their stunning art style and bleak yet moving narratives. They also introduced a fresh take on tactical combat that required a new approach from seasoned tactics gamers.

Image from the Banner Saga 3 Kickstarter page

The Banner Saga 3 has been up on Kickstarter for a few days and is close to reaching its goal of $200,000. While it will almost certainly reach its goal at this point, I still encourage people to check out the Kickstarter and donate if the pledges interest you. Regardless of whether you choose to donate, I definitely urge you to check out the first two games. While Alkanaur will end up quite distinct in terms of gameplay, narrative themes, and art style, I think the Banner Saga games show just how much depth and variety the tactical RPG genre has to offer.

Next week’s Showcase Saturday will show off some of our progress on Alkanaur’s battle mechanics, so if you’ve been hungry for some Alkanaur content, make sure to stop by our blog on February 4^th.

Dev Take Tuesday - Compliments

When’s the last time you allowed yourself a compliment? Today’s brief Dev Take Tuesday post is inspired by a Twitter hashtag. I saw the little list of what’s trending on Twitter and saw #NationalComplimentDay. Now, I know that all these silly holidays can be somewhat…well…silly. And based off my last desk job I’m pretty sure there are at least three separate “National Donut Days.” All that being said, I still liked the idea of dedicating a day to compliments.

Image of Fallout's Vault Boy, made by Bethesda Softworks

I’m going to make sure to give out a few extra compliments today, both in real life and over Twitter. But that’s not the focus of today’s post. I repeat the question I started with—when’s the last time you allowed yourself a compliment? I feel like the inescapable stream of iteration in game development forces most developers to become increasingly self-critical. This isn’t necessarily a bad thing. Criticizing is like chiseling—you keep chipping and shaping and smoothing to find something beautiful in what was once rough. But chip away at a stone forever and you’ll wind up with no sculpture and very tired hands.

Remember to take a break from self-criticism every once in a while, and give your project a compliment. Today, I’m going to compliment the work that Robby and I have done to start marketing and playtesting our game early. Working on builds that were only meant for demos felt a bit strange, but we got valuable feedback from the experience. Similarly, tweeting and posting while our followers were few and marketable content was hard to find sometimes felt like the first few brushstrokes of a painting, when the artist wonders if those brushstrokes will amount to anything. We’re starting to see the results from that work as our “painting” takes form, and I’m proud of our efforts to not only make a playable game, but a game that people will (hopefully) want to share with their friends.

So I encourage all the other devs out there to not only participate in #NationalComplimentDay, but to periodically give compliments to your own work, the work of others on your team, and the work of other dev teams. Let’s keep improving our art form and setting the bar higher and higher for what video games can do.  And let’s make sure we don’t wear ourselves out along the way. 

An early Showcase Saturday - Milkmaid of the Milky Way

I'll be busy tomorrow, so I guess we're doing Showcase Friday instead. Doesn't have quite the same ring to it, does it?

Milkmaids, cows, and frogs. Oh my. (Image found on the game's dev log)

Anyway, I just want to give a quick shout-out to a game called Milkmaid of the Milky Way. I've been following the game's progress on Twitter and Reddit, and I'm impressed at what this one-man dev has been able to create in about two years.  Do you remember the classic point-and-click adventure games of the nineties? Throw in some charming pixel art graphics and rhyming text and you have Milkmaid of the Milky Way. (By the way, the poet in me now feels challenged to make my own game filled with only rhymes, heh.)

The game just came out this week on Steam, and you can check it out here. 

Dev Take Tuesday - La La Land

Yesterday my wife and I went to see La La Land, the musical film starring Ryan Gosling and Emma Stone. I expected some good songs, copious dancing, and a sweet love story between two good actors. I wasn’t prepared for the film to be so poignant to me. I guess you can hold off on reading this post if you’re concerned about very mild spoilers, but I promise I won’t say anything that isn’t apparent 15 minutes into the film.

Gosling and Stone in La La Land (Image found here)

The two main characters are both dreamers of sorts—artist-types living in L.A. (the title of the film is rather clever). As expected, both characters experience conflict as they struggle to balance their dreams with reality. It’s not the first time this theme has shown up in a movie, of course, but maybe because of the music and the likable yet believable characters…something just clicked for me emotionally. During one scene toward the end of the film, I actually got quite emotional.

I know that balancing optimism and pragmatism is a constant conflict for practically anyone in the business of creating. I know some people try to peddle easy answers for game developers and other creators, but I don’t believe there’s one cure-all for everyone. The hard (but true, in my opinion) answer is that every situation is different, and that we need both realism and optimism in these industries. It’s obviously important to be realistic when it comes to managing expectations and taking care of finances.  I don’t see any reason to be ashamed of working a day job to pay for your art, and I never look down on people who want to primarily make money from making games. But I also admire people who take that leap and dare to realize their dreams--without them, we'd miss out on a lot of beautiful art and enjoyable games. As Emma Stone’s character, Mia, sings at one point in the movie: “Here’s to the ones who dream. Foolish as they may seem. Here’s to the hearts that ache. Here’s to the mess we make.”

I’m proud to be a dreamer, despite the heartache and despite the messes. Here’s to all the other foolish game devs out there who dream.

How to implement movement undo

It turns out that Skye still has a partner in crime on this project. I tend to keep to my hermitage, but from time to time, I feel it necessary to let people know I'm still here. Lately I've been focusing on building the code instead of the artwork, which is why there hasn't been much to show. However, I thought it might be interesting to talk about some of the design.

One of the most constructive bits of feedback we received from the Salt Lake gaming convention was that our movement system was not immediately intuitive. Because of that we decided to overhaul it and move to a point-and-click waypoint system similar to other tactical games. There are a few working parts to this, including the path finding algorithm, the grid system, the waypoints, and the actual movement. However, I'd like to focus more on the design of the waypoint system.

For those familiar with the fundamentals of programming, there is the concept of a stack. For those that know a bit more, there's another concept called the state pattern. A stack is essentially what it sounds like. You add things to the top and when you need something, you take it off the top, making it a "last in, first out" structure. The state pattern is a way to design the flow of a program. Essentially, there is one object that everything references and it delegates to state objects that behave differently. In order to implement a path (with waypoints) that can be undone, I employed a combination of these two concepts.

Here come the technical details, so if that makes you uneasy, feel free to stop here or skip to the last paragraph. Anyway, to start, I added an interface for what I refer to as an “action”. This action is essentially one of the state objects and any state in the state machine will need to have the same interface to its actions as the others in order for it to be reused. As I am using C#, the code looks something like this:

1 2 3 4 5 6

public interface IAction { void Act(Vector2 move); void Act(bool confirmation); .... ActionType GetActionType(); }

The Act() function accepts a number of different types of arguments. Each one will be implemented differently based on the state.

An example of one of the states might be something like this:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class MovementSelection : IAction { private Vector2 location; public MovementSelection() { // Initiation stuff for this state } public void Act(Vector2 move) { // Check for stuff that might need to validated before the move actually happens // Now we have a move, so we need to store it and move to the next state location = move; ActionHandler.Instance.SetState(new MovementWaypoint(move)); } .... public ActionType GetActionType() { return ActionType.MovementSelection; } }

As you can see, the state is in charge of initializing stuff for itself, storing any relative data, and then moving to the next state if appropriate. It also can return the type of state it is for bookkeeping if necessary. Then the next state (MovementWaypoint) handles itself in a like manner. And of course different states will keep track of different stuff and behave differently.

Now you may be wondering where all of this is initiated from and where the main handler object comes in. One of the keys to the state pattern is that the states are essentially hidden from the rest of the application. The state handler and other states are the only ones that should know anything about states. Ultimately, the state handler becomes the interface to the rest of the application for this.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

public class ActionHandler : IAction { // The following makes this object a singleton private static ActionHandler instance; public static ActionHandler Instance { get { if (instance == null) instance = new ActionHandler(); return instance; } } private ActionHandler() { /* any necessary initialization here */ } private Stack<IAction> stateStack; public void SetState(IAction newState) { // sets the current state or, for us, adds it to the stack of states that are used to keep track of state history } public void RevertState() { // Pop off the stack to have the previous state be the current } public ActionType GetActionType() { // get the type of the current state } public void Act(Vector2 move) { // calls Act on the current state } public void Act(bool confirmation) { // calls Act on the current state } .... }

There’s kind of a lot going on here, so explain it a bit. The first part makes this into a singleton, which ultimately means that only one instance of this object will ever exist. I won’t go into too much detail on this concept, but this is important because we only want one occurrence of the state machine. The next part is the stack that I mentioned previously. This is used to keep track of a history of states, or in our case, moves. The MovementSelection state handles the initial selection and the MovementWaypoint state handles subsequent selections and can also close out the path. Since all of these states are kept track of in the handler, it can handle all of it and delegate calls to the states themselves. Then if we need to undo, we can just revert the state and have the previous state as our current.

The benefit of using a stack is relatively obvious as it provides a history of actions, however, the state pattern is another powerful tool. Instead of having to edit a lot of code that could potentially be in a giant if statement, we can just add a state and update who goes to that state and what that state’s behavior is. Additionally, the state pattern can be expanded to more than just the movement (hint: I used this for the entire battle flow). Anyway, I hope this has given some useful information to those curious about the process.

Dev Take Tuesday - A Small Tribute to Carrie Fisher

Like many others today, I’m saddened by the death of actress Carrie Fisher. As a huge fan of the Star Wars universe—including the movies, books, and video games—I first appreciated Carrie Fisher for her role as the iconic Princess Leia. But later in life I started to also appreciate her honesty and candor in interviews as she discussed her problems with mental health and addiction. I think it’s important for me to remember that she wasn’t just about unconventional hairstyles, creative insults, metal bikinis, or even her skill with a blaster. Carrie Fisher was royalty off the screen as well.

Image found on this Huffington Post article

While writing and developing the characters of Alkanaur, I’ve always known that mental illness would play some role in shaping their personalities and backstories. I’ve personally dealt with depression and anxiety, and people close to me have had even more acute experiences with mental health. At this point, I haven’t written any specific dialogue, so I’m not sure how much of our characters’ problems with mental health will show. However, I do promise that all our characters’ struggles and experiences will be treated with respect, openness, and sincerity. Hopefully—in some small, small way—that will be a fitting tribute to Carrie’s legacy.

Showcase Saturday - Steam Greenlight and Skelattack

When I mention that I’m making a video game to friends and family, many people are curious how we’ll take our game to market. I’m going to use this showcase Saturday post to give a quick explanation of how we plan to get our game to consumers: Steam Greenlight.

Image found on Steam's website

Steam is essentially a digital storefront for nearly all computer games on the market. With few exceptions it’s safe to say that if you’re into PC gaming, you know Steam and use Steam. Steam used to curate all available games on its own, accepting titles from known publishers and then reviewing games from smaller companies to see if they belonged on Steam. With more and more independent (indie) publishers trying to get their games on Steam, the company decided to use a new crowdsourced approach called Greenlight.

So once our game is a little farther along—we’ll need to include screenshots and a nice trailer that show polished gameplay—we will enter Alkanaur into the Greenlight process. Once there, people can vote whether or not they’d be interested in buying the game. If we get enough attention, our game gets “greenlit” and we reserve a spot on Steam’s digital shelves, so to speak. From that point on we’ll continue to develop our game until it’s ready for release. Another nice feature of this process is that we’ll be able to build a community on Steam and keep receiving feedback to improve.

With so many games trying to be greenlit, the first few days of being on the front of the Greenlight page are vital. After you slip further back in line, you rely on other avenues to get visibility on your personal Greenlight page. So we’re hoping for a big first day, but if we don’t get greenlit right away, we’ll just keep spreading the word. Both Robby and I are confident that we’re making a well-designed, polished, and meaningful game that belongs on Steam, but it might take some extra work to make sure we get the necessary visibility. When the time comes, we’ll be reaching out to everyone for a bit of help. We’ll let you know!

In the meantime, I’d like to showcase a fun game called Skelattack. I’ve been following its progress on Twitter, and I think it has a unique character design and some fun gameplay. Skelattack is currently in the Greenlight process, so if you have a Steam account head on over to this link and check out the game. There’s even a demo version for Mac and PC users.