想做一个德州扑克规则的游戏，存在一些问题不能解决，求助中……

aolinge2017

德州扑克规则手牌（底牌）2张，公用牌5张，在7张牌中挑选5张牌，组合成最大的牌型。

牌型如下：

高牌（单牌）
一对（一对相同的牌）
两队（两对相同的牌）
三条（三个相同的+2个不同的）
顺子（五个连续的牌）
同花（同一花色）
葫芦（三个相同的+2个相同的）
四条（四个相同的+1个不同的）
同花顺（五个连续的牌，并且花色一样）
皇家同花顺（10 J Q K A，并且花色一样）


有高手能教我这个规则怎么写触发器吗


---------------------------------------------------------------------------------------------------------------

现在有3个问题没有解决，
1、所有玩家的牌中间有重复的牌，变量没设置对，希望能修改下
2、比较7个整数大小的是，有几率在第3、4、5位置的整数值为0（可能是丢失了），我的方法很笨，或者能换种更简单的比较算法
3、比较数值大小排列后，确定牌型，这里又涉及到了比较，希望能提供下简单方法，不要一个个比较

priceles

用数字表示牌面大小和花色，每次都遍历来比较如果符合某个规则就设为1，如果符合这个规则的下一个规则（比如一对和两对，两对为一对的下一个规则）就+1，用变量分别表示符合规则的次数，最后统计符合哪些规则

yxxiaobin

因为组合的数量很小，所以不必过于考虑效率问题，那么直接暴力解决就好了，首先给规则从大到小编号，比如单张的记做1，一对记做2，两对记做3，以此类推，最后皇家同花顺应该记做10。然后遍历每种组合，按规则从大到小的顺序比较这一组合符合哪种规则，第一次符合的规则就是当前组合的规则，比如一个组合首先判断是不是符合皇家同花顺，如果不符合，再判断是否符合同花顺，也不符合，判断是否属于四条，符合了，那么当前组合就是4条，判断结束，无需继续判断你是否符合葫芦了。把组合和规则编号记下来。然后读取第二种组合，再次这样判断，得出结论后，比较第一组合和第二组合谁的规则大，把小的丢弃掉，把大的作为第一组合，然后再读取下一组合，再次判断规则，再次比较大小。直到所有组合都判断完毕，最后得到的第一组合就是最大的组合。

这里只是提供了编程思路，具体如何读取组合，如何判断大小，你自己试着写，如果还是写不出来，继续提问，有时间我帮你做个演示。

priceles

yxxiaobin 发表于 2016-4-10 21:52
因为组合的数量很小，所以不必过于考虑效率问题，那么直接暴力解决就好了，首先给规则从大到小编号，比如单 ...

但是以后你想要在两个规则间插入要怎么办？

yxxiaobin

priceles 发表于 2016-4-10 22:01
但是以后你想要在两个规则间插入要怎么办？

你是说假如出现新的规则，比如在2和3之间需要加入一条规则，比2大，但是比3小是吧。这个很简单啊，你不要用1、2、3，而是用10、20、30，甚至是100、200、300，这样随便怎么增加规则也够用了吧。
而且既然是自己的图，那么源码自己肯定要掌握的，即便是用相邻数字，但是这一数字对应哪条规则是你指定的啊，你加入规则后让他们对应关系顺序后移不就好了，这样皇家同花顺就对应11了呗。

priceles

yxxiaobin 发表于 2016-4-10 22:07
你是说假如出现新的规则，比如在2和3之间需要加入一条规则，比2大，但是比3小是吧。这个很简单啊，你不要 ...

如果某条后规则有50个，是不是要移50位啊，是不是要编写个脚本来帮你做啊而且为什么要为空的变量分配内存空间呢

七键守护神

priceles 发表于 2016-4-10 22:17
如果某条后规则有50个，是不是要移50位啊，是不是要编写个脚本来帮你做啊而且为什么要为空的变量分配内存 ...

