Hi all,
I've being thinking a while on this subject and now I have so free time (well not really, but this is intersting enough for me to spend some time on this).
So here is a small definition document of what I'm going to implement.
Let me know what you think and please bear in mind that it is only a draft and not "official" definition of the what is going to be in the final application.
Online Prototype Testing Application (OPTA)
The goal of the application is to allow game developers create an mockup of their game and play it online with other testers. The application will only supply the UI for creating a mockup of the game. It will not enable any to capture any logic of the rules. This will need to be handled by the players such as: removing of objects, adding, moving components, etc. However, the application will allow logic of component type such as a deck of cards, dice, point counting etc.
This document will define the different components that the application will support and how to define them in the game definition file and what other files are needed such as bitmap files.
In order to save some time at this stage of the project, UI definitions and examples will not be included in this document. Since there are so many options for each item, the goal is to provide an application, as fast as possible for people to try it hands on and give feedback as to what is needed and how it needs to be done.
I’m writing here many things that I think that should be supported by the application but of course not all of them will be in the first version.
The game components
Map:
The map is the main place to put components on. Each map will open a window that can include components.
1: A bitmap that is supplied by the user. The map can include an empty area around the bitmap, by defining the map size larger then the bitmap supplied and including the position of the upper left point of the bitmap.
2: A definition of an area that will be opened as an empty window.
Every map that is defined can be opened by the players and view components placed on it.
Actions possible with the map:
Open/Close map
Create components on the map
Move components on the map
Remove components (see specific component for details)
Player Mat:
Similar to map in how you define but couple of more things need to be defined. Currently I can think of one: Is it visible to other players.
Player mat that is visible to all players can be opened for viewing by everyone, and non-visible can only be visible to the player. This will be managed by the application once defined.
Cards/Tiles:
For practical purpose tile and cards are the same objects and will be called from here on cards.
To define a set of cards you need to do the following
1: create a bitmap with all front side of the cards on it in the same size. The cards can be lined it any way. For example a 25 cards deck can be positioned as a bitmap 1x25 cards or 5x5 or even 4x7 but when defining the cards set you need to specify the positioning definition and the number of cards in the deck (in the later case 4x7, only the first 25 cards will be used).
2: create a bitmap with all backsides of the cards on it in the same size.
3: define the set of cards, which is the number of appearance of every card in the deck and for each card what backside to use.
4: define behavior of the deck:
a: visibility
i: open to all- showen to all players
ii: visible to opening player. Front side is visible to opening player, and back is visible to other players.
iii: Hidden. Only valid in player mat. Once opened all other players do not get any information.
b: when the deck is exhausted, reshuffle discarded cards or is the deck depleted.
Actions possible with cards/tiles:
At the beginning of the game the decks of cards/tiles will be shuffled.
Opening a card will open the top one.
Discard a card will remove the card and put in the discard pile of that deck.
Remove a card will remove the card from the game
Move a card by dragging it to different position or to a different map (or player mat)
Dice:
1: Define the number of side on the dice, and the type of dice: numbers or images
2: if it is an image dice, supply a bitmap file with all the images
3: Define a dice roll: how many dice of each type are used in a single roll. So a roll like cities and knights of Catan can be defined in a single roll and not make the player roll three different dice.
Action possible with dice:
Roll a defined dice roll.
Roll a single selected die.
Counters (enumerators):
These items are used to count different items such as score, round number etc.
1: define the name of the counter and is it a global counter or player specific counter
2: is it a private counter for. Valid only for player specific counters.
Action possible with Counters:
Add/Subtract value.
Tokens:
Tokens are markers that can be place on the map or players mat. Currently all tokens are square.
1: Define the token bitmap and the name of the token
2: Is it a player token. Player token will have a colored border.
3: Number of available token or unlimited number.
Action possible with Tokens:
Create a token and place it on the map, player mat
Discard a token will return the token to the pool (if there is a limited number)
Remove a token will remove a token from the game
Move a token by dragging it to different position or to a different map (or player mat)
How the application will work:
One player will start the application with a specific game setup and declare himself as the server and notify other people of his computer ip address. They will connect his computer after starting with the same game setup. Once a player joins the game he is prompt to select a player name and color. Once enough players connected the owner of the session can start the game and no more players can join.
Once the game is in progress there is an active player, only he can make changes: Create tokens, open cards, roll dice and every one sees his actions. Once the player finished his action he can transfer the control to someone else. The application will not manage turn order; the player will have to do that.
