进化

游戏背景

自然中蕴藏着神秘的双螺旋基因，演绎出生命的进化树。

前情提要

本游戏适合3-8人玩耍，游戏时长约20分钟。

游戏规则

为便于理解，在以下游戏规则说明中，可以将以下名词通俗理解为：

1. 基因：牌
2. 自然：牌堆
3. 世纪：回合
4. 隐性基因：手牌
5. 显性基因：桌面的牌
6. 生物：扮演桌面的牌的玩家
7. 进化：手牌叠置到桌面的牌上方
8. 发生事件：执行手牌上的文字效果
9. 历史：弃牌堆

1.游戏开始

洗混128个基因组成自然。每个生物分发4个基因，4即生物基因数量。由随机一个生物开始顺时针轮流进行一个世纪。

2.游戏回合

每个生物在一个世纪内进行以下操作：

1. 开始世纪，从自然中获取一个基因。

2. 当玩家没有显性基因时，可以进化出“门”基因，同时从自然获取一个基因。
   当玩家有显性基因时，若玩家的隐性基因中有符合生物的进化的，则可以选择进化出该基因，同时从自然获取一个基因。
   若无其他说明，每个世纪只可以进化一次。

3. 选择一个基因发生事件，然后该基因变成历史，结束回合。

3.游记结束

当有生物进化成出“属”基因时，该生物获胜，游戏结束。

牌组配置

128张牌

牌面文字

名词	张数	通俗理解	文字
废退	16	桌面的牌最上方进入弃牌堆	选择任意一个生物最高显性基因变为历史。
用进	16	桌面的牌最上方进入弃牌堆时，弃一张手牌获得	当某生物最高显性基因将变为历史时，将此基因变为历史来获得该基因。
掠夺性杂交	6	别人展示部分手牌，你来选择部分交换	选择任意一个生物让其展示任意数量隐性基因，你选择获得展示或者未展示的，并返还同等数量隐性基因。
选择性杂交	6	别人展示全部手牌，你来选择一张交换	检索任意一个生物的全部隐性基因，并与其交换其中一个。
平等性杂交	6	两个人交换全部手牌	选择其他两个生物交换所有隐性基因。
螺旋式杂交	6	顺或逆时针互相交换一张手牌	选择左或右方向，所有生物互相交换一个隐性基因。
群体性杂交	6	每人一张手牌打混重发	所有生物贡献一个隐性基因进行随机重组。
互惠性杂交	6	互相看手牌能否打到桌面	选择任意一个生物与其互相检索对方的全部隐性基因，若包含在对方生物上可进化的基因，则进化。
基因锁	4	不能进化	标记任意一个生物，使其无法进化，任意生物进化一次后解除。
时间锁	4	跳过回合	标记任意一个生物，跳过下一世纪，跳过后解除。
返祖	4	桌面的牌最上方收回手牌	选择任意一个生物最高显性基因变为隐性基因，同时选择一个隐性基因变为历史。
重新进化	4	桌面的牌最上方进入弃牌堆，同时置换一张手牌	选择任意一个生物最高显性基因变为历史，同时和自然交换一个隐性基因。
疯狂进化	4	回合进化两次	标记任意一个生物，使其可以在某世纪进化两次，进化后解除。
寄生	3	获得可以用于自己打到桌面的一张事件	标记任意一对生物寄生关系，在宿主生物基因发生事件时，若该基因可以用于寄生生物的进化，将一个隐性基因变为历史基因来获得该基因，获得后解除。
共生	3	别人进化时置换一张手牌	标记任意一对生物共生关系，双方生物在进化时，另一方可以和自然交换一个隐性基因，双方某一生物最高显性基因变为隐性基因或历史时解除。
集体突变	4	每人置换一张手牌	所有生物和自然交换一个隐性基因。
基因突变	4	执行牌堆上方的两张牌	选择任意一个生物，从自然中检索两个基因，若该基因可以用于该生物进化则进化，否则发生事件。
分解作用	2	获得弃牌一张	标记任意一个生物，可以获得任意变为历史的基因一次，获得后解除。
光合作用	2	选择置换四张手牌	从自然中获得生物基因数量的基因，然后将生物基因数量的隐性基因变为历史。
寒武纪	1	弃牌堆符合的全打到桌面	选择左或右方向，所有生物从历史中找到符合进化的基因并进化（不可被其他事件阻止）。
泥盆纪	1	所有人桌面的牌最上方进入弃牌堆	所有生物最高显性基因变为历史（不可被其他事件阻止）。
奥陶纪	1	增加1个手牌数	所有生物从自然获得一个基因（不可被其他事件阻止）。
白垩纪	1	减少1个手牌数	所有生物选择一个隐性基因变为历史（不可被其他事件阻止）。
时间机器	2	牌堆和弃牌堆交换	将历史与自然交换。