规则是作者制定的，也是需要在游戏一开始进行初始化的。
在初始化的时候分别注册这些规则，按照顺序来编号。没必要记住每个规则对应的序号，只需要记住注册的顺序。
这里建议你将规则写成函数，然后初始化的时候用一个函数引用数组来记录下它们。在判断牌型的时候，从大到小的顺序依次运行这些函数引用，如果得到返回真，就可以判断当前牌型成立了。
数组变量在声明后当然就要为其分配空间，数组是无法动态扩大或缩小的。而且SC2的变量其实都是引用，不会占用多大的内存，如果你想动态控制数组的长度，就用数据表代替变量吧。

priceles

七键守护神 发表于 2016-4-10 23:16
规则是作者制定的，也是需要在游戏一开始进行初始化的。
在初始化的时候分别注册这些规则，按照顺序来编 ...

我不建议从大到小来进行判断的，而是判断符合哪些牌型最后在统计的时候再为其排序，而且有可能规则是互不冲突的，如果从大到小排就要考虑所有可能的情况，万一不周全就要增加规则数，有可能越来越多的规则要判断，为以后的修改带来麻烦。

yxxiaobin

priceles 发表于 2016-4-11 08:08
我不建议从大到小来进行判断的，而是判断符合哪些牌型最后在统计的时候再为其排序，而且有可能规则是互不 ...

也正因为规则未必完全冲突，所以才要从大到小比较，比如某组合是葫芦，但是你判断单张、一对、两对、三条，仍然是符合的，但是这不是最大的组合，所以不能作为牌面的大小。事实上，如果从大到小的比较，当第一次通过检查时，牌的大小就肯定是这条规则，无需在向下检查了。而且经过优化的算法，某些情况的比较可以同时进行，比如同花顺和皇家同花顺，比较一副牌是不是皇家同花顺，需要符合三条规则，第一，符合同花，第二符合顺子，第三，符合从10到A的序列。拿到组合后先排序，查看最大的牌是不是A，如果不是，直接弃掉规则，如果是，继续判断牌是不是顺子，如果不是，那么直接弃掉和顺子有关的规则，如果是，判断牌是不是同花，如果不是，直接弃掉和同花有关的规则。如果是，则这副牌是皇家同花顺。其他以此类推。这样虽然也是从大到小比较的，但是可以避免重复比较，事实上只需要比较几次就能得出当前组合符合的最大规则。
另外我比较奇怪的是，德州扑克的规则是早制定好的吧，突然修改规则不是很奇怪的事么。就算你要自己写规则，那么直接写就是了。因为在SE中，可是支持函数的。函数这东西有多方便，我想稍微懂点编程的都了解吧。所以即使你要加入自己的规则，只要不是太奇葩，代码什么的真的是简单的要死。就现有规则来说，我们需要的函数真的不多，简单想一下有如下几个：
1.一副牌是否是顺子
2.一副牌是否是同花
3.一副牌中是否有四条
4.一副牌中是否有三条
5.一副牌中对子的数量
6.一副牌中最大的单张是哪张（如果用数组记录一副牌，则返回值就是数组下标，不是牌面值）
7.一张牌的牌面值
8.一张牌的花色


这些函数进行简单的套嵌，就能做出楼主要的10个规则。而且部分函数会在多处反复用到比如判断花色，这就体现出函数的优势了。
这样首先判断是否是皇家同花顺，即牌的1，2函数返回真，6函数返回牌的牌面是A。如果不是，根据返回值做分支，比如1函数返回假，那么就不必检测同花顺和顺子规则了。另外如果4函数返回1，那么不是葫芦就是3条，只要用5函数检测一下就能区分它们了。

aolinge2017

看见大家对我帖子这么关心，非常非常高兴，也非常感谢大家

因为扑克本身确定了规则，，就是10个规则，，，准确说是9个，皇家同花顺其实只是一个手气更好的体现

比如起手2张A，4个J，4个Q，4个K，4个A，皇家同花顺之类的，在游戏中可以做成更好的属性，更好的单位之类的附加东西

