Boardgame Development

Come2Play multiplayer API

noreply@blogger.com (Ema) — Sun, 03 Jan 2010 13:17:00 +0000

After the development of my first two games Tokyo Train and Haunted house I am interested in development of a multiplayer game. For this reason I started to study the Come2Play API.

Links to the project: http://www.come2play.com/developer.asp

The goal of the tutorial is to show how to build a Tic Tac Toe game using these API.

The project can be downloaded from www.mindthemove.com/blog/projects/TicTacToeC2P.zip

These API are basically used to have a communication between one or more clients (in Flash AS3) and the Come2Play server to allow a multiplayer game.

There are 2 type of functions: operations and callbacks.

I am going to use two classes.

- MainTTTC2P that extends ClientGameAPI. This is the main class the acts as controller

- TTTC2PViewer that is the viewer class. In some way, because the game is simple and it is for tutorial purpose, this will work as model as well.

I am not using an event driven approach as in the tutorials from come2play project because I found this confusing the main focus that is to learn how to use the basic API by come2play.

For any reference to the API this is the link: http://come2play.com/API_inner.asp?f=1&newsid=357

Let’s start from MainTTTC2P class.

This class is created in the first frame of the FLA file:

var game:MainTTTC2P = new MainTTTC2P(this)

The class is declared as:

public class MainTTTC2P extends ClientGameAPI

