[DotGNU]A webservice game project ((TODO))

[Peter Minten]

Hi folks,

here's a showoff project idea which might be beneficial to DotGNU.

--- REASONS ---

Everybody knows a game is the best way to show off since it's more attractive
than the average test file :-). So far there are a few small examples of
specific areas (CGI, QT# with pnet), but how about creating a bigger game that
covers all the aspects of DotGNU. IMHO that's a good way to catch bugs and logic
errors.

I was thinking of a Trading Card Game. The game would have the following
features:

* Programmable cards, the game cards must be able to do custom things. The best
way to implement this is IMHO embedded scripting. Scripting is something we need
to implement sometime anyway. I personally think the biggest problem with
scripting will be callbacks from C to C# code, the rest of the stuff is just
P/Invoking an interpreter lib.

* Online tournaments with rankings and stuff, tournaments are one of the most
fun elements of TCG's. Users of a webservice must be able to interact with
eachother, which isn't possible in our current design but is needed.

* Card winning, in tournaments cards could be earned. The cards could be
exported to the user's drive in a human readable format, but with an encrypted
checksum by the webservice where they were created. The cards could be imported
into another TCG webservice, but any cheating would be exposed by the checksum.
A user could use the cheated cards locally however. This is a good test for
encryption.

* Downloadable webservices, the webservices must be downloadable and should be
usable for U2U (user-to-user) play. This is a good test of our downloading
system.

* Graphical User Interface, the webservice should create windows on the client
and is thus a test for our remote GUI systems.

--- GAME RULES ---

This is what I had in mind as game rules (roughly):

There are 3 types of cards: resource, spell and creature. Resources are needed
to create spells and creatures. Spells can do a lot of different things, but
only once (unless overridden). Creature can be used to attack time and time
again and to block attacks from other creatures.

There are 4 alignments (influences the strategy which is best for the cards):
Bear (red): Power play, bear cards often do or die. Playing bear means
sacrificing units for power.
Fox (blue): Trickery, fox cards are the opposite of bear cards, they will first
get as many advantages as possible and then attack. Playing fox means fighting
at your terms.
Leopard (yellow): Speed, leopard cards are fast, they can often attack at the
first turn, but are not very durable. Playing leopard means attacking before
your opponent can get his act together.
Turtle (green): Durability, turtle cards are hard to destroy, this has it's
price in speed however. Playing turtle means waiting for your opponent to be
weakened and then attacking.

The game is played with a set of 40 card for each player composed by the player.
For tournaments the cards must be earned. This is done with an experience
system, every won game increases experience, based on the experience of the
player and the experience of the opponent. When the experience level of a player
reaches a certain threshold the level of the player get's increased. Every card
has a level which tells it's power, to use (or more exactly to accuire) a card a
player must have at least the level of a card. Every game won also gives the
player 1 credit, cards have prices based on the relative level of the player to
the card. If a player can afford a card he/she can accuire the card class and
use cards of that class.

The system is a little tricky so here are the rules again:
* You win experience by winning games, the amount of experience you gain is more
or less opponent_experience/your_experience * certain_amount +
other_certain_amount.
* You gain levels by gaining experience (level = experience div 100).
* Every game won gives you one credit (note that the tournament engine will
match you with a more or less equal opponent.
* The cost of cards is based on the level difference between the card and you.
* To acquire a card class you must have furfil these requirements:
  - your_level >= card_level
  - your_credit >= card_cost

Greetings,

Peter