我先说下，我对这个游戏的构思吧
初始：
玩家在2-8，加一个电脑为庄家（以后玩家可以买倍率，通俗的讲就是第七张牌没有翻起来，2个以上的玩家都吧金币全部下下去了，当前赢家避免自己输，所以可以向玩家电脑买保险，至于倍率数以后详细说）
初始资源2000金币，拥有一个基地，或许有一两个防御建筑这个后面可以改
玩家可结盟或者互为敌人，取决于游戏模式

玩法：
游戏在10秒左右开始
1、给每位玩家在52张牌中随机发两张手牌，给玩家在基地前面创建一个和手牌关联的单位（比如23，可能是一个机枪兵，2个A可能是火蝠，具体根据游戏设定），玩家1开始下注（下局为玩家2开始，依次类推）（由于大小盲太复杂，省略掉这个环节），如果玩家1下注50金币，后面的玩家都要跟50金币，也可大于或者弃牌，不能小于（除非拥有的金币数量小于50）；如果玩家5给了100，那么678,1234都要再给50才行；如果到最后玩家4再给100，那么又开始循环，直到没人加价或金币全部用完。中途可以弃牌，但是金币不返还。
2、屏幕中间发三张牌，所有玩家都能看见（52张牌 减去玩家手上的牌 的剩余牌），现在玩家用手上的2张手牌和屏幕中间的3张公用牌进行比较，组合最大的当前牌型（现在不需要电脑比较，玩家自己比较）；由玩家1开始下注\过牌\弃牌（下局为玩家2开始，依次类推），回到1循环的那个地方，直到没人加价或金币全部用完把手牌关联的单位变成组合牌型最大的单位（比如三条，可能是一个女妖，顺子可能是大和，具体根据游戏设定）
3、屏幕中间发一张牌，所有玩家都能看见（52张牌减去 玩家手上的牌+屏幕中间的4张公用牌 的剩余牌），现在玩家用手上的2张手牌和屏幕中间的4张公用牌进行比较，组合最大的当前牌型（现在不需要电脑比较，玩家自己比较）；由玩家1开始下注\过牌\弃牌（下局为玩家2开始，依次类推），回到1循环的那个地方，直到没人加价或金币全部用完。把手牌关联的单位变成组合牌型最大的单位（比如同花，可能是一个女妖，四条可能是奥丁，具体根据游戏设定）
4、屏幕中间发一张牌，所有玩家都能看见（52张牌减去 玩家手上的牌+屏幕中间的5张公用牌 的剩余牌），现在玩家用手上的2张手牌和屏幕中间的5张公用牌进行比较，组合最大的当前牌型（现在不需要电脑比较，玩家自己比较）；由玩家1开始下注\过牌\弃牌（下局为玩家2开始，依次类推），回到1循环的那个地方，直到没人加价或金币全部用完。把手牌关联的单位变成组合牌型最大的单位（比如同花，可能是一个女妖，四条可能是奥丁，具体根据游戏设定）

5、结算，现在需要电脑进行比较没有弃牌的玩家中。谁的牌最大，最大的赢取全部；如果牌型一样的将平分所有金币。这还存在一些细节问题，具体制作的时候详说

6、控制牌型对比最大奖励单位，到中场战斗，杀死对方的单位获得奖励，牌型越多优势越大，具体根据游戏设定（这里会弹出一个战斗或继续游戏的对话框，如果大多数人点击了战斗那么就到中场战斗，否者继续游戏，循环到1）

7、弃牌的玩家，可以获得一个防御建筑，围墙或者自动机枪，具体根据游戏设定。玩家剩余的单位会被保留，最后进行大会战（比如玩家一赢了所有玩家的金币）胜利方获得奖励。

奖励系统：
段位机制，取决于玩家获得的胜利场次
军衔机制，取决于玩家击杀数
手气王机制，就是上面说的拿到手牌一对、组合牌4个JQKA、皇家同花顺之内的牌型
每种机制等级都有附加的属性奖励，比如攻强、生命、单位等等
还可以奖励更好看的扑克图片之类的

