Goril­la Game Builder Demo

Nick Hodges, Goril­la
@nikoraisu

YouTube

By load­ing the video, you agree to YouTube’s pri­va­cy pol­i­cy.
Learn more

Load video

Full Tran­script:

Nick:
Hel­lo, I’m Nick from Goril­la just like Jo said and today I’m going to talk to you about the game builder tool that I’m putting togeth­er and also some slight­ly more sort of a down to earth, prac­ti­cal steps of how to go about design­ing and mak­ing your own games. I promise not to take you through an entire half book of Licht­en­stein as Dan rec­om­mend­ed, but I’ll give a slight­ly more boiled down ver­sion of it. So this has all been sort of a… I’m going to do this rel­a­tive­ly quick­ly because this has been already men­tioned, but to recap the moti­va­tions here as I shall see it. So why would you go ahead and cre­ate a game over a stan­dard psy­cho­log­i­cal task? Well, we’ve already heard in lots of dif­fer­ent ways that we can expect increased par­tic­i­pant engage­ment and atten­tion. We think we’ll get bet­ter qual­i­ty data because peo­ple are more focused on the task and we think we’ll get low­er attri­tion because it’s more fun.

Nick:
And in fact, we saw it actu­al­ly just now in Niko’s talk that in his lon­gi­tu­di­nal study moti­va­tion actu­al­ly increased over time, which is a pret­ty fab result. Sec­ond­ly, we want to use what­ev­er the fic­tion we cre­ate to boot­strap the com­pre­hen­sion. And Diana men­tioned, we’re cre­at­ing these lit­tle worlds and that can real­ly help our par­tic­i­pants under­stand what they’re sup­posed to do. It also gives us, and I think Simone touched on this in the first talk, that it also allows us to, in some cas­es, dis­guise what we’re mea­sur­ing so the par­tic­i­pants don’t start to sec­ond guess us. So if there’s a par­tic­u­lar type of accu­ra­cy that we’re after, if we present the game in such a way that you sim­ply have to uncov­er all the clues, but we’re not real­ly too both­ered about how long it takes you then we can dis­guise the fact that that’s what we’re tru­ly measuring.

Nick:
And third­ly, we want this world and this expe­ri­ence to use ani­ma­tions and oth­er effects to kind of flow togeth­er and cre­ate a sort of seam­less expe­ri­ence. So how does the game builder enable all of this? So to set the scene, the game board is a new tool in Goril­la. So like the task builder or the ques­tion­naire builder, but built specif­i­cal­ly for cre­at­ing games. It con­tains the same core tri­al engine that we use across all of our tools. So all of the tim­ing, all of the response han­dling, all of the ran­dom­iza­tion is all in there. It con­tains a rich ani­ma­tion sys­tem that lets you cre­ate com­plex sequences of ani­ma­tion. And it also con­tains a par­ti­cle engine that lets you cre­ate a dynam­ic effects like fire and sparks and things like that. And this being Goril­la, you can do all of these in the UI with­out need­ing to write any code.

Nick:
So I’m going to show you a demo of some of these tools work­ing in a moment, but first I just want to set the tools and con­text. So how do you go about design­ing a game from start to fin­ish? We’ve seen some of these amaz­ing projects. What was the sort of a behind the scenes work­flow that we went through? Now I’m sure some of you watch­ing and think­ing, “Wow, these look amaz­ing. But, boy, this sounds real­ly hard, I don’t know where to start. I’m not real­ly a gamer. I don’t spend been hours on my PlaySta­tion.” Don’t wor­ry, we’re mak­ing small, sim­ple games research here, not the next block­buster Call of Duty. But what we can do is take a lot of the ideas, both from sci­ence that’s been done before, but also main­stream games and dis­till them down to some­thing very sim­ple that we can use in our research.

