The experience of developing “Quak” during a hackathon.

In March 2019 we held a 2-day hackathon named “Ship IT!” in TouK. I was part of the team developing “Quak” – a 2D Liero/Soldat inspired game where players can immerse themselves into being a cute blob-like character while simultaneously laying waste to their opponent.

In this post I want to share our experience writing and designing the game, what kind of roles team members assumed and some of the technical choices we made.

Development

Working for a company that swims in JVM technologies – naturally we chose Kotlin as our development language. Our leader Rafał Golcz created a simple game engine in the ECS Model using the standard java game development library – libgdx and box2d for physics.

ECS stands for Entity Component System, and its main advantage over a standard object hierarchy (as games tend to be strongly object-oriented programs in principle) is its behavioural nature.

Instead of drowning in large inheritance trees and having potential “problems” with instantiation or making sure what kind of object goes where – we receive an elegant solution where the behaviour of every game object can be defined as a list of scripts that are attached to it. From design perspective it also allows for a more natural approach to creating specific objects (as in what properties an object has like dealing damage on impact, destruction on collision, bleeding).

Team Roles

Large gamedev companies (Blizzard, CD Project Red, Bethesda – to name a few) usually have strict roles for people working on their projects. Game directors, designers, writers, composers, testers, programmers, marketing teams, managers – all of which (except maybe for directors/managers) tend to be split between junior, senior and leads.

Developers are also often split according to their main responsibility: engine/tools development, gameplay programmers, special effect programmers. However, in smaller teams responsibilities tend to be way more relaxed. What I find really interesting is the natural emergence of similar structures during these 2 days of developing Quak.

We had a person responsible for art, another person for music and sound effects, 5 people who were actively developing various features for the game (controllers aka joystick and keyboard integration, weapons and missiles/bullets, collisions, character movement/controls, map loading, destructible terrain, blood splatter and camera shake effects).

At some point someone took the mantle of mapper and started creating the terrain you can see in the various screenshots in this article and a few others. What did wonders, in my opinion, was when one person became some sort of a Game Director and Designer’s hybrid. By making sure that everyone had a similar grasp of the direction the game was taking this person made sure that contradicting ideas and implementations didn’t emerge. I was this person.

Experience Itself

New features were “flowing in” as our leader noticed. Everything seemed to work seamlessly, every time someone wanted to push their changes to the repository they were met with the necessity of git pulling the changes which often introduced multiple new features. All of this added up made for a great passionate atmosphere, full of fast development and motivation. At some point we had outsourced testers from other projects to playtest early versions of the game as the sound of quacking echoed through the vast open-space of TouK.

Conclusions

During the project showcase Quak has been met with laughter and smirky remarks – great signs. We concluded that the game was a success – we delivered more than we thought we were capable of before the actual hackathon.

Making sure that the game is “juicy” (in gamedev slang – a game is juicy if love and care has been put into small details/finishing touches) at a relatively early stage with camera shake, visual effects like explosions or blood, sounds of duck quacking (as our bullets are all some kind of variation of TouK’s “duck” mascot) all made the game much more interesting to playtest and to develop – boosting the morale and work efficiency of the team.

Having little stand-ups every few hours to quickly discuss who is responsible for what and in which direction the game is going (what features to cut, which to implement, maybe some new ones?) as well as the aforementioned game director all made sure every member of the team knew what to do and in my opinion was the reason we managed to successfully finish the game. Quak has since then appeared at our stand during Scalar conference and was met with positive feedback.

It was an awesome experience but it wouldn’t be possible without a great team. Kudos to the entire Quak squad: Rafał Golcz, Robert Piwowarek, Agata Kłoss, Mateusz Mazur, Hubert Lipiński and Filip Majewski.

You May Also Like

How to use mocks in controller tests

Even since I started to write tests for my Grails application I couldn't find many articles on using mocks. Everyone is talking about tests and TDD but if you search for it there isn't many articles.

Today I want to share with you a test with mocks for a simple and complete scenario. I have a simple application that can fetch Twitter tweets and present it to user. I use REST service and I use GET to fetch tweets by id like this: http://api.twitter.com/1/statuses/show/236024636775735296.json. You can copy and paste it into your browser to see a result.

My application uses Grails 2.1 with spock-0.6 for tests. I have TwitterReaderService that fetches tweets by id, then I parse a response into my Tweet class.


class TwitterReaderService {
Tweet readTweet(String id) throws TwitterError {
try {
String jsonBody = callTwitter(id)
Tweet parsedTweet = parseBody(jsonBody)
return parsedTweet
} catch (Throwable t) {
throw new TwitterError(t)
}
}

private String callTwitter(String id) {
// TODO: implementation
}

private Tweet parseBody(String jsonBody) {
// TODO: implementation
}
}

class Tweet {
String id
String userId
String username
String text
Date createdAt
}

class TwitterError extends RuntimeException {}

TwitterController plays main part here. Users call show action along with id of a tweet. This action is my subject under test. I've implemented some basic functionality. It's easier to focus on it while writing tests.


class TwitterController {
def twitterReaderService

def index() {
}

def show() {
Tweet tweet = twitterReaderService.readTweet(params.id)
if (tweet == null) {
flash.message = 'Tweet not found'
redirect(action: 'index')
return
}

[tweet: tweet]
}
}