以上是我对这个游戏简单思路，算法规则这块我不太会，其他的我都能搞定的
扑克的图片已经搞定了，我现在在调整地图UI这块
希望有兴趣的朋友（只要能帮上忙的都行）加我QQ 2497506521，一起制作这个图。

也可以提一些你的想法和建议，我尽量采纳，谢谢

aolinge2017

yxxiaobin 发表于 2016-4-11 09:51
也正因为规则未必完全冲突，所以才要从大到小比较，比如某组合是葫芦，但是你判断单张、一对、两对、三条 ...

我把变量改了，怎么只能创建2张牌了呢
回复发不来连接图片，发上面了

yxxiaobin

完全看不明白你的图片是在哪里创建的，根据第二章截图，每个玩家只有一张底牌吧。
你应该先创建好界面，而不必管它应该显示哪张牌，如果界面本身就不对，那算法什么的也没法弄了。

aolinge2017

yxxiaobin 发表于 2016-4-12 12:48
完全看不明白你的图片是在哪里创建的，根据第二章截图，每个玩家只有一张底牌吧。
你应该先创建好界面，而 ...

是2张底牌，右边那个是开牌的时候的界面，我只是先显示出来自己检查看重叠牌没有
情况是重叠的，要不我把文件传给你，你空了帮我看下，弄了好久才弄成这个样的

aolinge2017

现在有3个问题没有解决，
1、所有玩家的牌中间有重复的牌，变量没设置对，希望能修改下
2、比较7个整数大小的是，有几率在第3、4、5位置的整数值为0（可能是丢失了），我的方法很笨，或者能换种更简单的比较算法
3、比较数值大小排列后，确定牌型，这里又涉及到了比较，希望能提供下简单方法，不要一个个比较

yxxiaobin

aolinge2017 发表于 2016-4-12 23:13
现在有3个问题没有解决，
1、所有玩家的牌中间有重复的牌，变量没设置对，希望能修改下
2、比较7个整数大 ...

玩家可能被重复发牌，是因为你并没有标记那张牌发过了，那张没有。要标记牌是否被发过，直接的方案就是用两个数组来记录，第一个数组记录所有的牌，第二个数组记录对应的牌是否被发过。如果随机到了发过的牌，重新随机一次就好了。如果你需要一直使用一套牌直到发完，那么这种方法效率可能变得低下，这时候你改成用编号表示牌，再用一个整数型数组记录的是乱序以后的牌，发牌时不再使用随机数，而是从牌顶依次发牌，用一个整数变量记录牌顶位置，当发过一张牌以后把牌顶位置下降一张就好了。

比较一组数的大小，其实就是排序，关于排序有很多种算法。贴一个排序算法的介绍，应该能看懂。http://baike.baidu.com/view/396887.htm

确定牌型的比较不知道是说什么。

因为不了解你的具体思路，所以就不针对你的游戏写代码了。我只是提供一些编程思路，具体代码还要你自己写的。

aolinge2017

yxxiaobin 发表于 2016-4-13 18:56
玩家可能被重复发牌，是因为你并没有标记那张牌发过了，那张没有。要标记牌是否被发过，直接的方案就是用 ...

修改了下，吧数值归了下类

算法001
在变量数组D[L][M](L为花色，M为1-13的数值)，挑选21个数值，每个数值不能重复




-------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------



算法002
给7个随机大小的数值排序

所有数组忽略0

变量数组A[7]，（[1]、[2]、[3]、[4]、[5]、[6]、[7]分别代表1-13之间的随机整数）
变量数组B[7]，（[1]代表A[7]中最大的数，[2]代表A[7]中第二大的数，依次类推，[7]代表A[7]中最小的；如果数值相等，就依次排列如9999762或8776641等）