Nick:
I spent sev­er­al years in the gam­ing indus­try before I cre­at­ed Goril­la. I built loads of games and I am going to make all of you into game design­ers by the end of this talk. So how do you start? The first step is to design your fic­tion. So put sim­ply, we want to design, cre­ate the world that the play­er is in. Give it some kind of set­ting. We want to give the play­er some kind of agency with­in that world. And then we want to match the game that we’re cre­at­ing to the task that you’re try­ing to imple­ment. And this is the bit that I think Diana men­tioned, in her talk, where this is the part where you want to align the mechan­ics of your game with the goals that you’re set­ting. Now, this all sounds quite lofty and high lev­el, but you can boil this down to just four sentences.

Nick:
So here we go. You just fill in the blanks. You are in space. You are an astro­naut. You have to repair the space sta­tion. Watch out for aster­oids. Good luck. Sim­ple. Okay. The sec­ond step is to sto­ry­board your game out. This basi­cal­ly means just to draw out what hap­pens screen by screen. What does the play­er see at each junc­ture? This is just an exam­ple I made up. And now when you are com­ing up with your fic­tion, you prob­a­bly had some ideas in your head as to how this is going to look. So you prob­a­bly had some visions of what the play­er would see. So draw those and flesh it out from there. Now this design phase is super impor­tant. This is where you work out how the inter­ac­tion is going to work, what the play­er sees and this is where you’re going to get rid of 90% of the ideas that, love­ly, but it’s going to be too hard or too fiddly.

Nick:
Once you’ve got your sto­ry­board togeth­er, now you need to get your art­work. Now we’re not going to cre­ate any of the art our­selves. We’re going to find art­work that already exists and use that. So look at your sto­ry­boards, make a list of all the indi­vid­ual props that you drew. Every sin­gle, indi­vid­ual bit and then go shop­ping for images of them. Google Image search is the best place to start. I think you’re very quick­ly find some of the big stock image sites like Shut­ter­stock and oth­ers. They’ve got loads of great options. Simone’s talk ear­li­er, it showed a wealth of oth­er real­ly cool resources where you can get our roy­al­ty-free stuff. So do check out those as well. And so now if you have too many, you can go back to your sto­ry­boards and sim­pli­fy. It’s worth not­ing, you can do an awful lot with just one image.

Nick:
So as my lit­tle tree exam­ple, here, you can make a whole for­est with just one tree. You might want to scale up and down a bit, flip it hor­i­zon­tal­ly so you get into a mir­ror image of each oth­er change, make some brighter or dark­er and sud­den­ly you’ve got a very nice look­ing for­est and I’ve only got one tree. Trans­par­ent back­grounds are a must, so you can lay­er things up real­ly nice­ly. And again, these image sites will have loads of those. And one thing that I’ve been look­ing at recent­ly is this thing called Pho­to­pea, which is essen­tial­ly a but­ton-by-but­ton repli­ca­tion of Pho­to­shop in the brows­er. So if you don’t have access to image manip­u­la­tion soft­ware, there’s a good option for you there.

Nick:
Okay. So we’ve got a sto­ry­board, we’ve got our art. Now we can get stuck in and actu­al­ly build it. So this is when you go ahead and build it in the game builder. As we always say, stub out the big parts, come back lat­er and fine tune you all the details. And in par­tic­u­lar, this I think applies gen­er­al­ly, but in par­tic­u­lar with games, if some­thing’s not work­ing or it’s too hard to pull off, take a step back and see if there’s an eas­i­er way. Go back to the sto­ry­boards if you need to change a par­tic­u­lar sequence. Go back and look for dif­fer­ent pieces of art if you can’t get it to look right. This is often quite an organ­ic process.

Nick:
And then final­ly pilot­ing. Now obvi­ous­ly always going to pilot your task. I think with games in par­tic­u­lar, there are three big ques­tions that you want to ask your­self. First of all, do peo­ple under­stand what to do? What do you need to put into your instruc­tions and what is just sort of obvi­ous from the game around them? Is any of the art con­fus­ing or dis­tract­ing? Is there too much noise in the back­ground? Is it ambigu­ous as to whether some­thing on there is good or bad, that they should col­lect it or avoid it? Are there things they think they should be able to click on, but they can’t. Stuff like that. Now, and final­ly, is it fun? Now, obvi­ous­ly we’re doing all this for research pur­pos­es, but we want to be sure that it’s sat­is­fy­ing and engag­ing to play so that we get that moti­va­tion and com­pli­ance that we’re after.

