Skip to Content

Starting a project

3 replies [Last post]
ycyclop
Offline
Joined: 11/12/2008

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.

mawibse
Offline
Joined: 12/31/1969
Starting a project

My suggestion is GENERALIZE.

ALL gamecomponents should have same structure:
Name
Number of sides
Size
Type
(For in game purposes: position X,Y and Z for position in stacks, rotation, which side up, owner)

Ex1:
Name: MainBoard
Number of sides: 1
Size: 30x20 cm
Type: Board
Ex2:
Name: BlueDice
Number of sides: 6
Size: 4x4 cm
Type: Dice

A) Each Side of a gamecomponent should have an Image attached to it.
B) Each side has an on/off value for if it is a Face or a Back for visibility logic.
C) Each side has a Visibility parameter that affects gamecomponents placed upon that side, possible parameters are:
1. Public
2. Hidden

theraje
Offline
Joined: 12/31/1969
Starting a project

Darkehorse and I were working on this a few months ago, before I got sidetracked by Real Life. I think your idea is basically the same as what we agreed on - a "dumb" application where all you can really do is add/move/remove stuff and generate random numbers/shuffle cards.

We seem to diverge here on the definition of components, though. Instead of "supporting" certain components, we had the idea of making a very generic game object. This object could be created, moved, added to a group (such as a deck of cards or whatnot), removed from a group, etc. The object groups would have a few functions (such as randomize and sort) as well.

The map portion of your document is also a bit overcooked, in my opinion. Instead of using an image, you would have either a blank board, or a tiled (for instance) background to use as a guide (like if your game uses a grid, for example). You would be able to save the locations etc. of components in a gamestate file, though.

As for the mat, one of our ideas was to have a pane of private parts (that sounds so wrong...) that would be invisible to others. If you moved one of them to the board, it would become visible to others. Sort of like the difference between holding a card in your hand and placing it face-up on the table.

When it comes to the cards, tiles, game pieces, chits, etc., we decided to go with the generic "GameObject" class. Via the use of an XML file or some other format editable in Notepad and its ilk, you would be able to edit its parameters, such as its ID #, component "type," state, image, rules text, etc. Using this method properly, one would be able to define a pool of cards by giving them unique ID numbers, setting the type to "Card," and filling in the rules text (what the card does, how much it costs, and whatever else). A deck of cards could be visible to one player or all of them, depending on the placement of the deck grouping - either in the player's private pane, or on the table.

Dice were an interesting little topic. You could either use a random number object on top of a generic die image, or, if you were using dice with symbols or something similar, you could define each side as a "d6" object for example, group them together, and have them work like a deck of cards. The principle is the same, except that the number is always visible (while cards are normally face-down) and that die values can't be "drawn" (removed).

There's a lot more to it than that, of course, but those are just a few of the meatier portions of the plan we came up with. Now, if I (or someone else here) could make it happen... I want to do it, but it will be a while before I can even think about working on it again.

RookieDesign
Offline
Joined: 12/31/1969
Starting a project

ycyclop,

I glad you express interest in this. I tried to do it few months ago, but again real life called back.

If you want to start a project, I suggest you start it on sourceforge and have an open license.

For this, I this that the best chance of this source code grow and profit from the community.

Syndicate content


forum | by Dr. Radut