游戏测试

测试代码

#-*-coding:utf-8-*-
# @Author: suhang1596

import sys
import cmd
import random

def find(grade,playerList,layerNumber):
    for i in playerList:
        if( int( ( i - 1 ) / 2 ) == grade ):
            grade = i
            if grade >= pow( 2 , layerNumber ) - 1:
                return 1
            else:
                find( grade , playerList , layerNumber )

def creatCard(layerNumber,cardList):
    x = 1
    for layer in range( layerNumber ):
        for node in range( pow( 2 , layer + 1) ):
            for samenode in range( pow( 2 , layerNumber - layer - 1 ) ):
                cardList.append( x )
                cardList.append( x )
            x = x + 1

def test(playerNumber,layerNumber,hd):
    random.shuffle(card[layerNumber])
    player = []
    for i in range( playerNumber ):
        player.append(card[layerNumber][hd*i:int(hd*(progress+i))])
        player[i].sort()

    for j in range( playerNumber ):
        mark = 0
        if ( player[j][0] == 1 ) | ( player[j][0] == 2 ):
            for y in range( 1 , 3 ):
                if (( find( y , player[j] , layerNumber ) == 1 )) :
                    mark += 1
            if mark > 0:
                mainSuccessCount[layerNumber][playerNumber] += 1
            else:
                mainFailCount[layerNumber][playerNumber] += 1
        else:
            mainFailCount[layerNumber][playerNumber] += 1

if __name__ == '__main__':

    testTimes = 500
    rate = 1.0
    progress = 0.625
    beginHandcard = 4
    roundHandcard = 1
    testLayerFrom=4
    testLayerTo=5
    testPlayerFrom=3
    testPlayerTo=9

    print (u'您的设定是玩到%.2f%%的进度，' % (progress*100)),
    print (u'起始%2d张牌，每回合抽取%2d张牌！\n' % (beginHandcard,roundHandcard))

    card = []
    mainSuccessCount = []
    mainFailCount = []
    handcardNumber = []
    for c in range(0,10):
        card.append([])
        handcardNumber.append([])
        mainSuccessCount.append([])
        mainFailCount.append([])
        for m in range(0,10):
            mainSuccessCount[c].append(0)
            mainFailCount[c].append(0)

    for cardNumber in range(testLayerFrom,testLayerTo):
        creatCard(cardNumber,card[cardNumber])
        print (u'目前的牌组设定下，%d个等级、%4d张牌，' % (cardNumber,len(card[cardNumber]),)),
        print (u'玩到%.2f%%的进度有%4d张牌' % (progress,len(card[cardNumber])*progress))

    for i in range(testTimes):
        for testLayer in range(testLayerFrom,testLayerTo):
            for testPlayer in range(testPlayerFrom,testPlayerTo):
                handcardNumber[testLayer] = len(card[testLayer]) / testPlayer
                test(testPlayer,testLayer,handcardNumber[testLayer])

    print (u'\n经过%d次测试，\n' % (testTimes))
    for testLayer in range(testLayerFrom,testLayerTo):
        for testPlayer in range(testPlayerFrom,testPlayerTo):
            x = float(mainSuccessCount[testLayer][testPlayer])
            y = float(mainFailCount[testLayer][testPlayer])
            rate  = x / ( x + y )
            print (u'在%2d个人中进化成功率%.2f%%,' % (testPlayer,rate*100)),
            print (u'即成功了%2d个人' % (int(rate*testPlayer))),
            hui = (  len(card[testLayer]) * progress -  beginHandcard * testPlayer )  /  roundHandcard
            quan = hui/testPlayer
            print (u'需要轮%2d圈%3d个回合' % (quan,hui))
        print ('\n')

测试结果

测试结果