Nick:
So I think you saw a lit­tle bit this ear­ly in Josh’s talk, actu­al­ly. So this was the card game that was in Josh’s pre­sen­ta­tion. I’m going to show you, in a bit of a more expand­ed detail as a show­case, how we went through that design process on that project and brought it to life. And I’m going to then show you me actu­al­ly build­ing it in the new tools. So quick recap. So you’ve got two options, A and B. They each worth a dif­fer­ent num­ber of points. Only one’s cor­rect and there’s a con­fed­er­ate who’s going to give you advice. And this advice may or may not be accu­rate. And what we’re inter­est­ed in is how long does it take for the… The con­fed­er­ate is going to start at accu­rate and then stop in accu­rate and what we’re inter­est­ed in is how long does it take before the per­son notices that their con­fed­er­ate is lying to them.

Nick:
So on our way we go. Design your fic­tion. So we set­tled on a casi­no. This one, obvi­ous­ly, had gam­bling ini­tial­ly and we tried some oth­er ideas out, but we dialed it back into a sort of casi­no. Some of the oth­er ideas we con­sid­ered, I think there’s one ver­sion where there were two jew­els, but one of them was guid­ed by a snake. We thought that sound­ed quite fun, but we were wor­ried that made incor­rect answers too salient and cor­rect ones not salient enough. And so peo­ple get too to wor­ried about avoid­ing the snake and not notic­ing in the jew­els. Where­as anoth­er ver­sion with two envelopes and you’re try­ing to work out or you’re try­ing to guess which one to take, but that seemed a bit devoid of con­text. Felt like a weird drug deal. So we sort of scrapped that one. So going for casi­no. So let’s go through the process.

Nick:
So you are in a casi­no, you are a gam­bler. You have to choose the cred­it card, watch out for the con­fed­er­ate’s advice. Good luck. All right, sto­ry­board­ing. So again, nice and sim­ple. The cards slide up onto the screen from below. We’ve got the two cards, red or blue. We’ve got the points super­im­posed on top. They want to slide into view and then a beat lat­er, we want the advice slide in from the side. So in this case say­ing, “Hey, I think you should take the blue one.” You then click on one of the cards. And you’re either going to go [inaudi­ble 00:09:06] going to flip over and show you either a star if you’re right and a cross if you’re wrong. And we’ll put some nice puffs of stars or a puff of smoke on there as well to make it look good.

Nick:
Okay, art. So here we go. We’re at 10 pieces of art we need for this. A nice sort of green back­ground. A sort of fel­ty card table. We want the two cards, red and blue. We want the oth­er side of the card, which the star or cross on them. And then for the con­fed­er­ate, we’re going to just do a nice lit­tle speech bub­ble and put a pic­ture of the card on top with a lit­tle tick to sort of make it look like a hint. And then those last two bits are the par­ti­cles that we’re going to spawn. So it’s going to be the star or the smoke. That’s all we need, 10 pictures.

Nick:
Okay. So you’ve already seen this, but just to recap, here’s what the final result looks like. Okay. So they slide up, you see it slide up from the side. That’s your advice say­ing, “Hey, you take the blue one.” So we go ahead. Oh, I find the tick on the blue one. It’s cor­rect, so we get the puffer stars. And we see the score go up in the cor­ner. This time he’s say­ing, “Take the red one.” So let’s go with it again. And ah, the swine, how dare he? Okay. That’s what we’re shoot­ing for. So I’m going to show you the new game builder now. So the first step in cre­at­ing this game is to lay out all these dif­fer­ent components.