Let's start writing a test from scratch. Most important thing here is that I use mock for my TwitterReaderService. I do not construct new TwitterReaderService(), because in this test I test only TwitterController. I am not interested in injected service. I know how this service is supposed to work and I am not interested in internals. So before every test I inject a twitterReaderServiceMock into controller:


import grails.test.mixin.TestFor
import spock.lang.Specification

@TestFor(TwitterController)
class TwitterControllerSpec extends Specification {
TwitterReaderService twitterReaderServiceMock = Mock(TwitterReaderService)

def setup() {
controller.twitterReaderService = twitterReaderServiceMock
}
}

Now it's time to think what scenarios I need to test. This line from TwitterReaderService is the most important:


Tweet readTweet(String id) throws TwitterError

You must think of this method like a black box right now. You know nothing of internals from controller's point of view. You're only interested what can be returned for you:

  • a TwitterError can be thrown
  • null can be returned
  • Tweet instance can be returned

This list is your test blueprint. Now answer a simple question for each element: "What do I want my controller to do in this situation?" and you have plan test:

  • show action should redirect to index if TwitterError is thrown and inform about error
  • show action should redirect to index and inform if tweet is not found
  • show action should show found tweet

That was easy and straightforward! And now is the best part: we use twitterReaderServiceMock to mock each of these three scenarios!

In Spock there is a good documentation about interaction with mocks. You declare what methods are called, how many times, what parameters are given and what should be returned. Remember a black box? Mock is your black box with detailed instruction, e.g.: I expect you that if receive exactly one call to readTweet with parameter '1' then you should throw me a TwitterError. Rephrase this sentence out loud and look at this:


1 * twitterReaderServiceMock.readTweet('1') >> { throw new TwitterError() }

This is a valid interaction definition on mock! It's that easy! Here is a complete test that fails for now:


import grails.test.mixin.TestFor
import spock.lang.Specification

@TestFor(TwitterController)
class TwitterControllerSpec extends Specification {
TwitterReaderService twitterReaderServiceMock = Mock(TwitterReaderService)

def setup() {
controller.twitterReaderService = twitterReaderServiceMock
}

def "show should redirect to index if TwitterError is thrown"() {
given:
controller.params.id = '1'
when:
controller.show()
then:
1 * twitterReaderServiceMock.readTweet('1') >> { throw new TwitterError() }
0 * _._
flash.message == 'There was an error on fetching your tweet'
response.redirectUrl == '/twitter/index'
}
}

| Failure: show should redirect to index if TwitterError is thrown(pl.refaktor.twitter.TwitterControllerSpec)
| pl.refaktor.twitter.TwitterError
at pl.refaktor.twitter.TwitterControllerSpec.show should redirect to index if TwitterError is thrown_closure1(TwitterControllerSpec.groovy:29)

You may notice 0 * _._ notation. It says: I don't want any other mocks or any other methods called. Fail this test if something is called! It's a good practice to ensure that there are no more interactions than you want.

Ok, now I need to implement controller logic to handle TwitterError.


class TwitterController {

def twitterReaderService

def index() {
}

def show() {
Tweet tweet

try {
tweet = twitterReaderService.readTweet(params.id)
} catch (TwitterError e) {
log.error(e)
flash.message = 'There was an error on fetching your tweet'
redirect(action: 'index')
return
}

[tweet: tweet]
}
}

My tests passes! We have two scenarios left. Rule stays the same: TwitterReaderService returns something and we test against it. So this line is the heart of each test, change only returned values after >>:


1 * twitterReaderServiceMock.readTweet('1') >> { throw new TwitterError() }

Here is a complete test for three scenarios and controller that passes it.


import grails.test.mixin.TestFor
import spock.lang.Specification

@TestFor(TwitterController)
class TwitterControllerSpec extends Specification {

TwitterReaderService twitterReaderServiceMock = Mock(TwitterReaderService)

def setup() {
controller.twitterReaderService = twitterReaderServiceMock
}

def "show should redirect to index if TwitterError is thrown"() {
given:
controller.params.id = '1'
when:
controller.show()
then:
1 * twitterReaderServiceMock.readTweet('1') >> { throw new TwitterError() }
0 * _._
flash.message == 'There was an error on fetching your tweet'
response.redirectUrl == '/twitter/index'
}

def "show should inform about not found tweet"() {
given:
controller.params.id = '1'
when:
controller.show()
then:
1 * twitterReaderServiceMock.readTweet('1') >> null
0 * _._
flash.message == 'Tweet not found'
response.redirectUrl == '/twitter/index'
}


def "show should show found tweet"() {
given:
controller.params.id = '1'
when:
controller.show()
then:
1 * twitterReaderServiceMock.readTweet('1') >> new Tweet()
0 * _._
flash.message == null
response.status == 200
}
}

class TwitterController {

def twitterReaderService

def index() {
}

def show() {
Tweet tweet

try {
tweet = twitterReaderService.readTweet(params.id)
} catch (TwitterError e) {
log.error(e)
flash.message = 'There was an error on fetching your tweet'
redirect(action: 'index')
return
}

if (tweet == null) {
flash.message = 'Tweet not found'
redirect(action: 'index')
return
}

[tweet: tweet]
}
}

The most important thing here is that we've tested controller-service interaction without logic implementation in service! That's why mock technique is so useful. It decouples your dependencies and let you focus on exactly one subject under test. Happy testing!