Desenvolvendo uma estrutura de jogo de cartas

Que tipo de padrões e idéias de design se pode usar para criar uma estrutura de jogo de cartas de propósito geral?

Isso decorre de que eu tentei construir um clone do popular jogo de Steve Jackson "Munchkin". Por causa da natureza desse jogo, acabei tendo que codificar tantas funcionalidades de cartão que o desenvolvimento se tornou caótico e complexo. Eu queria criar algo geral, mas acabei com apenas muitas classes com muitas funções substituídas e alternar instruções para determinar o comportamento.

Eu estava curioso para saber como alguém com mais experiência em design lidaria com essa tarefa de construir uma estrutura de jogo de cartas de propósito geral, ou pelo menos algo que pudesse ser estendido. Ou é melhor que, se eu quiser fazer uma simulação de um jogo de cartas como o Munchkin, estou preso em criar uma estrutura específica.

Eu gostaria de usar c #.

EDITAR

Eu gostaria de esclarecer um pouco do que eu gostaria de alcançar. Eu gostaria de uma estrutura na qual eu possa implementar basicamente fases com funcionalidade personalizada (fase 1: cartões de compra, fase 2: aplicar regras de manutenção, fase 3: cartões de jogo, fase 4: resolução, etc.).

Penso que definir um conjunto de regras seria sábio, o que seria combinado com as cartas e as fases.

Então, as cartas seriam definidas e, suponho, vinculadas às regras, por exemplo, uma regra poderia ser "Durante a fase de manutenção, perca 1 ficha". No entanto, uma carta que o jogador possui pode fornecer "Não perca nenhuma ficha durante a fase de manutenção". Portanto, seria bom poder amarrar isso juntos, mas dentro das entranhas da estrutura.

Suponho que isso também esteja fora do meu alcance.

Eu teria usado algum tipo de linguagem de script como LUA ou Python para definir cada comportamento ou cartão especial.

• http://www.lua.org/
• http://www.python.org/

Dessa forma, você pode definir um mecanismo "genérico" e manter as particularidades dos cartões longe do código principal, em alguns scripts pequenos e facilmente editáveis.

A principal vantagem das linguagens de script sobre XML ou outros dados "estáticos" é que as linguagens de script podem "criar" seus próprios comportamentos usando os métodos públicos oferecidos pelo mecanismo.

Exemplo: suponha que seu mecanismo ofereça os métodos "setDommage (target, dmg)" e "setVisualEffect (nameOfFxLuaScript)" etc. etc.

------Card1 -- A simple fireball-----
// Fire ball
setDommage(target, 37);
setVisualEffect("fireBall.lua");

------Card2 -- A multitype ball (outch it hurts!)-----
// Fire ball
setDommage(target, 37);
setVisualEffect("fireBall.lua");

// Ice ball
if( player.protectionAgainstIce == false )
{
    setDommage(target, 102);
    setVisualEffect("iceBall.lua");
}

// thunderbolt
while( player.Alive )
{
    setDommage(target, 1005);
    setVisualEffect("thunderBolt.lua");
}

Os dois cartões usam os mesmos métodos de mecanismo , mas não fazem as mesmas coisas. Os comportamentos também podem usar dados coletados do mecanismo (como a lista de jogadores para fazer um loop sobre eles) e para instruções if, etc.

A segunda, mas não a menor vantagem, é que ela não precisa ser compilada. Você pode modificar o script LUA e recarregá-lo diretamente sem recompilar o jogo. É muito bom para testar e iterar até encontrar as boas configurações.

A terceira vantagem é que qualquer pessoa que possa aprender a linguagem de script pode criar novos cartões / comportamentos, desde que você forneça uma lista dos métodos públicos compartilhados pelo mecanismo (e desde que você não codifique as LUAs). E como todos sabem, a comunidade é incrível quando você oferece ferramentas legais;)

Aqui está um wrapper LUA para C #: http://luaforge.net/projects/luainterface/