Nick:
So here we go. This is a brand new project in the game builder. I haven’t done any­thing yet. I’ve got a sin­gle blank scene, which I’ve called puz­zle. And all I’ve done so far is upload those 10 images I showed you ear­li­er. So we always start out with this screen con­tain­er, which then dri­ves that screen. And the first thing we’re going to do is go ahead and add a sprite. A sprite is just a game word for an image on the screen that we can move about. Let’s go and choose the tex­ture. We’re going to choose our nice green felt tex­ture. And there’s our back­ground. You can see this all pop into place live in front of me. The next thing we’re going to do is add anoth­er thing, which is a con­tain­er. And the con­tain­er is just the thing that lets us group oth­er bits togeth­er. So the card, essen­tial­ly, is going to be the card pic­ture and then the text on top. So we want to be able to group this togeth­er. Let’s name these.

Nick:
So we remem­ber who they are. That’s the back­ground, that’s the card con­tain­er and let’s go ahead and add a sprite for our card. So there we go. Let’s call this card and then we just drag it into the card con­tain­er to stick it into that group. There it is. Okay. Now we can go ahead and choose the card that we want and there it is. And now we’re going ahead and add some ani­ma­tion to it. So this is in our new sys­tem where you cre­ate enti­ties with these cer­tain bits on it, but you can add oth­er com­po­nents on to add more behav­ior. So in this case, we want a sprite to show the card and we want them ani­mat­ed, so add some ani­ma­tion. So add that, open up my ani­ma­tion tool and I’m going to hit a clip called flip because it’s going to be the bit where it flips over and let’s go ahead and add our flip animation.

Nick:
So we add a flip ani­ma­tion here and we want this to start at zero and go to one. We want to flip all the way over at 400 mil­lisec­ond, let’s go with that. Now I’ve cre­at­ed all this. And what I can then do is go back into the tool, click on my play but­ton and see that ani­ma­tion hap­pened that I just cre­at­ed. Okay, not bad. What we want to do now, there’s a quite a nice trick we can do where at the same time it’s flip­ping, we want it to jump up and down and that’ll make a nice effect. So this is what the chan­nels that you do. You can have two [inaudi­ble 00:12:15] ani­ma­tion hap­pen­ing togeth­er in par­al­lel. So we’re going to keep our flip and then we’re going to have a sec­ond chan­nel that’s going to move the card up and down. And those two effects com­bined togeth­er will make it look like it’s doing this nice lit­tle flip over on the table in front of you.

Nick:
So we have one move that moves up, one move that moves it back down again. We’ll make all the times enough and you can see that visu­al­ly, all of our ani­ma­tion chan­nels are lin­ing up. Show you how they’re going to line up. And now we can go ahead and try that. And there we go. That’s thing we want. Now, obvi­ous­ly at the moment, it’s still blue on both sides. We’d need to see the oth­er side of the card. So what we’re actu­al­ly going to do is go back on our ani­ma­tion tool and we’re going to chop this flip in half. So we want­ed to flip halfway. Then we’ll add a spe­cial ani­ma­tion, which does­n’t actu­al­ly move any­thing, but it just changes the text that we’re look­ing at. So we’re going to flip it halfway. So it’s basi­cal­ly exact­ly point­ing up at us, change it to, I guess, card good, which is the one with a star on it. And then we’ll have it flip the rest of the way.

Nick:
And so that’s how we’re going to cre­ate our nice sort of flip effect. So we can set it up to be 200 mil­lisec­onds the oth­er side. And then we can go back into our tool and see that work­ing. So this is all hap­pen­ing in engine. Your whole task is run­ning in that cen­tral pan­el. You don’t have to keep pre­view­ing and then jump­ing back to the tool. This is all hap­pen­ing live in engine. So we can try that now. And oh, some­thing’s not quite right. No prob­lem. Back into ani­ma­tion tool. I can go back in here. That bit did­n’t save prop­er­ly. Let’s set that back to where it should be and then I can close that and play it again. So a real­ly, real­ly nice tight loop between exper­i­ment­ing with things. Let’s set it back to the begin­ning. It starts out blue. We can then play off the ani­ma­tion and then we see the star on the oth­er side.