变量数组H[7]，（[1]、[2]、[3]、[4]、[5]、[6]、[7]分别代表1-4之间的随机整数）
变量数组G[7]，（[1]代表H[7]中最大的数，[2]代表H[7]中第二大的数，依次类推，[7]代表H[7]中最小的；如果数值相等，就依次排列如4444432或2222222等）


-------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------


算法003
设定牌型规则

变量数组G[7]中,代表花色（1>=2>=3>=4）
变量数组B[7]中,代表牌值大小位置（[1]>=[2]>=[3]>=[4]>=[5]>=[6]>=[7]）

对子数变量 i

牌型最大数值变量数组J[a]（a取决于玩家数,b当前牌型）


-------------------------------------------------------------------------------------------------------------------------------------
规则设定


单牌  B[7]设置 [1]>[2]>[3]>[4]>[5]>[6]>[7]  ---（J[a][1]）

一对  B[7]设置 [1]=[2] / [2]=[3] / [3]=[4] / [4]=[5] / [5]=[6] / [6]=[7]，对子数变量 i=1  ---（J[a][2]）

双对  B[7]设置 [1]=[2] / [2]=[3] / [3]=[4] / [4]=[5] / [5]=[6] / [6]=[7]，对子数变量 i=2  ---（J[a][3]）

三条  B[7]设置 [1]=[2]=[3] / [2]=[3]=[4] / [3]=[4]=[5] / [4]=[5]=[6] / [5]=[6]=[7]   ---（J[a][4]）