In the constructor I am going to get the calling movieclip and calling the super constructor (the constructor of the basic class ClientGameAPI.

Moreover I pass this movieclip to my viewer class that is created here.

The call to doRegisterOnServer is the way for the client to enter the lobby for this game. The call to this function should be done using AS3_vs_AS2.waitForStage function.

public function MainTTTC2P(stageMovieClip:MovieClip)

{

super(stageMovieClip);

theViewer = new TTTC2PViewer (stageMovieClip);

keyMove= 0;

AS3_vs_As2.waitForStage(this,constructGame);

}// constructor

private function constructGame(){

doRegisterOnServer();//registers your game on the server

}

The first callback function that is called is gotCustomInfo. You need to remember that the callback functions inherited by the basic class ClientGameAPI must be declared as “override”.

override public function gotCustomInfo (infoEntries:Array):void

{

this.myUserId = T.custom(CUSTOM_INFO_KEY_myUserId,null) as int;

}

On this function you get back some custom information. Calling the helper class T you can get some information back from the server. One simple example is to use the constant string “CUSTOM_INFO_KEY_myUserId” to get your user id. Because this is a important information it’s useful to get this stored.

Remember that each player will receive from the server a unique id to be identified. It’s critical for the client flash game to know the user id. In some how this is telling the program who is it.

The second callback function the client will receive is gotMatchStarted. This is triggered as soon as the game is started.

In this function the most important information is the list of the user ids for all the players. Again this is critical to know so this is stored in an internal variable.

I found useful as well store immediately where in this array the client is. This is done using the already stored information about my id.

Let’s have an example. If myUserId =41 and the array received is allPlayerIds=[41,42], this client has index 0 in the array while my opponent will have index 1. Therefore myUserIndex=0; This is another way to know who the client is, in terms of index in the array of all players.

This is the time where to start the new board using theViewer.startNewGame. The viewer class should also know what is myUserIndex, therefore I am going to store this on that class.

override public function gotMatchStarted (allPlayerIds:Array/*int*/, finishedPlayerIds:Array/*int*/, serverEntries:Array/*ServerEntry*/):void

{

this.allPlayerIds = allPlayerIds;

this.myUserIndex = allPlayerIds.indexOf(myUserId);

theViewer.startNewGame(this.myUserIndex);

addEventListener(Event.ENTER_FRAME,timerHandler);

setupFirstPlayer();

}

In this function I also start a loop using the ENTER_FRAME event. This is a function that will be called periodically with the fps set up in the FLA. This is a way to check if the viewer class has set up any new moves. This is an alternative to the event driven solution found in the come2play tutorials.

We will discuss this later.

The last function is used to define the first player. Because the game is in turns, only one player can make a move. Therefore this information must be set up.

A simple way is to define as starting player the first player in the index of all user ids. This information is stored in the currentturnIndexPlayer in the viewer class.

You need to think to the 2 clients that received the same array of the player ids (allPlayerIds). Therefore both clients have the user ids in order in this array: the first element of the array (allPlayerIds[0]) will be the same for both clients.

The serve must be notified by all clients about the current player. To do this each client must call the doAllSetTurn function. This is the way the server can be sure that all clients agreed to have one current player.

private function setupFirstPlayer() {

var firstPlayerIndex: int = 0;

theViewer.currentturnIndexPlayer = firstPlayerIndex;

doAllSetTurn(allPlayerIds[firstPlayerIndex],-1);

}

It is time now to see the viewer class.

In the constructor the movieclip is stored.

Then the board is created. I found useful to have a linear array of 9 elements instead of a double array 3x3. The index of the linear array will be:

0 1 2

3 4 5

6 7 8

In order to display an empty square or a square filled with the “x” or with the “o” I have created a Movie Clip symbol called Square and I have exported for Actionscript.

In the frame=1 there is an empty square. In frame=2 there is the “x”, while in frame=3 there is the “o”.

To create a new symbol it’s just enough to create a new instance of the class Square:

var squareNew = new Square();

The I set up the Square movieclip in the right position and to the right frame (squareNew.gotoAndStop(EMPTYFRAME);). Then I add this new symbol to the stage and to an arrayOfSquares that I use to keep track of the clicked squares.

To be noted I have used a dynamic property called “myBoardIndex” to store the index of the movie clip in the board. For example the first movie clip (on the left top corner) will have myBoardIndex=0. The one in the center of the board will have myBoardIndex=4, etc.

public function TTTC2PViewer (stageMovieClip:MovieClip)

{

this.stageMovieClip = stageMovieClip;

arrayOfSquares = new Array(9);

for(i=0;i<9;i++){

var squareNew = new Square();

squareNew.x=SQUAREPOSITION[i].x;

squareNew.y=SQUAREPOSITION[i].y;

squareNew.myBoardIndex= i;

squareNew.gotoAndStop(EMPTYFRAME);

squareNew.addEventListener(MouseEvent.MOUSE_DOWN, clickHandler);

arrayOfSquares[i] = squareNew;

stageMovieClip.addChild(squareNew);

squareClickedIndex = NOCLICKEDSQUARE;

}

}// constructor

Each movieclip is registered with a MOUSE_DOWN event. The called function is clickHandler.

public function clickHandler(event:MouseEvent){

if (!isMyTurn()) return;

var clicked:Square = event.target as Square;

if ((arrayOfSquares[clicked.myBoardIndex].currentFrame)==EMPTYFRAME){

setSquare(myUserIndex,clicked.myBoardIndex);

squareClickedIndex = clicked.myBoardIndex;

}

This function is immediately exit if it is not the turn of this client. This is done comparing the myUserIndex value with the currentturnIndexPlayer value.

public function isMyTurn():Boolean{

return (this.currentturnIndexPlayer==this.myUserIndex);

}

Then the target of the event is used to know which square was clicked. Only if the square is empty (that is checked using the currentFrame of the MovieClip then the square is changed calling the function setSquare (this function will be called to set the square also to set an opponent move). This is done simply using the procedure gotoAndStop to the playerIndex value (added by 2 because the first symbol “x” is to the frame 2 as you can see in the timeline for Square).

public function setSquare(playerIndex:int, squareIndex:int){

arrayOfSquares[squareIndex].gotoAndStop(playerIndex+OFFSETFIRSTSYMBOL);

}

The last action on the clickHandler function is to set the variable squareClickedIndex to the index of the board (value from 0 to 8). Normally this variable is set to -1 to indicate that no click is yet made. As soon as this variable is set to a different value, this indicates the place in the board where the click was performed.

This is the signal that the main class will check in the polling cycle inside the timerHandler. Actually there are 2 condition must be fulfilled: must be my turn and the theViewer.squareClickedIndex must be different than -1 (=theViewer.NOCLICKEDSQUARE).

public function timerHandler(event:Event):void {

if ( theViewer.isMyTurn() && (theViewer.squareClickedIndex!=theViewer.NOCLICKEDSQUARE) )

sendMoveToServer();

}

If so the sendMoveToServer is called. The main purpose of this function is to send to the server the message that a move was made by the current player using the function doStoreState.

public function sendMoveToServer(){

var myKey = this.myUserId+"_"+this.keyMove;

var userEntry:UserEntry = UserEntry.create(myKey,theViewer.squareClickedIndex,false);

var userEntries:Array = new Array();

userEntries.push(userEntry);

doStoreState(userEntries);

theViewer.squareClickedIndex = theViewer.NOCLICKEDSQUARE;

keyMove++;

}

The doStoreState function needs only one parameter that must be an Array of type UserEntry. Actually the array can contain only one element.

To create a variable of type UserEntry the static function create is used:

UserEntry.create(theKey,theValue,isSecret) where:

- theKey must be unique if you want to store a new message. If you use a key already present this will override the previous one.

- theValue is the actual message that you want to send

- isSecret indicates if the other clients will be allowed to see the message sent

Both theKey and theValue can be any Object. There are different way to choose how to create the key and the value. My choise was the following:

For the key I created a String of this type “myUserId_keyMove” where keyMove is incremented at each move (at each click). So for example with player with id=41 the first key sent will be “41_0”, the second “41_1” etc... While for the opponent (with id=42 for example) will be “42_0”, “42_1”, etc…

The value will be simply the index of the board where the click was performed. This is the critical information to send to the opponent so that the opponent can display the square with the right symbol.

After sending the message to the server , the incremental keyMove variable is updated. And the theViewer.squareClickedIndex variable is set to -1 so that next time (and when it will be again my turn) it will be possible to click again.

Now that the message is sent let’s suppose to move to the opponent client. This client must receive the message and display the opponent’s symbol on the board on the right position (board index).

This is done in the gotStateChanged function where the server sends to the client the serverEntries array containing the moves in terms of ServerEntry elements.

Because we sent only 1 message, only the first element serverEntries[0] will be used.

In this variable the property storedByUserId is the id of the client who sent this message. Because the client who actually sent the message is also receiving this information, we need to check if the message was sent by the client itself. Only if this was sent by the opponent the function theViewer.setSquare is called to display the opponent symbol.

While the client who sent the message is not doing this simply because we already set this on the clickHandler function. That was a choice. An alternative would have been to set the symbol for the client itself after he received back the gotStateChange event from the server.

override public function gotStateChanged(serverEntries:Array):void

{

var serverEntry:ServerEntry = serverEntries[0];

if (serverEntry.storedByUserId != this.myUserId){ theViewer.setSquare(allPlayerIds.indexOf(serverEntry.storedByUserId),serverEntry.value); }

setNextPlayerTurn();

// CHECK if the game is over

var winnerIndex:int = theViewer.winnerPlayer();

if (winnerIndex>-1) {

setupWinner(winnerIndex);

}

In any case the setNextPlayerTurn is called. First thing the currentIndexPlayer is updated with the next player. This is simply done adding 1 and set back to 0 the index in case it’s greater than the allPlayerIds array length.

private function setNextPlayerTurn(){

theViewer.currentturnIndexPlayer++;

if (theViewer.currentturnIndexPlayer >= allPlayerIds.length)

theViewer.currentturnIndexPlayer = 0;

doAllSetTurn(allPlayerIds[theViewer.currentturnIndexPlayer],-1);

}

Then the doAllSetTurn is sent to the server with the id of the new active player. It is also possible to set a maximum number of millisecond for the move (or -1 to ignore this).

This soAllSetTurn function must be called by all the clients to have any effect. And this is the reason why the gotStateChange function this is called from both clients. This is also useful to have both clients updated in terms of current player index.

The last action in the gotStateChange is to check if the game is over. If so the setupWinner function is called.

The main purpose of this function is to call the doAllEndMatch function to inform the server the game is ended. Again, as all the doAll…. functions, this must be called by all the players.

private function setupWinner(winnerIndex:int){

var finishedPlayers:Array = new Array();

var playerMatchOver:PlayerMatchOver;

for (var i:int=0; i

if ( i==winnerIndex ){

playerMatchOver= PlayerMatchOver.create(allPlayerIds[i],100,100);

}else{

playerMatchOver= PlayerMatchOver.create(allPlayerIds[i],0,0);

}

finishedPlayers.push(playerMatchOver);

}

doAllEndMatch(finishedPlayers);

}

The parameter sent to the server must be an array of type PlayerMatchOver. Each element must contain the id of all players that have finished the game. In our case both players end the game simultaneously.

Therefore there is a loop in the allPlayeIds array to create a variable of type PlayerMatchOver. Again the static method “create” is used with 3 parameters:

- userId

- theScore. Set to 100 if the player wins and 0 if the player looses.

- thePot. The pot is used if the game allows players to bet during the game. In our case this will be 100% if the player wins, and 0% if the player looses.

noreply@blogger.com (Ema) — Fri, 04 Apr 2008 14:39:00 +0000

Bruno Faidutti wrote an editorial on his website about the language in which he wrote the rules of his prototypes.
Basically he says that "I’ve even found out that even French publishers prefer English language prototypes, since they make easier to playtest the game with foreign publishers".
This is certainly a good point. But I think that there is another good reason: it easier to involve foreign playtesters.
I like to have the chance to send mine prototypes to a complete different gaming group, possibly in different country.
I remember that for Oltre Mare in the first version I sent to Henning Kropke in Germay. He planned to visit Mik Svellov in Copenahagen for some gaming sessions. So the proto of Oltre Mare received some playtests in the north of Europe before to be released. I had also a good preview from Mik in his website brettboard.dk before the fair!

At the moment I have a prototype who was sent to the Gathering of Friends and hopefully will be playtested. Moreover I will attendee the Bruno Faidutti's Ludophatic Gathering during the next weekend. In both case an english rule is a good point.

I have to admit, anyway, that the language in which I write new ideas that come out from playtesting sessions are just in Italian. I found easier to formilize these ideas in my native language. At least for the moment.
It maybe also depends of the fact that I usually share these ideas with my gaming group members that are Italian.

Emanuele

Ideas strike back

noreply@blogger.com (Ema) — Fri, 04 Apr 2008 14:02:00 +0000

Some game ideas come backs, sometimes.

It's the case of a game I designed more than 2 years ago. I presented to a big publisher during the Essen fair. But it was reject in the same meeting during the explanation!
"It's a good theme, I like it. But there is too much components, and I do not like ..." (follows some explanations).
Well, things that happens!

I had a similar experience with another publisher who first said: "This game seems too similar to one we already got in our program. Please verify and let me know!". In this occasion at least I got a new game for my collection. I really never played that game, and it really was not so similar! Well, both games use an auction mechanism and have cards. But there are many others out there that are similar in this way! :-)
Almost one year later the same publisher decided to give it a try, after my assurance the game was not so similar! And after some tests they decided they like it and they will produce!

A very happy ending. But for the "too much components" prototype it was not the same!...
... Until few weeks ago when another publisher asked me if I have ready a game with some particular characteristics (I am not authorized to give any details for the moment)... They were not worried about the components, because in very few time of playtest they decide it was a good game...

Well, I have to admit that I worked hard during the Easter weekend (I forced my father to play it just after the Easter lunch :-P
I changed enough things to have a really better game... with the same components anyway! I was much more soddisfy than before, so in this case time elapsed without thinking of it was a good point! And let me have a more exciting game that hopefully will be published.

There is another prototype, for which I had very good feedback from my playtesters. But it was rejected from 3 different publishers... I think this project is almost 5 years old.
I have worked a lot to find a good solution to problems arose.
I think some months ago I found the real problem. My opinion is that, during the years, I changed several things without focusing on the real problem.
That problem give only one way to play for the best strategy removing a lot of fun to a quite complex game!
Now that I have, hopefully, found the right issue, I'm confident I can find the solution to have a nice game!

Sometime ideas come back... sometime we only need time...

Emanuele

Theme and Mechanisms

noreply@blogger.com (Ema) — Wed, 05 Mar 2008 17:08:00 +0000

This post is a kind of reply to the very interesting post by Jonathan Degann "What is this boardgame about" I suggest to read here.
Several times we consider Eurogames to have a theme pasted up to a set of mechanisms. It is so easy to change the theme because what a game is about, in my opinion, is the set of rules defined for it.
One friend of mine called the physic class, during the highschool period, as "the most detailed role play game".
So we can see Tychoon theme completely changed into El Capitan. Or Ra changed in Razzia (by the way I found the Mafia theme that suites better than the egyptian one).
I compare Amytis to Amune-Re (just to stay with the same authors and similar themes :-) because in order to win you need to have a look to all the aspects you try to manage. In Amyitis you have several ways to score (even if it is essential to plant and to irrigate as Cyril said) and several things to do in order to score! I am not sure about the so called "star structure", but it is not the focus of the design in my opinion and it was introduced by Cyril to reply to the BGG post.
In Amun-Re you also have several ways to score.. "too much" someone can say, and who said that it doesn't matter what you do because you score for everything, I supposed have not clear the game (or miserably loose :-).
But I have to admit that in Amun-Re is easier to play than Amytis because it is simply more easy to have a one to one match for a rule to the theme.
In Amun-Re you bid to conquer territories. You buy bricks for building pyramids and you blind-bid for offer to the god. It is probably more "linear" than "star", but it surely easier to grab when you learn the game.
Maybe in Amytis there is only a problem with the theme and how it doesn't find an immediatly correpond to the rules. It is not so easy to remember that the carovan is used for the plantion. Why do I need to move the carovan in order to have a new platation? Even because with the carovan you can also gain one of the special cards as building the Babylon gate. So what have in common to build the gate with the creation of a platation portion of the garden? Apparently nothing, and most of all has no thematic approach to the carovan!
In my opinion these missed associations between rules and theme let some players find diffucult to grab the rules.
You can find the same easy approach to the theme association to the rule to other mentioned (in the Jonathan article) games such as Puerto Rico and Caylus.
In my Hermagor some players were disappointed to the fact that the fantasy theme was not well suited to the game mechanism. They probaly expected sheep and wood instead of egg's dragon and relic.
When I am asked about "first theme or first mechanism" during the design process, I surely reply with "first mechanism". So I start from one or more mechanisms I would like to have in my new game.
For instance in Il Principe I wanted to use the roles (as in Puerto Rico), while the Building Cards selection mechanism was inspired by King Breakfast.
But when I develop a game I try to think about the theme as soon as possible. Sometime I also change the theme not only rules during the playtesting.
Thinking to the theme helps me to develop the rules. In fact if I have to add or remove some rules, or if I need to round out some rule mechanisms or some score systems the theme helps me a lot. And this process gives a more chance to have a good connection between rules and the theme itself.

Emanuele

Solutions not Pathces

noreply@blogger.com (Ema) — Fri, 22 Feb 2008 16:47:00 +0000

Last evening I playtested one prototype of mine with my friend Stefano.
It is a game from 2 to 4 players, so we tried a 2 player game. It was the second playtest (the first one was in 4).

I'm not going to describe the game here, but I would like to point out about an aspect of the game that was not working and how I want to try to solve it.
The problem is about the mechanism of the combat: it is the first time I'm working on a game where it is possible to have a fight between players.
So I am a little bit worried about, even because fighting is not excatly a typical german game mechanism...

During the playtest simply the combat doesn't occur. The main reason was that it was not neccessary to figth because we had enough space where to expand our villages whithout moving in conflict. Maybe the board was too big for 2 players, so that it could be resolved by a fine tuning of the dimension. Or maybe both our nature let us finding alternative strategy other than a fight.

Because the combat did not occur we also avoid to choose the "warrior cards" during all the game. Warrior cards were an option during a specific phase of the game where a player is prompted to choose between different actions. One of these actions is to "hire" warriors and it was never used. From a design point of view this phase were weaker because of the reduced number of choices.

As Knizia wrote in an interesting interview reported into the book "Rule of play" when something goes wrong during a playtest, you have to search for a good solution, not for a patch. He was talking about the playtest of his "The Lord of the Ring" collaborative game and how he found good solutions to resolve several problems all in once instead of applying a patch for each issue.

In my situation I had 2 main problems:
- the combat never occured
- the choice in a certain phase is less interesting (due to the avoiding of combat)

But the game was quite good even without fights! And Stefano convinced me to remove from the rules the possibility of a combat.

Instead of trying to make a patch for the two problems I would like to search an alternative solution where these problems are simply no more reported!

Let's assume that it is possible to play, with fun, without any combat as Stefano suggested.
In this case I still have the second problem to resolve: infact if I have no more combat I have no more "Warrior cards". So I have less choice.
I need more choices during this phase in order to give more spice to the game.

Another thing I had notice is the lack of a final score system. Up now I have a scoring during the end of each turn and an intermediate scoring during specific rounds, but still have no final score (for the end of the game).

I would like to resolve both lacks in once single way, as Dr Knizia teachs. So if I am able to introduce some actions useful for the final (or intermediate) score I maybe fix these problems.

Let's see in future playtests.

Emanuele

Client side technology

noreply@blogger.com (Ema) — Thu, 14 Feb 2008 14:26:00 +0000

Let's talk a bit about technology.
In this post I will talk only about the client part.
I have started my idea last year when I started a new job in Padova in Java web application. It was surely for me a return to a job I did several years ago (I worked with Microsoft tecnology in the meantime for non-web applications).
It was an opportunity to update my knowledge in the web development world.
I surprsly found something new: it was called Ajax. I don't want to talk in detail about Ajax because you can find a lot of tutorial on the web. I would only to note that the Asyncronous concept (the "A" from Ajax) is excatly what surprise me simply because it was what a normal web application lacked in order to become a game application!
Infact the "rough" of a web application (against the non-web applications) is that normally when you perform an action (a click on an image, or on a link) you see a page reload. That means a window flickering! That is excatly what makes a video game on web unplayable in terms of good feeling.
Moreover I learned about JavaScript framework such as Prototype and Scriptacolous and Mootools. These frameworks introduced a set of functions (a library) for specific grafic effects! The result is something unseen on a traditional web application. It is what now is called RIA: Rich Interent Application.
This was also possible thanks to the fact the main browsers (Internet Explorer 7, Firefox and Safari) became quite standard in interpreting JS and HTML.
So I started to learn these frameworks and the power of JavaScript and decided to try to develop a simply game using only JavaScript.
After almost a year I found this tecnology too difficult to use. I need to know a lot of CSS and DHTML other than JavaScript and the frameworks (I foucused on Mootools because seems really better than Scriptacolous).
Moreover debug JavaScript can become a nightmare!
In the meantime I discovery ActionScript 3.0 that is also known as Flash 9 and is included in the new Adobe Creative Suite. ActionScript 3.0 is a great evolution respect his preceding mainly because it is full Object Oriented. For a programmer who worked for more than 8 years using Object Oriented languages such as Java, C++ and C#, learning AS 3.0 is a joke!
AS 3.0 has also other advantages: the Flash player is a plugin that is mainly present in almost all the browser (and it is easy to install in any case). It easier to debug and to develop. And has a complete set of native objects really useful for videogames (but this is not a news of the 3.0 version).

So my target now is ActionScript 3.0. I worked for less than half time to have the same result I add in JavaScript.

Next time I will talk about the server side technology.

The effects of broken rules in a political game

noreply@blogger.com (Ema) — Wed, 13 Feb 2008 14:25:00 +0000

In this post I would like to point out how a bad rule development can let the game be a disaster.
I am just using a methafor in order to talk about political facts.
If you didn't know anything about the political crisis of Italian governement you can read this CNN article.

It's really a drama!
And this instability on the Italian governement is due to the election rules.
Rules, that we do not need to forgot, was acted by Berlusconi in the last weeks of his last governament. And we do not need to forget that Prodi's governament in 2 years was not able (or lack of will) to change these rules.

The final effect of this instability is that Italy governament is not working for people needs!
Because of we have not new rules, we are asked to go to the election day next 12 and 13 of April to play such a game with so broken rules! With a result that will be something unchanged, at least from the point of view of people needs.

I thanks Bruno Faidutti that invited me to his Ludophatic Gathering for the same weekend. At least I will the pleasure to play a lot of good games instead!

PS.: I suggest you to read about Italian disaster rules in the Beppe Grillo's english blog.

Prototyping

noreply@blogger.com (Ema) — Tue, 29 Jan 2008 12:47:00 +0000

The games I design passes two different phase.
The first one is the born of the idea. This, as said in a precedent post, should come from an already played game.
The second one is the devolopment of this idea.

Usually there are more ideas than games. And that's fine because should be impossible to fit all the ideas in a good game.
I use two different medias to annotate an idea: an excercise book and a word processor.
I prefer a big excercise book with small squares. Small squares are useful to draw some draft schema.
As word processor I'm using Google Doc mainly because I can easly share my ideas to playtesters or friends.
I have to admit that I tend to share a document mainly for the rules instead of the ideas....
The idea so written will never remain the same one. But writing the idea is a way to focus on the idea itself.
The idea is the source for the second phase.

The second phase is more long and harder to achive. Infact if this second phase will successfully end I have a game that can be played. This is what I called the development of the idea. It should be also called prototyping.
It is nice to note that in the software engineering field the prototyping is one of the phase on the software production lifecyle. So there is a good parallel between making computer programs and making a boardgame. We can assume the during this phase the game is in alfa testing (it is a software term).

The main task during prototyping is the test.
Usually I iterate through the following steps:
1. I prepare or modify a prototype
2. I test it for myself
3. The game was not good? I quit! I consider this idea not good enough!
4. Something to change? Come back to point 1.
5. Is the development of the idea good enough?
6. I prepare a better prototype.
7. I test it with real players. I also send the prototype to players who are not from my gaming group
8. There is some good feedback so that it can be changes somethin? I come back to point 1.
9. If I am really soddisfied I can consider the development phase finished.

There are a lot to discuss about these points, and I will in future posts.
What I want to highlight now is that there are 2 loops on this phase.
The first is on point 3 and the second on point 8. Both let the process go back to point 1.
But point 1. is to prepare a new prototype, with some relevant changes in order to test these changes.

Sometimes you don't really need to change the prototype, but only some rules (if you consider rules part of the prototype, you can say that each time you change a rule, you just change the prototype!).

When I first start with a prototype I try to quick create one. Usually I re-use pieces from other games (there are some boxes on my collection almost empty :-). I have some "preferred" pieces. For instance as score track I tend to use the one from Carcassonne! If I need some colored cards I use them from my Il Principe or I uses some very common Land Cards from Magic the Gathering (they are freely provided by my friend Stefano Rampazzo who owns the boardgame shop Tempus Fugit).
Because of the proto should be transformed several times, and maybe it will be dismissed because of the idea wasn't good enough, it is a waste of time to prepare a very detailed prototype.
Moreover in the first steps I will be the only one who test the game: I have my ideas in my mind (and in my excercise book) so I should survive to a collage of pieces as prototype!

In point 6., before to try the game with real players, I try to have a better proto. This means trying to have not an abstract game, but with a theme (maybe a not definitive one). Anyway I try to focus to have a pretty good playable proto.
This is important, in my opinion, because I want to be sure that problems that will come out can be assign to the game mechanics itself and not to a poor rappresentation of the game.
Again Google Images is coming in help. You just need to search for a "sheep picture" in order to have several good symbols for your Catan like prototype.
Sometime I re-uses artwork from other games (not only mine). I remember I tested Fantasy Pub before the publishing to the Bruno Faidutti's gathering many years ago! And I used some pictures from a Bruno's game! He came close to the table and said smiling: "I think I know this wizard!".

So the proto is improved in two different ways:
- the changes of mechanics and rules that must be naturally followed by the change of proto;
- the improvement of the pictures, symbols, components of the proto itself.

What does development means?

noreply@blogger.com (Ema) — Fri, 25 Jan 2008 12:43:00 +0000

Sometimes I am asked how the ideas for a boardgame comes in my mind.
My answer is that the idea is not the most important thing in order to design a boardgame.
The most difficult and time consuming activity to goal a good boardgame is the playtesting phase.

It requires a lot of time and tuning of the initial "idea".
I call this phase the development of the idea.
This term is sometimes used for person who is working inside a publisher company and who is responsable of the final release of the game. Probably the most known developer is Stefan Bruek from Alea. I think the german term is "Redaktion".

There are 2 different meaning for development:
- the development of the playing of the game, that is the development of the idea, the mechanism, the theme;
- the phisic development of the boardgame in order to have a published product, that means the decision on the artwork, on the components, on the package, on the rules.

Stefan Bruek job is doing both activities: he first evalute the prototypes, then try to develop with the author the mechanics, the flow of the game. Then when the game concept is ok, he manages the production aspect.

When I design a game for Mind the Move, I did the same job (helped by my wife Barbara) with the difference that I am the author too!

As several players already have noticed my games are a good mix of mechanism already seen in other games. So I can answer to the initial question "where comes ideas comes in mind?" with a more precise answers: "playing other games!".

But after that the development phase starts... And that's the hardest part of this nice hobby!

The begin of this idea...

noreply@blogger.com (Ema) — Thu, 24 Jan 2008 15:33:00 +0000

I started my idea to develop the electronic version of boardgames late in 2000.
I was not yet a boardgame author, so I was trying to approach the boardgame world using my software development knowledge.

I live in Padua that is only 30 minutes far from Venice where I knew Venice Connection have his office. So I send an email trying to approach VC team with the idea to develop freely a game they published. I was answered by Leo Colovini who invite me to meet him.
We talked a bit about this (rather new for me) world.

Internet for online games were still not so popular in 2000, but I already had the chance to play Quake and Unreal online using a flat internet connection. I also discovered the Microsoft Zone portal and played a lot to Backgammon (this game also gave me some idea to desing my Fantasy Pub).
I explained to Leo my idea of an online portal where to play boardgame, following the same model made by Microsoft Zone.
He instead had a different view of the boardgame on the computer: he like the idea to play against an artificial player moved by the computer. He show me his Cartagena, but I had no more time and interest in that project.... even if the idea still remained in my mind...

At the moment there are several online portals where you can play boardgames.
These are mainly grouped in two categories: Play By Mail (PBM) and Play in real time.

The most famous for playing in real time is surely Brettspielwelt where a lot of good boardgames are implemented. Days of Wonder has also several games they have published that can be played online. There are some interesting sites where you can play chess as at 64squar.

There are also several portals where you can play by mail, like for instance the one implemented by my friend MaBi MaBiWeb . Another is Boardgamegeek where there you can play Euprhat & Tigris and some other games. Another one is Yucata , but there are many others..

Graph theory and City interconnections

noreply@blogger.com (Ema) — Wed, 23 Jan 2008 12:38:00 +0000

Yesterday I had an idea about how to use my programming knwoledge for building boardgame prototype.
It's several days I am thinking to one new prototype idea. It is one of the many so I really don't know if it is good or not.
To understand if an idea is good enought to be a real boardgame, I just need to playtest it.
But before to playtest it I need a real protoype.
And to build a prototype is something that can become boring.
Some board are easy to use. Think about a square grid, similar to a chessboard. You just can type in even in a normal word processor using a table and print it.
If you need an hexagonal board you just need more work to do, and you can uses something like PowerPoint or Illustrator.
The clever thing of a protoype is that it doesn't remain as it is thought at first glance. It evolves, it changes. Sometime it is dismissed because the idea was not so good.

So one of the main problem for me is how to optimize my time. I have few time (even thought it is almost all my spare time) for boardgame developments, so optimizing my time is something essential.
One of the first think I learned is to use software for drawing my prototypes. It is easy to keep track of the modifications, and it is easy to print a new board or a new set of cards.
You just need some starting effort and then you can easly change stuffs inside, print a new version and use it.
It is easier than drawing with a pencil even because you can easly print with color instead of painting with colored pastels.

But sometimes you just need a complex board, like the one I am thinking in these days: a graph.
It mathematics there is a subset of knowledge that is called Graph Theory. It is used for modelling a city map for insteance (GPS devides are provided with software who manages a "graph" of streets).
Some games that are using a board with graphs?
Ticket to Ride for instance: cities are the nodes, rail tracks are the edges that connects the nodes.
In Hermagor there is a graph of cities and roads too.

So how to design a graph that can be easly changed?
It is easy to understand that you maybe need more nodes (more cities) or more interconnected edges (more streets).
Sometimes on the edges there is a value. In Ticket to Ride the number of trains that needs to connect two different cities are different and represents the distance between them.

In my idea I need some values on the edges and also a color! And I have no idea of the number of nodes or edges I need! It will come from playtests.

The solution should come from a small computer program that can manage these stuffs.
If I can have a kind of empty blackboard where I can add and delete nodes and edges should be fine enough!
I also need to save the graph in order to load it for changes.
I should easly adding a color and a value to both edges and nodes.
I should also adding a random functionality in order to change values and colors randomly.

Such a kind of program can be useful to other boardgame authors.

I found an already made program for the graph editor. It is freely downloadable from here. I will check if it is good for this purpose.

Emanuele

Welcome to Boardgame development

noreply@blogger.com (Ema) — Wed, 16 Jan 2008 08:41:00 +0000

Hi everyone.
2008 is already started and for this year I have a lot of expectetions and projects in my mind...
Nothing new so far.
But ideas remains ideas if you do not develop in things.
This blog is one of the idea that I want to start in order to become a real thing!

What this blog is about?
As the title says I want to talk about boardgame development.
But there are 2 ways in which I intend "development".
The first is about to develop a real boardgame. In this field I had already some success because I have published for Mind the Move, Amigo, Rio Grande, Tilsit, QuinedWhiteGoblin some boardgames.

The second is about to develop a video boardgame. Beacuse of I am a software engineer with almost 9 years of experience in software development, I should be able to develop the electronic version of boardgames.

Let's see if I will be able to find time to write in this blog for this 2008 and more....

Ema