Nick:
[inaudi­ble 00:13:48]. That’s how we can com­pos­ite all these things. The last thing we’re going to want to do is add our puff of stars at the end. So there’s anoth­er ani­ma­tion here, again, it does­n’t move any­thing. It just spawns some­thing. So we’re going to go ahead and spawn some stars at the end of this ani­ma­tion, I’ve already cre­at­ed the stars’ par­ti­cle effect, so we can just type the name in there. And now we can refresh our scene, set it all back to the begin­ning and see the whole thing hap­pen­ing alto­geth­er. And this is all hap­pen­ing dynam­i­cal­ly in engine. What you see here is exact­ly what your par­tic­i­pan­t’s going to see, is all the same ele­ments running.

Nick:
Okay. So that’s how you can com­pose all the dif­fer­ent bits of your scene. So the next thing is, how do we stitch all of this togeth­er? So I’m going to fast for­ward a bit here. So I’ve done both cards now. So it’s all the same stuff you’ve seen before. They’ve now got a text bit on the top, which shows the num­bers with the score in the cor­ner and then the con­fed­er­ate is done with one sprite to be the speech bub­ble and anoth­er sprite to be the advice. So it’s all done exact­ly the same way.

Nick:
So the first thing you want to do is make the var­i­ous ele­ments ani­mate onto the screen. So in the same way that we did the move on the card, make it jump up and down, I’ve got a move ani­ma­tion called a pair, which makes the cards slide up. We’ve got this spe­cial prop­er­ty called play on start, which means that when we start the screen, we’re going to play these ani­ma­tions imme­di­ate­ly. So let’s set these onto the con­fed­er­ate and the card con­tain­er and then we need to move our card con­tain­er off the screen. So it starts off screen and then the very first thing it does is ani­mate on. If I go ahead and refresh this, we then see that that slides on. And then the con­fed­er­ate comes in. This is all using those same move ani­ma­tions. The con­fed­er­ate’s got a lit­tle delay on there so that it comes in a bit after the cards. So the next thing we need to do is when we first set it up, we just set the card just to be the blue card the whole time.

Nick:
What we actu­al­ly want is to define which card goes where and how many points are on each side in our spread­sheet so that we can design all of our tri­als out of our account, the bal­anc­ing and set which answer is going to be the left or the right. So what we do here is we go back to our card left and instead of say­ing, oh, it’s always going to be the blue card all you want to do is click this lit­tle link but­ton and say, look for a spread­sheet col­umn called card left and use that. Sure, if you can’t find it, default to card blue, but we want it to be what­ev­er’s in the spread­sheet. We can do the same for the points. We’re going to bind that to anoth­er col­umn that I set up called points left. And we see when I bind this it snaps to being what is cur­rent­ly in that first row of the spread­sheet. So we can actu­al­ly pre­view each row of our spread­sheet as we build.

Nick:
So that’s that. Now the next thing we need to do is set up how we’re going to respond to this. So you respond to these by click­ing on them. So I’m going to add a click response to my card. Now this is the one on the left, so the response I’m just going to call this one left. And in my spread­sheet, I’ve set up where the left or right is the right answer. And I’m going to bind the score that you get for that response to the points left col­umn. The last bit we then need to do on the screen lev­el is say, okay, when we get the response, is it right or not. So here we can add a score to the screen and say, okay, the cor­rect answer is what­ev­er is in the answer col­umn in my spread­sheets. So if you use the task builder, these kinds of mechan­ics are very famil­iar to you, but we’re try­ing to make the tools much more con­tent aware at this time.

Nick:
The final bit is that when we do final­ly respond, we want to then play one of our ani­ma­tions. So there’s anoth­er com­po­nent here that does ani­mate on response accu­ra­cy. And we can then say, well, if we’re cor­rect, play this one. If we’re incor­rect, play this oth­er one. That flip ani­ma­tion I showed you, I’ve changed that to be called cor­rect. And I made an incor­rect one that shows the cross and does the smoke. Now we built all of this. If we reset it all, we can see the whole thing in and out and when we tap on the blue card, we can see your ani­ma­tion play and the stars play out. So in the same way, we can actu­al­ly com­pos­ite it our whole task. We could build the whole thing here. The whole flow com­plete­ly in engine run­ning live in the edi­tor. And we think all of this togeth­er, it’s going to make games super easy to put togeth­er, real­ly nice and fast iter­ate on.