顺子  B[7]设置 [1]=[2]+[1],[2]=[3]+[1],[3]=[4]+[1],[4]=[5]+[1],[5]=[6]+[1] / [2]=[3]+[1],[3]=[4]+[1],[4]=[5]+[1],[5]=[6]+[1],[6]=[7]+[1] / [1]=[13],[2]=[12],[3]=[11[,[4]=[10],[7]=[1] (K Q J 10 A)  ---（J[a][5]）

同花  G[7]设置 [1][2][3][4][5][6][7]其中5个以上数值都等于1 / 2 / 3 / 4
      B[7]设置 [1]>[2]>[3]>[4]>[5]>[6]>[7]
      ---（J[a][6]）

葫芦  B[7]设置 [1]=[2]=[3]（[4]=[5]/[5]=[6]/[6]=[7]/[4]=[5]=[6]/[5]=[6]=[7])  / [2]=[3]=[4] ([5]=[6]/[6]=[7]/[5]=[6]=[7]) / [3]=[4]=[5] ([1]=[2]/[6]=[7]) / [4]=[5]=[6] ([1]=[2]/[2]=[3]) / [5]=[6]=[7] ([1]=[2]/[2]=[3]/[3]=[4]/[1]=[2]=[3])   

      ---（J[a][7]）

金刚  B7设置 [1]=[2]=[3]=[4] / [2]=[3]=[4]=[5] / [3]=[4]=[5]=[6] / [4]=[5]=[6]=[7]   ---（J[a][8]）

同花顺 G7设置 [1][2][3][4][5][6][7]其中5个以上数值都等于1 / 2 / 3 / 4
       B[7]设置 [1]=[2]+[1],[2]=[3]+[1],[3]=[4]+[1],[4]=[5]+[1],[5]=[6]+[1] / [2]=[3]+[1],[3]=[4]+[1],[4]=[5]+[1],[5]=[6]+[1],[6]=[7]+[1] / [1]=[13],[2]=[12],[3]=[11[,[4]=[10],[7]=[1] (K Q J 10 A)
       ---（J[a][9]）


-------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------


算法004
大小比较
比较规则，先比较牌型，相同牌型再比较点数

如葫芦33322与44333，先比较333，再比较22与44谁大
如三条：83332与94333 或 99987与99962；顺子：98765与87654；金刚：96666与99996 或 96666与66663

之前 变量数组J[a],中的 决定了牌型
整数变量数组C[7]（[1]每种牌型对应的最大点数，[2]每种牌型对应的第2大点数，[3]每种牌型对应的第3大点数，[4]每种牌型对应的第4大点数，[5]每种牌型对应的第5大点数,[6]每种牌型对应的第6大点数，[7]每种牌型对应的第7大点数）
先比较C[1]，在比较C[2]，依次类推

C[7]决定牌型值的大小。
C[7]的值还存在一个问题，
当B[7]中的[7]不等于 整数1 (就是扑克里的A)时，B[7]中的[1]最大
当B[7]中的[7]等于 整数1 (就是扑克里的A)时，B[7]中的[7]>[1]
(如顺子（KQJ10A）13 12 11 10 1与54321，65432与54321)

可能需要增加其他的变量进行比较，详见下面的比较规则）


高牌   C[1]=B[7]的[1]（如9875432，那么C[1]=9,C[2]=8,C[3]=7,C[4]=5,C[5]=4）

一对   C[1]=B[7]的[[1]/[2]/[3]/[4]/[5]/[6]/[7](成一对的数值的值）（如9654322，那么C[1]=2,C[2]=B[7]的B[7]的[1]/[2]/[3]/[4]/[5]/[6]/[7]不成对的最大数值9,C[3]=B[7]中[1]/[2]/[3]/[4]/[5]/[6]/[7]不成对的第2大数值6,C[4]=B[7]中[1]/[2]/[3]/[4]/[5]/[6]/[7]不成对的第3大数值5；只需比较前面5张最大的后面忽略）

双对   C[1]=B[7]的[[1]/[2]/[3]/[4]/[5]/[6]/[7](两个成一对的数值中最大的一个对子的值，）（如9954322，那么C[1]=9,C[2]=2,C[3]=B[7]的B[7]的[1]/[2]/[3]/[4]/[5]/[6]/[7]不成对的最大数值5)

三条   C[1]=B[7]的[[1]/[2]/[3]/[4]/[5]/[6]/[7](三个相等数值）（如9998432，那么C[1]=9,C[2]=B[7]的B[7]的[1]/[2]/[3]/[4]/[5]/[6]/[7]相等3个数值外的最大数值8,C3=B[7]的B[7]的[1]/[2]/[3]/[4]/[5]/[6]/[7]相等3个数值外的第二大数值4)

顺子   C[1]=B[7]的[[1]/[2]/[3]/[4]/[5]/[6]/[7](至少5个相连数值中最大数值）（如9865432，那么C[1]=6,C[2]=5,C[3]=4,C[4]=3,C[5]=2）

同花   C[1]=B[7]的[1]（如9875432，那么C[1]=9,C[2]=8,C[3]=7,C[4]=5,C[5]=4）

葫芦   C[1]=B[7]的[[1]/[2]/[3]/[4]/[5]/[6]/[7](三个相等数值最大的数值）C[2]=B[7]的B[7]的[1]/[2]/[3]/[4]/[5]/[6]/[7](三个相等数值第2大数值/成对的数值）（如9993332，那么C[1]=9,C[2]=3；9987222，那么C[1]=2,C[2]=9）

金刚   C[1]=B[7]的[[1]/[2]/[3]/[4]/[5]/[6]/[7](四个相等数值最大的数值）C[2]=B[7]的B[7]的[1]/[2]/[3]/[4]/[5]/[6]/[7](四个相等数值第大数值）（如9999332，那么C[1]=9,C[2]=3；9872222，那么C[1]=2,C[2]=9）

同花顺 C[1]=B[7]的[[1]/[2]/[3]/[4]/[5]/[6]/[7](至少5个相连数值中最大数值）（如9865432，那么C[1]=6,C[2]=5,C[3]=4,C[4]=3,C[5]=2）



比较中设计到我上面说过的

当B[7]中的[7] 不等于 整数1 (就是扑克里的A)时，B[7]中的[1]最大
当B[7]中的[7] 等于 整数1   (就是扑克里的A)时，B[7]中的[7]>[1]

(如顺子（KQJ10A）13 12 11 10 1与54321，65432与54321)

这种情况的处理