Nick:
And it’s going to enable some real­ly excit­ing research in the com­ing months. So that’s pret­ty much every­thing I’ve got for time so far. I’ve one last lit­tle sneaky thing I want to show you, which is mul­ti­play­er. We’ve been work­ing on Goril­la Mul­ti­play­er for a while. It’s close to com­ple­tion and we’re real­ly excit­ed by where this is going. It’s going to be work­ing across mul­ti­ple tools. So it would work in the game builder that I just showed you, it’ll also work in the new task builder we’re build­ing. I’m not entire­ly sure what a mul­ti­play­er ques­tion­naire would look like, but in the­o­ry, that would be pos­si­ble to. Again, it’s ful­ly inte­grat­ed into UI. There’s no cod­ing required and we’re look­ing at mul­ti­ple dif­fer­ent modes of inter­ac­tions. So turn-based, real-time chat, all this kind of thing. So I’ve got a very, very sim­ple demo of the Ulti­ma­tum game, which I’m sure you’re famil­iar with, which I’m going to show you.

Nick:
And I’ll give you a very, very quick insight into how it’s put togeth­er. So here we go. I’ve got, this is the same task. I’ve got it in two sep­a­rate browsers. This is going to have to be how you do pre­view mul­ti­play­er stuff. So I’ve got Chrome on left and Edge on the right. They’re both look­ing at the same page in the same task. So let’s go ahead and start a pre­view on both of them and what you’re able to do with the mul­ti­play­er games is you’ll be able to cre­ate a room dynam­i­cal­ly and then paste it into the oth­er brows­er so you can link your two brows­er win­dows togeth­er. This is for pre­view­ing in the exper­i­ment. This will be done for you with lob­bies and things, but this is how we do it just when you’re pre­view­ing. So those two will now find each oth­er and the task will start simul­ta­ne­ous­ly. Now you see, they’re both see­ing the same thing, but only the one on the left has got this next but­ton. because they’re the one that’s in con­trol of the screen.

Nick:
So [inaudi­ble 00:19:04] instruc­tions of the Ulti­ma­tum game. Say hit next and there we are, see the offer. Now we can see some of the ani­ma­tions are the same, but some of them are dif­fer­ent. The one on the left has got the options of how much to offer and the one of the right is just wait­ing. So in the one on the left then choos­es what they’re going to offer, the toll pass­es to the play­er on the right. So they then offer that and they choose whether to refuse or accept it. They go ahead and do that. And then we go again, but this time it’s the oth­er way round. The play­er on the right is the one mak­ing the offer and the play­er on the left is wait­ing. Say go ahead and do that. And then con­trol is going to pass back to the play­er on the right. And they get to refuse to accept as usu­al. Okay, that’s that.

Nick:
Let’s go back into the edi­tor and see very quick­ly how this is put togeth­er. So the first step for mul­ti­play­er, which is real­ly impor­tant, is you have to go to the mul­ti­play­er tab and turn it on. It’s the kind of tun­ing I like. And then when we go to our dis­plays, there’s basi­cal­ly one extra bit that we could do. Because we said we want two play­ers, we get these extra two columns on our spread­sheet, Play­er A and Play­er B. And then when we go to dis­plays, we lay out one of our [inaudi­ble 00:20:10] user, but there’s a spe­cial extra com­po­nent we can add called the mul­ti­play­er com­po­nent. And all that does, is it restricts that ele­ment to being for one play­er or the oth­er. So in this case, the response options there for Play­er A and the oth­er play­er’s work­ing off of it is for Play­er B. When we go to the sec­ond screen, it’s the same idea, but the oth­er way round. So now the response options are there for Play­er B and the wait­ing text is just there for Play­er A.

Nick:
So using these real­ly, real­ly, real­ly sim­ple mechan­ics, you’re able to con­trol who sees what in any one screen. Now, when we first paired our play­ers togeth­er and indeed when they’re paired togeth­er in a lob­by, they will have a canon­i­cal order between them. One of them is his play­er one, and one of them is play­er two. What those Play­er A and Play­er B bit allows you to do in your spread­sheet is con­trol of what­ev­er order the play­ers exist­ed in the world. In the first tri­al I want, okay, who­ev­er the first play­er is their Play­er A first. And who­ev­er the sec­ond play­er is they get to be Play­er B, but in the sec­ond tri­al in lev­el row three here, I want it to be the oth­er way round. So the sec­ond play­er gets to be Play­er A and the first play­er gets to be Play­er B. That’s how you can impose a turn struc­ture and make sure that all of your play­ers who’ve been giv­en oppor­tu­ni­ty through all the dif­fer­ent actions. And you’ve got all the con­trol there in your spreadsheet.

Nick:
That is every­thing from me. We will be run­ning beta pro­grams and ear­ly access teams for all of these tools. So if you’re inter­state go to Gorilla.sc/comingsoon, sign with the main­te­nance and we’ll be in touch when we’ve got some­thing to show you. And that’s every­thing from me.

Jo:
Thank you so much, Nick. That was extra­or­di­nary see­ing how quick­ly you put that game togeth­er. I remem­ber when you first built the gam­bling game for [Josh Bal­sters 00:21:48], it took about a day, if not, two days to build that gam­ing code. And you’ve just built most of that game in half an hour. Is that about right?

Nick:
Pret­ty much. I think that’s what we’ve got it down to you now. Yeah. Yes. And I think too so much of it is… So as we find so much of these ele­ments, it’s the same thing that you want to do again and again and just by mov­ing that func­tion­al­i­ty into the tool­ing, it makes it super easy to exper­i­ment with these things, fine tune all those adjust­ments and hav­ing that live, in engine, visu­al lay­outs, I find to be extreme­ly pow­er­ful when I’m build­ing any­thing. I’m a pro­gram­mer. I’ve been pro­gram­ming for decades and I still much pre­fer it to have every­thing visu­al­ly there in a tool in front of me that I can then edit with because I think that feed­back loop from mak­ing a change to see­ing the effect that it has, has such a mas­sive impact on how quick­ly you can work. So that’s what we’ve real­ly tried to tight­en with this new gen­er­a­tion of tools.

Jo:
Okay. A cou­ple of ques­tions in the chat for you. So [Lizzie Buchanan 00:22:49] is ask­ing, is there a way to make the games adap­tive? Is that going to be built into the game builder?

Nick:
Yeah. So adap­tiv­i­ty is some­thing that we… So there’s a few dif­fer­ent ways of doing this and this is actu­al­ly going to be core across all of the tools that we’re build­ing. So yes, absolute­ly there’s going to be a par­tic­u­lar ways of doing adap­tiv­i­ty. One of them is either by, I showed you the bind­ing to the spread­sheet, but you can also bind cer­tain prop­er­ties to embed­ded data, which is dynam­ic data that is saved on a per-par­tic­i­pant basis. So if you have, and this is how I think Nico’s games work is that the time that you had to react was a piece of embed­ded data that was mod­i­fied depend­ing on how quick­ly you did it. So if you did real­ly well, that we would save that time that you had to get slight­ly small­er. And then the fol­low­ing tri­al basi­cal­ly, you read from that val­ue to then set itself up.

Nick:
So all the same thing would work here instead of choos­ing spread­sheet, you choose embed­ded data. The oth­er thing we’re putting in, which is anoth­er way of approach­ing dif­fi­cul­ty, [inaudi­ble 00:23:49] and adap­tiv­i­ty is that I think most peo­ple famil­iar with the spread­sheet that dri­ves your tri­als, what we’re try­ing to make real­ly seam­less is that you could actu­al­ly have mul­ti­ple spread­sheets. And so you could have three spread­sheets with easy, medi­um, hard and then have rules that essen­tial­ly mean that when you reach some per­for­mance [inaudi­ble 00:24:05], we essen­tial­ly hop up a spread­sheet to your medi­um dif­fi­cul­ty tri­als. So that’d be anoth­er way of doing slight­ly broad­er adap­tiv­i­ty where you have sev­er­al dif­fer­ent dif­fi­cult lev­els that you want to intro­duce to peo­ple. And even define all of those real­ly easy in your spread­sheet and have a sim­ple rule of way of how you move between them. So those are some of the ways that we’re look­ing to bring adap­tiv­i­ty both to the game builder and to the task builder, as that all comes together.

Jo:
And then anoth­er ques­tion from the Q&A is do you envis­age your mul­ti­pli­er being extend­able to more than two play­ers? And I mean, we saw just 10 min­utes ago, Dan Richard­son show­ing in his exper­i­ments, which have dozens of co-present par­tic­i­pants. So Dan, maybe you can, if you’re still here, you can turn your video back on. If peo­ple want to do, there’s two dif­fer­ent ones, real-time inter­ac­tion that could be done with the hive? That might be that Dan’s gone.

Speak­er 1:
I think Dan’s gone, Jo.

Jo:
Okay. Or Nick?

Nick:
Yeah. So I think that’s, yeah. So there’s a few dif­fer­ent ways that we’re look­ing at explor­ing this. One of them is that the demo I showed with the Ulti­ma­tum game is obvi­ous­ly for, in this case, to be a game, but for a fixed num­ber of play­ers. And I think there’s a large range of these tasks that peo­ple are inter­est­ed in, which are where you have to have a fixed num­ber of peo­ple. I think there’s anoth­er whole chart of games, like Dan’s ones, where actu­al­ly you want to play with a whole group of peo­ple and peo­ple don’t nec­es­sar­i­ly have assigned roles. They’re all doing some­thing togeth­er. And I think where that real­ly has an impact on how you go about build­ing things is that if you’re doing some­thing that has very spe­cif­ic roles, needs a very fixed num­ber of play­ers, then you’re very, very sen­si­tive to peo­ple drop­ping out.

Nick:
In the Ulti­ma­tum game, if one of the play­ers just dis­ap­pears. You’re basi­cal­ly stuffed. Where­as in one of Dan’s pre­sen­ta­tions, if one audi­ence mem­ber goes away, it’s fine. You can car­ry on. So I think what we’re look­ing to do is give you some fair­ly spe­cif­ic options. This is either a game that real­ly needs two peo­ple and it does­n’t work any oth­er way, or, yeah, this is a tool for a group of whole bunch of peo­ple. And those are some of the configurations/options that you’d be able to set in that mul­ti­play­er tab that I showed you. So that’s how we’re envis­ag­ing that work­ing. And I think, like I say, the real crux thing, bor­ing­ly, is how do you han­dle dropouts. And I think you’d want very, very dif­fer­ent rules depend­ing on the kind of mode of game that you’re building.

Jo:
Yeah. Cer­tain­ly, with online stud­ies, some peo­ple report dropout rates as high as 10%. One in 10 peo­ple are drop­ping out and that kills your exper­i­ments. As soon as you’ve got a game with 10 peo­ple, then you just can’t run your exper­i­ments any­more because it will always fail at one way or anoth­er. So, yeah, that’s real­ly inter­est­ing. We’re going to have to stop there, but if you’re in the room and you were there for the games pre­sen­ta­tion and game builder, could you give some feed­back to Nick in the chat? What do you think about game builder? What’s that made you think about for your research?

 

Get on the Waitlist

BeOnline is the conference to learn all about online behavioral research. It's the ideal place to discover the challenges and benefits of online research and to learn from pioneers. If that sounds interesting to you, then click the button below and sign up for our newsletter. You will be the first to know when we release new content and open applications for BeOnline 2022.

With thanks to our sponsors!

Goril­la Game Builder Demo