├── .idea
├── .gitignore
├── dictionaries
│ └── Administrator.xml
├── encodings.xml
├── misc.xml
├── modules.xml
├── poker.iml
├── vcs.xml
└── watcherTasks.xml
├── README.md
├── ddz
├── bottom_card.go
├── card.go
├── card_type.go
├── const.go
├── find_card.go
├── split_card.go
└── util.go
├── go.mod
└── test
├── test_bottom_card.go
├── test_card_find.go
├── test_card_find_lai_zi.go
├── test_card_split.go
├── test_card_type.go
└── test_card_type_lai_zi.go
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /workspace.xml
--------------------------------------------------------------------------------
/.idea/dictionaries/Administrator.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | chun
5 | jian
6 | ruan
7 |
8 |
9 |
--------------------------------------------------------------------------------
/.idea/encodings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/.idea/poker.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/watcherTasks.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/ddz/bottom_card.go:
--------------------------------------------------------------------------------
1 | package ddz
2 |
3 | // 底牌牌型判定
4 | func GetBottomCardType(cards []*Card) BottomCardType {
5 | myCards := convertToMap(cards, nil)
6 | _, value, line := getCountValueLine(myCards)
7 |
8 | if huoJian(value) {
9 | return BottomCardTypeHuoJian
10 | }
11 |
12 | if oneJoker(value) {
13 | return BottomCardTypeOneJoker
14 | }
15 |
16 | if tongHuaShun(cards, value, line) {
17 | return BottomCardTypeTongHuaShun
18 | }
19 |
20 | if tongHua(cards) {
21 | return BottomCardTypeTongHua
22 | }
23 |
24 | if shunZi(value, line) {
25 | return BottomCardTypeShunZi
26 | }
27 |
28 | if sanBuDai(value) {
29 | return BottomCardTypeSanBuDai
30 | }
31 | return BottomCardTypeNone
32 | }
33 |
34 | // 火箭
35 | func huoJian(value valueList) bool {
36 | var smallJoker bool
37 | var bigJoker bool
38 | for _, v := range value[1] {
39 | if v == NumTypeSmallJoker {
40 | smallJoker = true
41 | }
42 |
43 | if v == NumTypeBigJoker {
44 | bigJoker = true
45 | }
46 | }
47 |
48 | if smallJoker == true && bigJoker == true {
49 | return true
50 | }
51 | return false
52 | }
53 |
54 | // 单王
55 | func oneJoker(value valueList) bool {
56 | var joker int
57 | for _, v := range value[1] {
58 | if v == NumTypeSmallJoker || v == NumTypeBigJoker {
59 | joker++
60 | }
61 | }
62 |
63 | if joker == 1 {
64 | return true
65 | }
66 | return false
67 | }
68 |
69 | // 同花顺
70 | func tongHuaShun(cards []*Card, value valueList, line []int) bool {
71 | if !tongHua(cards) {
72 | return false
73 | }
74 |
75 | if !shunZi(value, line) {
76 | return false
77 | }
78 | return true
79 | }
80 |
81 | // 同花
82 | func tongHua(cards []*Card) bool {
83 | if len(cards) == 0 {
84 | return false
85 | }
86 |
87 | suit := cards[0].Suit
88 | for _, c := range cards {
89 | if suit != c.Suit {
90 | return false
91 | }
92 | }
93 | return true
94 | }
95 |
96 | // 顺子
97 | func shunZi(value valueList, line []int) bool {
98 | // 只能有单张
99 | if len(value[2]) != 0 || len(value[3]) != 0 || len(value[4]) != 0 {
100 | return false
101 | }
102 |
103 | // 不能有2和大小王
104 | for _, v := range line {
105 | if isJokerAndTwo(v) {
106 | return false
107 | }
108 | }
109 |
110 | // 必须连续
111 | valueRange := line[len(line)-1] - line[0] + 1
112 | if valueRange != len(line) {
113 | return false
114 | }
115 | return true
116 | }
117 |
118 | // 三不带
119 | func sanBuDai(value valueList) bool {
120 | // 只能有三张
121 | if len(value[1]) != 0 || len(value[2]) != 0 || len(value[4]) != 0 {
122 | return false
123 | }
124 |
125 | if len(value[3]) != 1 {
126 | return false
127 | }
128 | return true
129 | }
130 |
--------------------------------------------------------------------------------
/ddz/card.go:
--------------------------------------------------------------------------------
1 | package ddz
2 |
3 | import "fmt"
4 |
5 | // 牌
6 | type Card struct {
7 | Suit SuitType // 花色
8 | Num NumType // 牌值
9 | }
10 |
11 | func (c Card) String() string {
12 | return fmt.Sprintf("%s%s", c.Suit, c.Num)
13 | }
14 |
15 | func NewCard(suit SuitType, num NumType) *Card {
16 | return &Card{
17 | Suit: suit,
18 | Num: num,
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/ddz/card_type.go:
--------------------------------------------------------------------------------
1 | package ddz
2 |
3 | // 获取牌型
4 | func GetCardType(cards []*Card, laiZiNums ...NumType) (list []*CardTypeInfo) {
5 | if len(laiZiNums) == 0 {
6 | // 无癞子算法
7 | return analysis(cards)
8 | }
9 |
10 | var normalCards []*Card // 普通牌
11 | var laiZiCards []*Card // 癞子牌
12 | for _, c := range cards {
13 | var exist bool
14 | for _, num := range laiZiNums {
15 | if c.Num == num {
16 | exist = true
17 | break
18 | }
19 | }
20 |
21 | if exist {
22 | laiZiCards = append(laiZiCards, c)
23 | } else {
24 | normalCards = append(normalCards, c)
25 | }
26 | }
27 |
28 | if len(laiZiCards) == 0 {
29 | // 无癞子算法
30 | return analysis(cards)
31 | } else {
32 | // 癞子算法
33 | return analysisLaiZi(cards, normalCards, laiZiCards)
34 | }
35 | }
36 |
37 | // 无癞子算法
38 | func analysis(cards []*Card) (list []*CardTypeInfo) {
39 | size := len(cards)
40 | dictCards := convertToMap(cards, nil)
41 | count, value, line := getCountValueLine(dictCards)
42 |
43 | switch size {
44 | case 1:
45 | // 单
46 | if info := isDan(size, value); info.CardType != CardTypeNone {
47 | list = append(list, &info)
48 | return
49 | }
50 |
51 | case 2:
52 | // 对
53 | if info := isDui(size, value); info.CardType != CardTypeNone {
54 | list = append(list, &info)
55 | return
56 | }
57 |
58 | // 火箭
59 | if info := isHuoJian(size, value); info.CardType != CardTypeNone {
60 | list = append(list, &info)
61 | return
62 | }
63 |
64 | case 3:
65 | // 三不带
66 | if info := isSanBuDai(size, value); info.CardType != CardTypeNone {
67 | list = append(list, &info)
68 | return
69 | }
70 |
71 | case 4:
72 | // 三带一
73 | if info := isSanDaiYi(size, value); info.CardType != CardTypeNone {
74 | list = append(list, &info)
75 | return
76 | }
77 |
78 | // 炸弹
79 | if info := isZhaDan(size, value); info.CardType != CardTypeNone {
80 | list = append(list, &info)
81 | return
82 | }
83 |
84 | case 5:
85 | // 三带二
86 | if info := isSanDaiEr(size, value); info.CardType != CardTypeNone {
87 | list = append(list, &info)
88 | return
89 | }
90 |
91 | case 6:
92 | // 四带单
93 | if info := isSiDaiDan(size, value); info.CardType != CardTypeNone {
94 | list = append(list, &info)
95 | return
96 | }
97 |
98 | case 8:
99 | // 四带对
100 | if info := isSiDaiDui(size, value, line); info.CardType != CardTypeNone {
101 | list = append(list, &info)
102 | return
103 | }
104 | }
105 |
106 | // 顺子
107 | if info := isShunZi(size, value, line); info.CardType != CardTypeNone {
108 | list = append(list, &info)
109 | return
110 | }
111 |
112 | // 连对
113 | if info := isLianDui(size, value, line); info.CardType != CardTypeNone {
114 | list = append(list, &info)
115 | return
116 | }
117 |
118 | // 飞机不带
119 | if info := isFeiJiBuDai(size, value, line); info.CardType != CardTypeNone {
120 | list = append(list, &info)
121 | return
122 | }
123 |
124 | // 飞机带一
125 | if info := isFeiJiDaiYi(size, count, value, line); info.CardType != CardTypeNone {
126 | list = append(list, &info)
127 | return
128 | }
129 |
130 | // 飞机带二
131 | if info := isFeiJiDaiEr(size, value, line); info.CardType != CardTypeNone {
132 | list = append(list, &info)
133 | return
134 | }
135 |
136 | // 连炸
137 | if info := isLianZha(size, value, line); info.CardType != CardTypeNone {
138 | list = append(list, &info)
139 | return
140 | }
141 | return
142 | }
143 |
144 | // 单
145 | func isDan(size int, value valueList) (info CardTypeInfo) {
146 | if size != 1 {
147 | return
148 | }
149 |
150 | info.CardType = CardTypeDan
151 | info.MinValue = value[1][0]
152 | return
153 | }
154 |
155 | // 对
156 | func isDui(size int, value valueList) (info CardTypeInfo) {
157 | if size != 2 {
158 | return
159 | }
160 |
161 | // 牌值相同
162 | if len(value[2]) == 1 {
163 | info.CardType = CardTypeDui
164 | info.MinValue = value[2][0]
165 | }
166 | return
167 | }
168 |
169 | // 三不带
170 | func isSanBuDai(size int, value valueList) (info CardTypeInfo) {
171 | if size != 3 {
172 | return
173 | }
174 |
175 | if len(value[3]) == 1 {
176 | info.CardType = CardTypeSanBuDai
177 | info.MinValue = value[3][0]
178 | }
179 | return
180 | }
181 |
182 | // 三带一
183 | func isSanDaiYi(size int, value valueList) (info CardTypeInfo) {
184 | if size != 4 {
185 | return
186 | }
187 |
188 | if len(value[3]) == 1 && len(value[1]) == 1 {
189 | info.CardType = CardTypeSanDaiYi
190 | info.MinValue = value[3][0]
191 | }
192 | return
193 | }
194 |
195 | // 三带二
196 | func isSanDaiEr(size int, value valueList) (info CardTypeInfo) {
197 | if size != 5 {
198 | return
199 | }
200 |
201 | if len(value[3]) == 1 && len(value[2]) == 1 {
202 | info.CardType = CardTypeSanDaiEr
203 | info.MinValue = value[3][0]
204 | }
205 | return
206 | }
207 |
208 | // 四带单(炸弹带两张单)
209 | func isSiDaiDan(size int, value valueList) (info CardTypeInfo) {
210 | if size != 6 {
211 | return
212 | }
213 |
214 | if len(value[4]) == 1 && (len(value[1]) == 2 || len(value[2]) == 1) {
215 | info.CardType = CardTypeSiDaiDan
216 | info.MinValue = value[4][0]
217 | }
218 | return
219 | }
220 |
221 | // 四带对(炸弹带两对)
222 | func isSiDaiDui(size int, value valueList, line lineList) (info CardTypeInfo) {
223 | if size != 8 {
224 | return
225 | }
226 |
227 | // 是否二连炸
228 | if info = isLianZha(size, value, line); info.CardType != CardTypeNone {
229 | return
230 | }
231 |
232 | if len(value[4]) == 1 && len(value[2]) == 2 {
233 | info.CardType = CardTypeSiDaiDui
234 | info.MinValue = value[4][0]
235 | return
236 | }
237 |
238 | if len(value[4]) == 2 {
239 | info.CardType = CardTypeSiDaiDui
240 | info.MinValue = value[4][1]
241 | return
242 | }
243 | return
244 | }
245 |
246 | // 顺子
247 | func isShunZi(size int, value valueList, line lineList) (info CardTypeInfo) {
248 | if size < 5 || size > 12 {
249 | return
250 | }
251 |
252 | // 只能有单张
253 | if len(value[2]) != 0 || len(value[3]) != 0 || len(value[4]) != 0 {
254 | return
255 | }
256 |
257 | // 不能有2和大小王
258 | for _, v := range line {
259 | if isJokerAndTwo(v) {
260 | return
261 | }
262 | }
263 |
264 | // 必须连续
265 | valueRange := line[len(line)-1] - line[0] + 1
266 | if size != valueRange {
267 | return
268 | }
269 |
270 | info.CardType = CardTypeShunZi
271 | info.MinValue = line[0]
272 | info.MaxValue = line[len(line)-1]
273 | return
274 | }
275 |
276 | // 连对
277 | func isLianDui(size int, value valueList, line lineList) (info CardTypeInfo) {
278 | if size < 6 || size%2 != 0 {
279 | return
280 | }
281 |
282 | // 只能有对子
283 | if len(value[1]) != 0 || len(value[3]) != 0 || len(value[4]) != 0 {
284 | return
285 | }
286 |
287 | // 不能有2和大小王
288 | for _, v := range line {
289 | if isJokerAndTwo(v) {
290 | return
291 | }
292 | }
293 |
294 | // 必须连续
295 | valueRange := line[len(line)-1] - line[0] + 1
296 | if size != valueRange*2 {
297 | return
298 | }
299 |
300 | info.CardType = CardTypeLianDui
301 | info.MinValue = line[0]
302 | info.MaxValue = line[len(line)-1]
303 | return
304 | }
305 |
306 | // 飞机不带
307 | func isFeiJiBuDai(size int, value valueList, line lineList) (info CardTypeInfo) {
308 | if size < 6 || size%3 != 0 {
309 | return
310 | }
311 |
312 | // 只能有三张
313 | if len(value[1]) != 0 || len(value[2]) != 0 || len(value[4]) != 0 {
314 | return
315 | }
316 |
317 | // 不能有2和大小王
318 | for _, v := range line {
319 | if isJokerAndTwo(v) {
320 | return
321 | }
322 | }
323 |
324 | // 必须连续
325 | valueRange := line[len(line)-1] - line[0] + 1
326 | if size != valueRange*3 {
327 | return
328 | }
329 |
330 | info.CardType = CardTypeFeiJiBuDai
331 | info.MinValue = line[0]
332 | info.MaxValue = line[len(line)-1]
333 | return
334 | }
335 |
336 | // 飞机带一
337 | func isFeiJiDaiYi(size int, count countList, value valueList, line lineList) (info CardTypeInfo) {
338 | if size < 8 || size%4 != 0 {
339 | return
340 | }
341 |
342 | // 连炸不是飞机带一
343 | info = isLianZha(size, value, line)
344 | if info.CardType != CardTypeNone {
345 | return
346 | }
347 |
348 | valueRange := size / 4
349 |
350 | for i := NumTypeAce; i >= NumTypeThree+valueRange-1; i-- {
351 | var nums []int
352 | for j := i; j >= i-valueRange+1; j-- {
353 | if count[j] >= 3 {
354 | nums = append(nums, j)
355 | continue
356 | }
357 | break
358 | }
359 |
360 | if len(nums) == valueRange {
361 | info.CardType = CardTypeFeiJiDaiYi
362 | info.MinValue = nums[len(nums)-1]
363 | info.MaxValue = nums[0]
364 | return
365 | }
366 | }
367 | return
368 | }
369 |
370 | // 飞机带二
371 | func isFeiJiDaiEr(size int, value valueList, line []int) (info CardTypeInfo) {
372 | if size < 10 || size%5 != 0 {
373 | return
374 | }
375 |
376 | // 不能有单张
377 | if len(value[1]) != 0 {
378 | return
379 | }
380 |
381 | // 三张不能有2
382 | for _, v := range value[3] {
383 | if isJokerAndTwo(v) {
384 | return
385 | }
386 | }
387 |
388 | // 必须连续
389 | valueRange := value[3][len(value[3])-1] - value[3][0] + 1
390 | if size != valueRange*5 {
391 | return
392 | }
393 |
394 | info.CardType = CardTypeFeiJiDaiEr
395 | info.MinValue = value[3][0]
396 | info.MaxValue = value[3][len(value[3])-1]
397 | return
398 | }
399 |
400 | // 炸弹
401 | func isZhaDan(size int, value valueList) (info CardTypeInfo) {
402 | if size != 4 {
403 | return
404 | }
405 |
406 | if len(value[4]) == 1 {
407 | info.CardType = CardTypeZhaDan
408 | info.MinValue = value[4][0]
409 | }
410 | return
411 | }
412 |
413 | // 火箭
414 | func isHuoJian(size int, value valueList) (info CardTypeInfo) {
415 | if size != 2 {
416 | return
417 | }
418 |
419 | if huoJian(value) {
420 | info.CardType = CardTypeHuoJian
421 | }
422 | return
423 | }
424 |
425 | // 连炸
426 | func isLianZha(size int, value valueList, line lineList) (info CardTypeInfo) {
427 | if size < 8 || size%4 != 0 {
428 | return
429 | }
430 |
431 | // 只能有四张
432 | if len(value[1]) != 0 || len(value[2]) != 0 || len(value[3]) != 0 {
433 | return
434 | }
435 |
436 | // 不能有2和大小王
437 | for _, v := range line {
438 | if isJokerAndTwo(v) {
439 | return
440 | }
441 | }
442 |
443 | // 必须连续
444 | valueRange := line[len(line)-1] - line[0] + 1
445 | if valueRange != size/4 {
446 | return
447 | }
448 |
449 | info.CardType = CardTypeLianZha
450 | info.MinValue = line[0]
451 | info.MaxValue = line[len(line)-1]
452 | return
453 | }
454 |
455 | // 癞子算法
456 | func analysisLaiZi(cards []*Card, normalCards []*Card, laiZiCards []*Card) (list []*CardTypeInfo) {
457 | size := len(cards)
458 | laiZiSize := len(laiZiCards)
459 |
460 | dictCards := convertToMap(cards, nil)
461 | _, value, _ := getCountValueLine(dictCards)
462 |
463 | normalDictCards := convertToMap(normalCards, nil)
464 | normalCount, normalValue, normalLine := getCountValueLine(normalDictCards)
465 |
466 | // 癞子单
467 | if info := isDanLaiZi(size, value); info.CardType != CardTypeNone {
468 | list = append(list, &info)
469 | }
470 |
471 | // 癞子对
472 | if info := isDuiLaiZi(size, value, normalLine); info.CardType != CardTypeNone {
473 | list = append(list, &info)
474 | }
475 |
476 | // 癞子三不带
477 | if info := isSanBuDaiLaiZi(size, value, normalLine); info.CardType != CardTypeNone {
478 | list = append(list, &info)
479 | }
480 |
481 | // 癞子三带一
482 | if infoList := isSanDaiYiLaiZi(size, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
483 | list = append(list, infoList...)
484 | }
485 |
486 | // 癞子三带二
487 | if infoList := isSanDaiErLaiZi(size, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
488 | list = append(list, infoList...)
489 | }
490 |
491 | // 癞子四带单
492 | if infoList := isSiDaiDanLaiZi(size, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
493 | list = append(list, infoList...)
494 | }
495 |
496 | // 癞子四带对
497 | if infoList := isSiDaiDuiLaiZi(size, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
498 | list = append(list, infoList...)
499 | }
500 |
501 | // 癞子顺子
502 | if infoList := isLianLaiZi(CardTypeShunZi, size, normalValue, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
503 | list = append(list, infoList...)
504 | }
505 |
506 | // 癞子连对
507 | if infoList := isLianLaiZi(CardTypeLianDui, size, normalValue, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
508 | list = append(list, infoList...)
509 | }
510 |
511 | // 癞子飞机不带
512 | if infoList := isLianLaiZi(CardTypeFeiJiBuDai, size, normalValue, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
513 | list = append(list, infoList...)
514 | }
515 |
516 | // 癞子飞机带一
517 | if infoList := isFeiJiDaiYiLaiZi(size, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
518 | list = append(list, infoList...)
519 | }
520 |
521 | // 癞子飞机带二
522 | if infoList := isFeiJiDaiErLaiZi(size, normalCount, normalLine, laiZiSize); len(infoList) != 0 {
523 | list = append(list, infoList...)
524 | }
525 |
526 | // 四纯癞子炸
527 | if info := isChunLaiZiZhaDan(size, laiZiSize, laiZiCards); info.CardType != CardTypeNone {
528 | list = append(list, &info)
529 | }
530 |
531 | // 火箭
532 | if info := isHuoJian(size, value); info.CardType != CardTypeNone {
533 | list = append(list, &info)
534 | }
535 |
536 | // 软炸
537 | if info := isRuanZhaDan(size, normalLine); info.CardType != CardTypeNone {
538 | list = append(list, &info)
539 | }
540 |
541 | // 癞子炸
542 | if info := isLaiZiZhaDan(size, laiZiSize, laiZiCards); info.CardType != CardTypeNone {
543 | list = append(list, &info)
544 | }
545 |
546 | // 软连炸
547 | if info := isRuanLianZha(size, normalCount, normalLine, laiZiSize); info.CardType != CardTypeNone {
548 | list = append(list, &info)
549 | }
550 | return
551 | }
552 |
553 | // 癞子单
554 | func isDanLaiZi(size int, value valueList) (info CardTypeInfo) {
555 | if size != 1 {
556 | return
557 | }
558 |
559 | info.CardType = CardTypeDan
560 | info.MinValue = value[1][0]
561 | return
562 | }
563 |
564 | // 癞子对
565 | func isDuiLaiZi(size int, value valueList, normalLine lineList) (info CardTypeInfo) {
566 | if size != 2 {
567 | return
568 | }
569 |
570 | // 非癞子牌有多少种牌值
571 | switch len(normalLine) {
572 | case 0:
573 | if len(value[2]) != 1 {
574 | return
575 | }
576 |
577 | info.CardType = CardTypeDui
578 | info.MinValue = value[2][0]
579 |
580 | case 1:
581 | if isJoker(normalLine[0]) {
582 | return
583 | }
584 |
585 | info.CardType = CardTypeDui
586 | info.MinValue = normalLine[0]
587 | }
588 | return
589 | }
590 |
591 | // 癞子三不带
592 | func isSanBuDaiLaiZi(size int, value valueList, normalLine lineList) (info CardTypeInfo) {
593 | if size != 3 {
594 | return
595 | }
596 |
597 | // 非癞子牌有多少种牌值
598 | switch len(normalLine) {
599 | case 0:
600 | if len(value[3]) != 1 {
601 | return
602 | }
603 |
604 | info.CardType = CardTypeSanBuDai
605 | info.MinValue = value[3][0]
606 |
607 | case 1:
608 | if isJoker(normalLine[0]) {
609 | return
610 | }
611 |
612 | info.CardType = CardTypeSanBuDai
613 | info.MinValue = normalLine[0]
614 | }
615 | return
616 | }
617 |
618 | // 癞子三带一
619 | func isSanDaiYiLaiZi(size int, normalCount countList, normalLine lineList, laiZiSize int) (list []*CardTypeInfo) {
620 | if size != 4 {
621 | return
622 | }
623 |
624 | var min CardTypeInfo // 最小值
625 | var max CardTypeInfo // 最大值
626 |
627 | // 非癞子牌有多少种牌值
628 | switch len(normalLine) {
629 | case 2:
630 | var line []int
631 | for _, v := range normalLine {
632 | if isJoker(v) {
633 | continue
634 | }
635 | line = append(line, v)
636 | }
637 |
638 | if len(line) == 0 {
639 | return
640 | }
641 |
642 | min = minSanDaiYiLaiZi(normalCount, line, laiZiSize)
643 | max = maxSanDaiYiLaiZi(normalCount, line, laiZiSize)
644 |
645 | default:
646 | return
647 | }
648 |
649 | if min.CardType == CardTypeNone && max.CardType == CardTypeNone {
650 | return
651 | }
652 |
653 | if min.MinValue == max.MinValue {
654 | list = append(list, &min)
655 | } else {
656 | list = append(list, &min, &max)
657 | }
658 | return
659 | }
660 |
661 | // 最小癞子三带一
662 | func minSanDaiYiLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
663 | for i := 0; i < len(line); i++ {
664 | info = sanDaiYiLaiZi(line[i], normalCount, laiZiSize)
665 | if info.CardType != CardTypeNone {
666 | return
667 | }
668 | }
669 | return
670 | }
671 |
672 | // 最大癞子三带一
673 | func maxSanDaiYiLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
674 | for i := len(line) - 1; i >= 0; i-- {
675 | info = sanDaiYiLaiZi(line[i], normalCount, laiZiSize)
676 | if info.CardType != CardTypeNone {
677 | return
678 | }
679 | }
680 | return
681 | }
682 |
683 | // 癞子三带一结果
684 | func sanDaiYiLaiZi(value int, normalCount countList, laiZiSize int) (info CardTypeInfo) {
685 | var laiZi int
686 |
687 | // 补三张
688 | switch normalCount[value] {
689 | case 0:
690 | laiZi += 3
691 | case 1:
692 | laiZi += 2
693 | case 2:
694 | laiZi += 1
695 | }
696 |
697 | if laiZi > laiZiSize {
698 | return
699 | }
700 |
701 | info.CardType = CardTypeSanDaiYi
702 | info.MinValue = value
703 | return
704 | }
705 |
706 | // 癞子三带二
707 | func isSanDaiErLaiZi(size int, normalCount countList, normalLine lineList, laiZiSize int) (list []*CardTypeInfo) {
708 | if size != 5 {
709 | return
710 | }
711 |
712 | var min CardTypeInfo // 最小值
713 | var max CardTypeInfo // 最大值
714 |
715 | // 非癞子牌有多少种牌值
716 | switch len(normalLine) {
717 | case 2:
718 | for _, v := range normalLine {
719 | if isJoker(v) {
720 | return
721 | }
722 | }
723 |
724 | min = minSanDaiErLaiZi(normalCount, normalLine, laiZiSize)
725 | max = maxSanDaiErLaiZi(normalCount, normalLine, laiZiSize)
726 |
727 | default:
728 | return
729 | }
730 |
731 | if min.CardType == CardTypeNone && max.CardType == CardTypeNone {
732 | return
733 | }
734 |
735 | if min.MinValue == max.MinValue {
736 | list = append(list, &min)
737 | } else {
738 | list = append(list, &min, &max)
739 | }
740 | return
741 | }
742 |
743 | // 最小癞子三带二
744 | func minSanDaiErLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
745 | for i := 0; i < len(line); i++ {
746 | info = sanDaiErLaiZi(line[i], normalCount, line, laiZiSize)
747 | if info.CardType != CardTypeNone {
748 | return
749 | }
750 | }
751 | return
752 | }
753 |
754 | // 最大癞子三带二
755 | func maxSanDaiErLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
756 | for i := len(line) - 1; i >= 0; i-- {
757 | info = sanDaiErLaiZi(line[i], normalCount, line, laiZiSize)
758 | if info.CardType != CardTypeNone {
759 | return
760 | }
761 | }
762 | return
763 | }
764 |
765 | // 癞子三带二结果
766 | func sanDaiErLaiZi(value int, normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
767 | var laiZi int
768 |
769 | // 补三张
770 | switch normalCount[value] {
771 | case 0:
772 | laiZi += 3
773 | case 1:
774 | laiZi += 2
775 | case 2:
776 | laiZi += 1
777 | }
778 |
779 | if laiZi > laiZiSize {
780 | return
781 | }
782 |
783 | // 补对子
784 | for _, v := range line {
785 | if v == value {
786 | continue
787 | }
788 |
789 | switch normalCount[v] {
790 | case 0:
791 | laiZi += 2
792 | case 1:
793 | laiZi += 1
794 | }
795 |
796 | if laiZi > laiZiSize {
797 | return
798 | }
799 | }
800 |
801 | info.CardType = CardTypeSanDaiEr
802 | info.MinValue = value
803 | return
804 | }
805 |
806 | // 癞子四带单
807 | func isSiDaiDanLaiZi(size int, normalCount countList, normalLine lineList, laiZiSize int) (list []*CardTypeInfo) {
808 | if size != 6 {
809 | return
810 | }
811 |
812 | var min CardTypeInfo // 最小值
813 | var max CardTypeInfo // 最大值
814 |
815 | // 非癞子牌有多少种牌值
816 | switch len(normalLine) {
817 | case 0, 1:
818 | return
819 |
820 | default:
821 | var line []int
822 | for _, v := range normalLine {
823 | if isJoker(v) {
824 | continue
825 | }
826 | line = append(line, v)
827 | }
828 |
829 | min = minSiDaiDanLaiZi(normalCount, line, laiZiSize)
830 | max = maxSiDaiDanLaiZi(normalCount, line, laiZiSize)
831 | }
832 |
833 | if min.CardType == CardTypeNone && max.CardType == CardTypeNone {
834 | return
835 | }
836 |
837 | if min.MinValue == max.MinValue {
838 | list = append(list, &min)
839 | } else {
840 | list = append(list, &min, &max)
841 | }
842 | return
843 | }
844 |
845 | // 最小癞子四带单
846 | func minSiDaiDanLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
847 | // 最小值为3
848 | info = siDaiDanLaiZi(NumTypeThree, normalCount, laiZiSize)
849 | if info.CardType != CardTypeNone {
850 | return
851 | }
852 |
853 | for i := 0; i < len(line); i++ {
854 | if line[i] == NumTypeThree {
855 | continue
856 | }
857 |
858 | info = siDaiDanLaiZi(line[i], normalCount, laiZiSize)
859 | if info.CardType != CardTypeNone {
860 | return
861 | }
862 | }
863 | return
864 | }
865 |
866 | // 最大癞子四带单
867 | func maxSiDaiDanLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
868 | // 最大值为2
869 | info = siDaiDanLaiZi(NumTypeTwo, normalCount, laiZiSize)
870 | if info.CardType != CardTypeNone {
871 | return
872 | }
873 |
874 | for i := len(line) - 1; i >= 0; i-- {
875 | if line[i] == NumTypeTwo {
876 | continue
877 | }
878 |
879 | info = siDaiDanLaiZi(line[i], normalCount, laiZiSize)
880 | if info.CardType != CardTypeNone {
881 | return
882 | }
883 | }
884 | return
885 | }
886 |
887 | // 癞子四带单结果
888 | func siDaiDanLaiZi(value int, normalCount countList, laiZiSize int) (info CardTypeInfo) {
889 | var laiZi int
890 |
891 | // 补四张
892 | switch normalCount[value] {
893 | case 0:
894 | laiZi += 4
895 | case 1:
896 | laiZi += 3
897 | case 2:
898 | laiZi += 2
899 | case 3:
900 | laiZi += 1
901 | }
902 |
903 | if laiZi > laiZiSize {
904 | return
905 | }
906 |
907 | info.CardType = CardTypeSiDaiDan
908 | info.MinValue = value
909 | return
910 | }
911 |
912 | // 癞子四带对
913 | func isSiDaiDuiLaiZi(size int, normalCount countList, normalLine lineList, laiZiSize int) (list []*CardTypeInfo) {
914 | if size != 8 {
915 | return
916 | }
917 |
918 | var min CardTypeInfo // 最小值
919 | var max CardTypeInfo // 最大值
920 |
921 | // 非癞子牌有多少种牌值
922 | switch len(normalLine) {
923 | case 0, 1:
924 | return
925 |
926 | default:
927 | for _, v := range normalLine {
928 | if isJoker(v) {
929 | return
930 | }
931 | }
932 |
933 | min = minSiDaiDuiLaiZi(normalCount, normalLine, laiZiSize)
934 | max = maxSiDaiDuiLaiZi(normalCount, normalLine, laiZiSize)
935 | }
936 |
937 | if min.CardType == CardTypeNone && max.CardType == CardTypeNone {
938 | return
939 | }
940 |
941 | if min.MinValue == max.MinValue {
942 | list = append(list, &min)
943 | } else {
944 | list = append(list, &min, &max)
945 | }
946 | return
947 | }
948 |
949 | // 最小癞子四带对
950 | func minSiDaiDuiLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
951 | // 最小值为3
952 | info = siDaiDuiLaiZi(NumTypeThree, normalCount, line, laiZiSize)
953 | if info.CardType != CardTypeNone {
954 | return
955 | }
956 |
957 | for i := 0; i < len(line); i++ {
958 | if line[i] == NumTypeThree {
959 | continue
960 | }
961 |
962 | info = siDaiDuiLaiZi(line[i], normalCount, line, laiZiSize)
963 | if info.CardType != CardTypeNone {
964 | return
965 | }
966 | }
967 | return
968 | }
969 |
970 | // 最大癞子四带对
971 | func maxSiDaiDuiLaiZi(normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
972 | // 最大值为2
973 | info = siDaiDuiLaiZi(NumTypeTwo, normalCount, line, laiZiSize)
974 | if info.CardType != CardTypeNone {
975 | return
976 | }
977 |
978 | for i := len(line) - 1; i >= 0; i-- {
979 | if line[i] == NumTypeTwo {
980 | continue
981 | }
982 |
983 | info = siDaiDuiLaiZi(line[i], normalCount, line, laiZiSize)
984 | if info.CardType != CardTypeNone {
985 | return
986 | }
987 | }
988 | return
989 | }
990 |
991 | // 癞子四带对结果
992 | func siDaiDuiLaiZi(value int, normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
993 | var laiZi int
994 |
995 | // 补四张
996 | switch normalCount[value] {
997 | case 0:
998 | laiZi += 4
999 | case 1:
1000 | laiZi += 3
1001 | case 2:
1002 | laiZi += 2
1003 | case 3:
1004 | laiZi += 1
1005 | }
1006 |
1007 | if laiZi > laiZiSize {
1008 | return
1009 | }
1010 |
1011 | // 补对子
1012 | for _, v := range line {
1013 | if v == value {
1014 | continue
1015 | }
1016 |
1017 | switch normalCount[v] {
1018 | case 0:
1019 | laiZi += 2
1020 | case 1:
1021 | laiZi += 1
1022 | }
1023 |
1024 | if laiZi > laiZiSize {
1025 | return
1026 | }
1027 | }
1028 |
1029 | info.CardType = CardTypeSiDaiDui
1030 | info.MinValue = value
1031 | return
1032 | }
1033 |
1034 | // 癞子连牌(顺子,连对,飞机不带)
1035 | func isLianLaiZi(cardType CardType, size int, normalValue valueList, normalCount countList, normalLine lineList, laiZiSize int) (list []*CardTypeInfo) {
1036 | var min CardTypeInfo // 最小值
1037 | var max CardTypeInfo // 最大值
1038 |
1039 | switch cardType {
1040 | case CardTypeShunZi:
1041 | // 顺子
1042 | if size < 5 || size > 12 {
1043 | return
1044 | }
1045 |
1046 | // 非癞子牌只能有单张
1047 | if len(normalValue[2]) != 0 || len(normalValue[3]) != 0 || len(normalValue[4]) != 0 {
1048 | return
1049 | }
1050 |
1051 | case CardTypeLianDui:
1052 | // 连对
1053 | if size < 6 || size%2 != 0 {
1054 | return
1055 | }
1056 |
1057 | // 非癞子牌只能有单张和对子
1058 | if len(normalValue[3]) != 0 || len(normalValue[4]) != 0 {
1059 | return
1060 | }
1061 |
1062 | case CardTypeFeiJiBuDai:
1063 | // 飞机不带
1064 | if size < 6 || size%3 != 0 {
1065 | return
1066 | }
1067 |
1068 | // 非癞子牌只能有单张和对子和三张
1069 | if len(normalValue[4]) != 0 {
1070 | return
1071 | }
1072 | }
1073 |
1074 | // 非癞子牌有多少种牌值
1075 | switch len(normalLine) {
1076 | case 0, 1:
1077 | return
1078 |
1079 | default:
1080 | for _, v := range normalLine {
1081 | if isJokerAndTwo(v) {
1082 | return
1083 | }
1084 | }
1085 |
1086 | // 最小值
1087 | min = lianLaiZi(ResultTypeMin, cardType, normalCount, normalLine, laiZiSize)
1088 |
1089 | // 最大值
1090 | max = lianLaiZi(ResultTypeMax, cardType, normalCount, normalLine, laiZiSize)
1091 | }
1092 |
1093 | if min.CardType == CardTypeNone && max.CardType == CardTypeNone {
1094 | return
1095 | }
1096 |
1097 | if min.MinValue == max.MinValue {
1098 | list = append(list, &min)
1099 | } else {
1100 | list = append(list, &min, &max)
1101 | }
1102 | return
1103 | }
1104 |
1105 | // 连癞子
1106 | func lianLaiZi(resultType ResultType, cardType CardType, normalCount countList, line lineList, laiZiSize int) (info CardTypeInfo) {
1107 | var laiZi int
1108 |
1109 | // 补牌
1110 | for i := line[0]; i <= line[len(line)-1]; i++ {
1111 | switch normalCount[i] {
1112 | case 0:
1113 | switch cardType {
1114 | case CardTypeShunZi:
1115 | laiZi += 1
1116 | case CardTypeLianDui:
1117 | laiZi += 2
1118 | case CardTypeFeiJiBuDai:
1119 | laiZi += 3
1120 | }
1121 | case 1:
1122 | switch cardType {
1123 | case CardTypeLianDui:
1124 | laiZi += 1
1125 | case CardTypeFeiJiBuDai:
1126 | laiZi += 2
1127 | }
1128 | case 2:
1129 | switch cardType {
1130 | case CardTypeFeiJiBuDai:
1131 | laiZi += 1
1132 | }
1133 | }
1134 | }
1135 |
1136 | if laiZi > laiZiSize {
1137 | return
1138 | }
1139 |
1140 | // 处理多余的癞子
1141 | var laiZiGroup int
1142 | limitLaiZi := laiZiSize - laiZi
1143 | switch cardType {
1144 | case CardTypeShunZi:
1145 | laiZiGroup = limitLaiZi
1146 |
1147 | case CardTypeLianDui:
1148 | laiZiGroup = limitLaiZi / 2
1149 |
1150 | case CardTypeFeiJiBuDai:
1151 | laiZiGroup = limitLaiZi / 3
1152 | }
1153 |
1154 | // 结果处理
1155 | var minValue int
1156 | var maxValue int
1157 | switch resultType {
1158 | case ResultTypeMin:
1159 | if line[0]-laiZiGroup < NumTypeThree {
1160 | minValue = NumTypeThree
1161 | maxValue = line[len(line)-1] + laiZiGroup - (line[0] - NumTypeThree)
1162 | } else {
1163 | minValue = line[0] - laiZiGroup
1164 | maxValue = line[len(line)-1]
1165 | }
1166 |
1167 | case ResultTypeMax:
1168 | if line[len(line)-1]+laiZiGroup > NumTypeAce {
1169 | minValue = line[0] - (laiZiGroup - (NumTypeAce - line[len(line)-1]))
1170 | maxValue = NumTypeAce
1171 | } else {
1172 | minValue = line[0]
1173 | maxValue = line[len(line)-1] + laiZiGroup
1174 | }
1175 | }
1176 |
1177 | switch cardType {
1178 | case CardTypeShunZi:
1179 | info.CardType = CardTypeShunZi
1180 | info.MinValue = minValue
1181 | info.MaxValue = maxValue
1182 | case CardTypeLianDui:
1183 | info.CardType = CardTypeLianDui
1184 | info.MinValue = minValue
1185 | info.MaxValue = maxValue
1186 | case CardTypeFeiJiBuDai:
1187 | info.CardType = CardTypeFeiJiBuDai
1188 | info.MinValue = minValue
1189 | info.MaxValue = maxValue
1190 | }
1191 | return
1192 | }
1193 |
1194 | // 癞子飞机带一
1195 | func isFeiJiDaiYiLaiZi(size int, normalCount countList, normalLine lineList, laiZiSize int) (list []*CardTypeInfo) {
1196 | if size < 8 || size%4 != 0 {
1197 | return
1198 | }
1199 |
1200 | var min CardTypeInfo // 最小值
1201 | var max CardTypeInfo // 最大值
1202 | valueRange := size / 4 // 几飞机
1203 |
1204 | switch len(normalLine) {
1205 | case 0, 1:
1206 | return
1207 |
1208 | default:
1209 | var line []int // 去除2和大小王的值
1210 | for _, v := range normalLine {
1211 | if isJokerAndTwo(v) {
1212 | continue
1213 | }
1214 | line = append(line, v)
1215 | }
1216 |
1217 | // 最小值
1218 | min = minFeiJiDaiYiLaiZi(normalCount, line, valueRange, laiZiSize)
1219 |
1220 | // 最大值
1221 | max = maxFeiJiDaiYiLaiZi(normalCount, line, valueRange, laiZiSize)
1222 | }
1223 |
1224 | if min.CardType == CardTypeNone && max.CardType == CardTypeNone {
1225 | return
1226 | }
1227 |
1228 | if min.MinValue == max.MinValue {
1229 | list = append(list, &min)
1230 | } else {
1231 | list = append(list, &min, &max)
1232 | }
1233 | return
1234 | }
1235 |
1236 | // 最小癞子飞机带一
1237 | func minFeiJiDaiYiLaiZi(normalCount countList, line lineList, valueRange int, laiZiSize int) (info CardTypeInfo) {
1238 | // 最小值为3的飞机
1239 | info = feiJiDaiYiLaiZi(normalCount, NumTypeThree, NumTypeThree+valueRange-1, laiZiSize)
1240 | if info.CardType != CardTypeNone {
1241 | return
1242 | }
1243 |
1244 | // 最小值不为3的飞机
1245 | for i := 0; i < len(line); i++ {
1246 | min := line[i] - valueRange + 1
1247 | if min <= NumTypeThree {
1248 | continue
1249 | }
1250 |
1251 | info = feiJiDaiYiLaiZi(normalCount, min, line[i], laiZiSize)
1252 | if info.CardType != CardTypeNone {
1253 | return
1254 | }
1255 | }
1256 | return
1257 | }
1258 |
1259 | // 最大癞子飞机带一
1260 | func maxFeiJiDaiYiLaiZi(normalCount countList, line lineList, valueRange int, laiZiSize int) (info CardTypeInfo) {
1261 | // 最大值为A的飞机
1262 | info = feiJiDaiYiLaiZi(normalCount, NumTypeAce-valueRange+1, NumTypeAce, laiZiSize)
1263 | if info.CardType != CardTypeNone {
1264 | return
1265 | }
1266 |
1267 | // 最大值不为A的飞机
1268 | for i := len(line) - 1; i >= 0; i-- {
1269 | if line[i] == NumTypeAce {
1270 | continue
1271 | }
1272 |
1273 | min := line[i] - valueRange + 1
1274 | if min <= NumTypeThree {
1275 | info = feiJiDaiYiLaiZi(normalCount, NumTypeThree, NumTypeThree+valueRange-1, laiZiSize)
1276 | if info.CardType != CardTypeNone {
1277 | return
1278 | }
1279 | } else {
1280 | info = feiJiDaiYiLaiZi(normalCount, min, line[i], laiZiSize)
1281 | if info.CardType != CardTypeNone {
1282 | return
1283 | }
1284 | }
1285 | }
1286 | return
1287 | }
1288 |
1289 | // 癞子飞机带一结果
1290 | func feiJiDaiYiLaiZi(normalCount countList, min int, max int, laiZiSize int) (info CardTypeInfo) {
1291 | var laiZi int
1292 |
1293 | // 补飞机
1294 | for i := min; i <= max; i++ {
1295 | switch normalCount[i] {
1296 | case 0:
1297 | laiZi += 3
1298 | case 1:
1299 | laiZi += 2
1300 | case 2:
1301 | laiZi += 1
1302 | }
1303 | }
1304 |
1305 | if laiZi > laiZiSize {
1306 | return
1307 | }
1308 | info.CardType = CardTypeFeiJiDaiYi
1309 | info.MinValue = min
1310 | info.MaxValue = max
1311 | return
1312 | }
1313 |
1314 | // 癞子飞机带二
1315 | func isFeiJiDaiErLaiZi(size int, normalCount countList, normalLine lineList, laiZiSize int) (list []*CardTypeInfo) {
1316 | if size < 10 || size%5 != 0 {
1317 | return
1318 | }
1319 |
1320 | var min CardTypeInfo // 最小值
1321 | var max CardTypeInfo // 最大值
1322 | valueRange := size / 5 // 几飞机
1323 |
1324 | switch len(normalLine) {
1325 | case 0, 1:
1326 | return
1327 |
1328 | default:
1329 | // 不能有大小王
1330 | for _, v := range normalLine {
1331 | if isJoker(v) {
1332 | return
1333 | }
1334 | }
1335 |
1336 | var line []int // 去除2
1337 | for _, v := range normalLine {
1338 | if isJokerAndTwo(v) {
1339 | continue
1340 | }
1341 | line = append(line, v)
1342 | }
1343 |
1344 | // 最小值
1345 | min = minFeiJiDaiErLaiZi(normalCount, line, normalLine, valueRange, laiZiSize)
1346 |
1347 | // 最大值
1348 | max = maxFeiJiDaiErLaiZi(normalCount, line, normalLine, valueRange, laiZiSize)
1349 | }
1350 |
1351 | if min.CardType == CardTypeNone && max.CardType == CardTypeNone {
1352 | return
1353 | }
1354 |
1355 | if min.MinValue == max.MinValue {
1356 | list = append(list, &min)
1357 | } else {
1358 | list = append(list, &min, &max)
1359 | }
1360 | return
1361 | }
1362 |
1363 | // 最小癞子飞机带二
1364 | func minFeiJiDaiErLaiZi(normalCount countList, line lineList, normalLine lineList, valueRange int, laiZiSize int) (info CardTypeInfo) {
1365 | // 最小值为3的飞机
1366 | info = feiJiDaiErLaiZi(normalCount, normalLine, NumTypeThree, NumTypeThree+valueRange-1, laiZiSize)
1367 | if info.CardType != CardTypeNone {
1368 | return
1369 | }
1370 |
1371 | // 最小值不为3的飞机
1372 | for i := 0; i < len(line); i++ {
1373 | min := line[i] - valueRange + 1
1374 | if min <= NumTypeThree {
1375 | continue
1376 | }
1377 |
1378 | info = feiJiDaiErLaiZi(normalCount, normalLine, min, line[i], laiZiSize)
1379 | if info.CardType != CardTypeNone {
1380 | return
1381 | }
1382 | }
1383 | return
1384 | }
1385 |
1386 | // 最大癞子飞机带二
1387 | func maxFeiJiDaiErLaiZi(normalCount countList, line lineList, normalLine lineList, valueRange int, laiZiSize int) (info CardTypeInfo) {
1388 | // 最大值为A的飞机
1389 | info = feiJiDaiErLaiZi(normalCount, normalLine, NumTypeAce-valueRange+1, NumTypeAce, laiZiSize)
1390 | if info.CardType != CardTypeNone {
1391 | return
1392 | }
1393 |
1394 | // 最大值不为A的飞机
1395 | for i := len(line) - 1; i >= 0; i-- {
1396 | if line[i] == NumTypeAce {
1397 | continue
1398 | }
1399 |
1400 | min := line[i] - valueRange + 1
1401 | if min <= NumTypeThree {
1402 | info = feiJiDaiErLaiZi(normalCount, normalLine, NumTypeThree, NumTypeThree+valueRange-1, laiZiSize)
1403 | if info.CardType != CardTypeNone {
1404 | return
1405 | }
1406 | } else {
1407 | info = feiJiDaiErLaiZi(normalCount, normalLine, min, line[i], laiZiSize)
1408 | if info.CardType != CardTypeNone {
1409 | return
1410 | }
1411 | }
1412 | }
1413 | return
1414 | }
1415 |
1416 | // 癞子飞机带二结果
1417 | func feiJiDaiErLaiZi(normalCount countList, normalLine lineList, min int, max int, laiZiSize int) (info CardTypeInfo) {
1418 | var laiZi int
1419 |
1420 | // 补飞机
1421 | for i := min; i <= max; i++ {
1422 | switch normalCount[i] {
1423 | case 0:
1424 | laiZi += 3
1425 | case 1:
1426 | laiZi += 2
1427 | case 2:
1428 | laiZi += 1
1429 | }
1430 |
1431 | if laiZi > laiZiSize {
1432 | return
1433 | }
1434 | }
1435 |
1436 | // 补对子
1437 | for _, v := range normalLine {
1438 | var exist bool
1439 | for i := min; i <= max; i++ {
1440 | if v == i {
1441 | exist = true
1442 | break
1443 | }
1444 | }
1445 |
1446 | if exist {
1447 | continue
1448 | }
1449 |
1450 | switch normalCount[v] {
1451 | case 0:
1452 | laiZi += 2
1453 | case 1:
1454 | laiZi += 1
1455 | }
1456 |
1457 | if laiZi > laiZiSize {
1458 | return
1459 | }
1460 | }
1461 |
1462 | info.CardType = CardTypeFeiJiDaiEr
1463 | info.MinValue = min
1464 | info.MaxValue = max
1465 | return
1466 | }
1467 |
1468 | // 软炸
1469 | func isRuanZhaDan(size int, normalLine lineList) (info CardTypeInfo) {
1470 | if len(normalLine) != 1 {
1471 | return
1472 | }
1473 |
1474 | if isJoker(normalLine[0]) {
1475 | return
1476 | }
1477 |
1478 | switch size {
1479 | case 4:
1480 | info.CardType = CardTypeRuanZhaDan4
1481 |
1482 | case 5:
1483 | info.CardType = CardTypeRuanZhaDan5
1484 |
1485 | case 6:
1486 | info.CardType = CardTypeRuanZhaDan6
1487 |
1488 | case 7:
1489 | info.CardType = CardTypeRuanZhaDan7
1490 |
1491 | case 8:
1492 | info.CardType = CardTypeRuanZhaDan8
1493 |
1494 | case 9:
1495 | info.CardType = CardTypeRuanZhaDan9
1496 |
1497 | case 10:
1498 | info.CardType = CardTypeRuanZhaDan10
1499 |
1500 | case 11:
1501 | info.CardType = CardTypeRuanZhaDan11
1502 |
1503 | case 12:
1504 | info.CardType = CardTypeRuanZhaDan12
1505 | }
1506 |
1507 | if info.CardType == CardTypeNone {
1508 | return
1509 | }
1510 |
1511 | info.MinValue = normalLine[0]
1512 | return
1513 | }
1514 |
1515 | // 四纯癞子炸
1516 | func isChunLaiZiZhaDan(size int, laiZiSize int, laiZiCards []*Card) (info CardTypeInfo) {
1517 | if size != 4 || laiZiSize != 4 {
1518 | return
1519 | }
1520 |
1521 | laiZiDictCards := convertToMap(laiZiCards, nil)
1522 | _, _, laiZiLine := getCountValueLine(laiZiDictCards)
1523 |
1524 | if len(laiZiLine) == 1 {
1525 | info.CardType = CardTypeChunLaiZiZhaDan
1526 | info.MinValue = laiZiLine[0]
1527 | }
1528 | return
1529 | }
1530 |
1531 | // 癞子炸
1532 | func isLaiZiZhaDan(size int, laiZiSize int, laiZiCards []*Card) (info CardTypeInfo) {
1533 | if size != laiZiSize {
1534 | return
1535 | }
1536 |
1537 | switch size {
1538 | case 4:
1539 | laiZiDictCards := convertToMap(laiZiCards, nil)
1540 | _, _, laiZiLine := getCountValueLine(laiZiDictCards)
1541 |
1542 | if len(laiZiLine) != 1 {
1543 | info.CardType = CardTypeLaiZiZhaDan4
1544 | }
1545 |
1546 | case 5:
1547 | info.CardType = CardTypeLaiZiZhaDan5
1548 |
1549 | case 6:
1550 | info.CardType = CardTypeLaiZiZhaDan6
1551 |
1552 | case 7:
1553 | info.CardType = CardTypeLaiZiZhaDan7
1554 |
1555 | case 8:
1556 | info.CardType = CardTypeLaiZiZhaDan8
1557 | }
1558 |
1559 | if info.CardType == CardTypeNone {
1560 | return
1561 | }
1562 | return
1563 | }
1564 |
1565 | // 软连炸
1566 | func isRuanLianZha(size int, normalCount countList, normalLine lineList, laiZiSize int) (info CardTypeInfo) {
1567 | if size < 8 || size%4 != 0 {
1568 | return
1569 | }
1570 |
1571 | // 不能有2和大小王
1572 | for _, v := range normalLine {
1573 | if isJokerAndTwo(v) {
1574 | return
1575 | }
1576 | }
1577 |
1578 | var laiZi int
1579 |
1580 | // 补牌
1581 | for i := normalLine[0]; i <= normalLine[len(normalLine)-1]; i++ {
1582 | switch normalCount[i] {
1583 | case 0:
1584 | laiZi += 4
1585 | case 1:
1586 | laiZi += 3
1587 | case 2:
1588 | laiZi += 2
1589 | case 3:
1590 | laiZi += 1
1591 | }
1592 |
1593 | if laiZi > laiZiSize {
1594 | return
1595 | }
1596 | }
1597 |
1598 | info.CardType = CardTypeRuanLianZha
1599 | info.MinValue = normalLine[0]
1600 | info.MaxValue = normalLine[len(normalLine)-1]
1601 | return
1602 | }
1603 |
--------------------------------------------------------------------------------
/ddz/const.go:
--------------------------------------------------------------------------------
1 | package ddz
2 |
3 | import "strconv"
4 |
5 | // 牌值
6 | type NumType int
7 |
8 | const (
9 | NumTypeNone NumType = iota
10 | NumTypeThree = 3
11 | NumTypeAce = 14
12 | NumTypeTwo = 15
13 | NumTypeSmallJoker = 16
14 | NumTypeBigJoker = 17
15 | )
16 |
17 | func (n NumType) String() string {
18 | switch n {
19 | case 3, 4, 5, 6, 7, 8, 9, 10:
20 | return strconv.Itoa(int(n))
21 | case 11:
22 | return "J"
23 | case 12:
24 | return "Q"
25 | case 13:
26 | return "K"
27 | case NumTypeAce:
28 | return "A"
29 | case NumTypeTwo:
30 | return "2"
31 | case NumTypeSmallJoker:
32 | return "小王"
33 | case NumTypeBigJoker:
34 | return "大王"
35 | default:
36 | return "牌值错误"
37 | }
38 | }
39 |
40 | // 花色
41 | type SuitType int
42 |
43 | const (
44 | SuitTypeNone SuitType = iota
45 | SuitTypeJoker // 鬼牌
46 | SuitTypeHeart // 红桃
47 | SuitTypeSpade // 黑桃
48 | SuitTypeDiamond // 方块
49 | SuitTypeClub // 草花
50 | )
51 |
52 | func (s SuitType) String() string {
53 | switch s {
54 | case SuitTypeJoker:
55 | return "鬼牌"
56 | case SuitTypeHeart:
57 | return "红桃"
58 | case SuitTypeSpade:
59 | return "黑桃"
60 | case SuitTypeDiamond:
61 | return "方块"
62 | case SuitTypeClub:
63 | return "草花"
64 | default:
65 | return "花色错误"
66 | }
67 | }
68 |
69 | // 牌型
70 | type CardType int
71 |
72 | const (
73 | CardTypeNone CardType = iota
74 | CardTypeDan // 单
75 | CardTypeDui // 对
76 | CardTypeSanBuDai // 三不带
77 | CardTypeSanDaiYi // 三带一
78 | CardTypeSanDaiEr // 三带二
79 | CardTypeSiDaiDan // 四带单(炸弹带两张单)
80 | CardTypeSiDaiDui // 四带对(炸弹带两对)
81 | CardTypeShunZi // 顺子
82 | CardTypeLianDui // 连对
83 | CardTypeFeiJiBuDai // 飞机不带
84 | CardTypeFeiJiDaiYi // 飞机带一
85 | CardTypeFeiJiDaiEr // 飞机带二
86 | CardTypeRuanZhaDan4 // 四软炸
87 | CardTypeZhaDan // 硬炸弹
88 | CardTypeLaiZiZhaDan4 // 四癞子炸
89 | CardTypeChunLaiZiZhaDan // 四纯癞子炸
90 | CardTypeRuanZhaDan5 // 五软炸
91 | CardTypeLaiZiZhaDan5 // 五癞子炸
92 | CardTypeRuanZhaDan6 // 六软炸
93 | CardTypeLaiZiZhaDan6 // 六癞子炸
94 | CardTypeRuanZhaDan7 // 七软炸
95 | CardTypeLaiZiZhaDan7 // 七癞子炸
96 | CardTypeRuanZhaDan8 // 八软炸
97 | CardTypeLaiZiZhaDan8 // 八癞子炸
98 | CardTypeRuanZhaDan9 // 九软炸
99 | CardTypeRuanZhaDan10 // 十软炸
100 | CardTypeRuanZhaDan11 // 十一软炸
101 | CardTypeRuanZhaDan12 // 十二软炸
102 | CardTypeHuoJian // 火箭
103 | CardTypeRuanLianZha // 软连炸(癞子只有大小王)
104 | CardTypeLianZha // 硬连炸
105 | )
106 |
107 | func (c CardType) String() string {
108 | switch c {
109 | case CardTypeDan:
110 | return "单"
111 | case CardTypeDui:
112 | return "对"
113 | case CardTypeSanBuDai:
114 | return "三不带"
115 | case CardTypeSanDaiYi:
116 | return "三带一"
117 | case CardTypeSanDaiEr:
118 | return "三带二"
119 | case CardTypeSiDaiDan:
120 | return "四带单(炸弹带两张单)"
121 | case CardTypeSiDaiDui:
122 | return "四带对(炸弹带两对)"
123 | case CardTypeShunZi:
124 | return "顺子"
125 | case CardTypeLianDui:
126 | return "连对"
127 | case CardTypeFeiJiBuDai:
128 | return "飞机不带"
129 | case CardTypeFeiJiDaiYi:
130 | return "飞机带一"
131 | case CardTypeFeiJiDaiEr:
132 | return "飞机带二"
133 | case CardTypeRuanZhaDan4:
134 | return "四软炸"
135 | case CardTypeZhaDan:
136 | return "硬炸弹"
137 | case CardTypeLaiZiZhaDan4:
138 | return "四癞子炸弹"
139 | case CardTypeChunLaiZiZhaDan:
140 | return "四纯癞子炸弹"
141 | case CardTypeRuanZhaDan5:
142 | return "五软炸"
143 | case CardTypeLaiZiZhaDan5:
144 | return "五癞子炸弹"
145 | case CardTypeRuanZhaDan6:
146 | return "六软炸"
147 | case CardTypeLaiZiZhaDan6:
148 | return "六癞子炸弹"
149 | case CardTypeRuanZhaDan7:
150 | return "七软炸"
151 | case CardTypeLaiZiZhaDan7:
152 | return "七癞子炸弹"
153 | case CardTypeRuanZhaDan8:
154 | return "八软炸"
155 | case CardTypeLaiZiZhaDan8:
156 | return "八癞子炸弹"
157 | case CardTypeRuanZhaDan9:
158 | return "九软炸"
159 | case CardTypeRuanZhaDan10:
160 | return "十软炸"
161 | case CardTypeRuanZhaDan11:
162 | return "十一软炸"
163 | case CardTypeRuanZhaDan12:
164 | return "十二软炸"
165 | case CardTypeHuoJian:
166 | return "火箭"
167 | case CardTypeRuanLianZha:
168 | return "软连炸"
169 | case CardTypeLianZha:
170 | return "硬连炸"
171 | default:
172 | return "牌型错误"
173 | }
174 | }
175 |
176 | // 底牌牌型
177 | type BottomCardType int
178 |
179 | const (
180 | BottomCardTypeNone BottomCardType = iota
181 | BottomCardTypeHuoJian // 火箭
182 | BottomCardTypeOneJoker // 单王
183 | BottomCardTypeTongHuaShun // 同花顺
184 | BottomCardTypeTongHua // 同花
185 | BottomCardTypeShunZi // 顺子
186 | BottomCardTypeSanBuDai // 三不带
187 | )
188 |
189 | func (c BottomCardType) String() string {
190 | switch c {
191 | case BottomCardTypeHuoJian:
192 | return "火箭"
193 | case BottomCardTypeOneJoker:
194 | return "单王"
195 | case BottomCardTypeTongHuaShun:
196 | return "同花顺"
197 | case BottomCardTypeTongHua:
198 | return "同花"
199 | case BottomCardTypeShunZi:
200 | return "顺子"
201 | case BottomCardTypeSanBuDai:
202 | return "三不带"
203 | default:
204 | return "底牌牌型错误"
205 | }
206 | }
207 |
208 | // 结果类型
209 | type ResultType int
210 |
211 | const (
212 | ResultTypeNone ResultType = iota
213 | ResultTypeMin // 最小值
214 | ResultTypeMax // 最大值
215 | )
216 |
--------------------------------------------------------------------------------
/ddz/split_card.go:
--------------------------------------------------------------------------------
1 | package ddz
2 |
3 | import (
4 | "sort"
5 | )
6 |
7 | // 拆牌(经典模式)
8 | func SplitCardsJingDian(cards []*Card) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
9 | dictCards := convertToMap(cards, nil)
10 |
11 | size := len(dictCards)
12 | count, value, _ := getCountValueLine(dictCards)
13 |
14 | // 火箭
15 | if retCards, retInfo := findHuoJian(size, dictCards, value); retInfo.CardType != CardTypeNone {
16 | retCardsList = append(retCardsList, retCards)
17 | retInfoList = append(retInfoList, retInfo)
18 |
19 | size = len(dictCards)
20 | count, value, _ = getCountValueLine(dictCards)
21 | }
22 |
23 | // 炸弹
24 | if cardsList, infoList := splitZhaDan(size, dictCards, value); len(infoList) != 0 {
25 | retCardsList = append(retCardsList, cardsList...)
26 | retInfoList = append(retInfoList, infoList...)
27 |
28 | size = len(dictCards)
29 | count, value, _ = getCountValueLine(dictCards)
30 | }
31 |
32 | // 拆2
33 | if retCards, retInfo := splitTwo(dictCards); retInfo.CardType != CardTypeNone {
34 | retCardsList = append(retCardsList, retCards)
35 | retInfoList = append(retInfoList, retInfo)
36 |
37 | size = len(dictCards)
38 | count, value, _ = getCountValueLine(dictCards)
39 | }
40 |
41 | // 拆飞机
42 | if cardsList, infoList := splitFeiJiBuDai(size, dictCards, count, value); len(infoList) != 0 {
43 | retCardsList = append(retCardsList, cardsList...)
44 | retInfoList = append(retInfoList, infoList...)
45 |
46 | size = len(dictCards)
47 | count, value, _ = getCountValueLine(dictCards)
48 | }
49 |
50 | // 拆顺子
51 | if cardsList, infoList := splitShunZi(size, dictCards, count); len(infoList) != 0 {
52 | retCardsList = append(retCardsList, cardsList...)
53 | retInfoList = append(retInfoList, infoList...)
54 |
55 | size = len(dictCards)
56 | count, value, _ = getCountValueLine(dictCards)
57 | }
58 |
59 | // 拆连对
60 | if cardsList, infoList := splitLianDui(size, dictCards, count, value); len(infoList) != 0 {
61 | retCardsList = append(retCardsList, cardsList...)
62 | retInfoList = append(retInfoList, infoList...)
63 |
64 | size = len(dictCards)
65 | count, value, _ = getCountValueLine(dictCards)
66 | }
67 |
68 | // 拆三不带
69 | if cardsList, infoList := splitSanBuDai(size, dictCards, value); len(infoList) != 0 {
70 | retCardsList = append(retCardsList, cardsList...)
71 | retInfoList = append(retInfoList, infoList...)
72 |
73 | size = len(dictCards)
74 | count, value, _ = getCountValueLine(dictCards)
75 | }
76 |
77 | // 拆对
78 | if cardsList, infoList := splitDui(size, dictCards, value); len(infoList) != 0 {
79 | retCardsList = append(retCardsList, cardsList...)
80 | retInfoList = append(retInfoList, infoList...)
81 |
82 | size = len(dictCards)
83 | count, value, _ = getCountValueLine(dictCards)
84 | }
85 |
86 | // 拆单
87 | if cardsList, infoList := splitDan(size, dictCards, value); len(infoList) != 0 {
88 | retCardsList = append(retCardsList, cardsList...)
89 | retInfoList = append(retInfoList, infoList...)
90 |
91 | size = len(dictCards)
92 | count, value, _ = getCountValueLine(dictCards)
93 | }
94 | return
95 | }
96 |
97 | // 拆牌(不洗牌)
98 | func SplitCardsBuXiPai(cards []*Card) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
99 | dictCards := convertToMap(cards, nil)
100 |
101 | size := len(dictCards)
102 | count, value, _ := getCountValueLine(dictCards)
103 |
104 | // 拆连炸
105 | if cardsList, infoList := splitLianZha(size, dictCards, count, value); len(infoList) != 0 {
106 | retCardsList = append(retCardsList, cardsList...)
107 | retInfoList = append(retInfoList, infoList...)
108 |
109 | size = len(dictCards)
110 | count, value, _ = getCountValueLine(dictCards)
111 | }
112 |
113 | // 拆火箭
114 | if retCards, retInfo := findHuoJian(size, dictCards, value); retInfo.CardType != CardTypeNone {
115 | retCardsList = append(retCardsList, retCards)
116 | retInfoList = append(retInfoList, retInfo)
117 |
118 | size = len(dictCards)
119 | count, value, _ = getCountValueLine(dictCards)
120 | }
121 |
122 | // 拆炸弹
123 | if cardsList, infoList := splitZhaDan(size, dictCards, value); len(infoList) != 0 {
124 | retCardsList = append(retCardsList, cardsList...)
125 | retInfoList = append(retInfoList, infoList...)
126 |
127 | size = len(dictCards)
128 | count, value, _ = getCountValueLine(dictCards)
129 | }
130 |
131 | // 拆2
132 | if retCards, retInfo := splitTwo(dictCards); retInfo.CardType != CardTypeNone {
133 | retCardsList = append(retCardsList, retCards)
134 | retInfoList = append(retInfoList, retInfo)
135 |
136 | size = len(dictCards)
137 | count, value, _ = getCountValueLine(dictCards)
138 | }
139 |
140 | // 拆飞机
141 | if cardsList, infoList := splitFeiJiBuDai(size, dictCards, count, value); len(infoList) != 0 {
142 | retCardsList = append(retCardsList, cardsList...)
143 | retInfoList = append(retInfoList, infoList...)
144 |
145 | size = len(dictCards)
146 | count, value, _ = getCountValueLine(dictCards)
147 | }
148 |
149 | // 拆顺子
150 | if cardsList, infoList := splitShunZi(size, dictCards, count); len(infoList) != 0 {
151 | retCardsList = append(retCardsList, cardsList...)
152 | retInfoList = append(retInfoList, infoList...)
153 |
154 | size = len(dictCards)
155 | count, value, _ = getCountValueLine(dictCards)
156 | }
157 |
158 | // 拆连对
159 | if cardsList, infoList := splitLianDui(size, dictCards, count, value); len(infoList) != 0 {
160 | retCardsList = append(retCardsList, cardsList...)
161 | retInfoList = append(retInfoList, infoList...)
162 |
163 | size = len(dictCards)
164 | count, value, _ = getCountValueLine(dictCards)
165 | }
166 |
167 | // 拆三不带
168 | if cardsList, infoList := splitSanBuDai(size, dictCards, value); len(infoList) != 0 {
169 | retCardsList = append(retCardsList, cardsList...)
170 | retInfoList = append(retInfoList, infoList...)
171 |
172 | size = len(dictCards)
173 | count, value, _ = getCountValueLine(dictCards)
174 | }
175 |
176 | // 拆对
177 | if cardsList, infoList := splitDui(size, dictCards, value); len(infoList) != 0 {
178 | retCardsList = append(retCardsList, cardsList...)
179 | retInfoList = append(retInfoList, infoList...)
180 |
181 | size = len(dictCards)
182 | count, value, _ = getCountValueLine(dictCards)
183 | }
184 |
185 | // 拆单
186 | if cardsList, infoList := splitDan(size, dictCards, value); len(infoList) != 0 {
187 | retCardsList = append(retCardsList, cardsList...)
188 | retInfoList = append(retInfoList, infoList...)
189 |
190 | size = len(dictCards)
191 | count, value, _ = getCountValueLine(dictCards)
192 | }
193 | return
194 | }
195 |
196 | // 拆牌(不洗牌+双王癞子模式)
197 | func SplitCardsBuXiPaiLaiZi(cards []*Card, laiZiNums []NumType) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
198 | var normalCards []*Card // 普通牌
199 | var laiZiCards []*Card // 癞子牌
200 | for _, c := range cards {
201 | var exist bool
202 | for _, num := range laiZiNums {
203 | if c.Num == num {
204 | exist = true
205 | break
206 | }
207 | }
208 |
209 | if exist {
210 | laiZiCards = append(laiZiCards, c)
211 | } else {
212 | normalCards = append(normalCards, c)
213 | }
214 | }
215 |
216 | laiZiSize := len(laiZiCards) // 癞子牌数量
217 |
218 | if laiZiSize == 0 {
219 | return SplitCardsBuXiPai(cards)
220 | }
221 |
222 | // 癞子牌
223 | laiZiDictCards := convertToMap(laiZiCards, nil)
224 | _, laiZiValue, _ := getCountValueLine(laiZiDictCards)
225 |
226 | // 非癞子牌拆牌
227 | retCardsList, retInfoList = SplitCardsBuXiPai(normalCards)
228 |
229 | // 拆癞子火箭
230 | if retCards, retInfo := findHuoJian(laiZiSize, laiZiDictCards, laiZiValue); retInfo.CardType != CardTypeNone {
231 | retCardsList = append(retCardsList, retCards)
232 | retInfoList = append(retInfoList, retInfo)
233 |
234 | laiZiSize = len(laiZiDictCards)
235 | if laiZiSize == 0 {
236 | return
237 | }
238 | }
239 |
240 | // 补四软炸(三不带补)
241 | index := -1
242 | max := 0
243 | for i := 0; i < len(retInfoList); i++ {
244 | if retInfoList[i].CardType == CardTypeSanBuDai && max < retInfoList[i].MinValue {
245 | index = i
246 | max = retInfoList[i].MinValue
247 | }
248 | }
249 |
250 | if index >= 0 {
251 | retInfoList[index].CardType = CardTypeRuanZhaDan4
252 | retCardsList[index] = append(retCardsList[index], findCardsLaiZi(laiZiDictCards, 1)...)
253 |
254 | laiZiSize = len(laiZiDictCards)
255 | if laiZiSize == 0 {
256 | return
257 | }
258 | }
259 |
260 | // 补三不带
261 | index = -1
262 | max = 0
263 | for i := 0; i < len(retInfoList); i++ {
264 | if retInfoList[i].CardType == CardTypeDui && max < retInfoList[i].MinValue {
265 | index = i
266 | max = retInfoList[i].MinValue
267 | }
268 | }
269 |
270 | if index >= 0 {
271 | retInfoList[index].CardType = CardTypeSanBuDai
272 | retCardsList[index] = append(retCardsList[index], findCardsLaiZi(laiZiDictCards, 1)...)
273 |
274 | laiZiSize = len(laiZiDictCards)
275 | if laiZiSize == 0 {
276 | return
277 | }
278 | }
279 |
280 | // 补五软炸
281 | index = -1
282 | max = 0
283 | for i := 0; i < len(retInfoList); i++ {
284 | if retInfoList[i].CardType == CardTypeZhaDan && max < retInfoList[i].MinValue {
285 | index = i
286 | max = retInfoList[i].MinValue
287 | }
288 | }
289 |
290 | if index >= 0 {
291 | retInfoList[index].CardType = CardTypeRuanZhaDan5
292 | retCardsList[index] = append(retCardsList[index], findCardsLaiZi(laiZiDictCards, 1)...)
293 |
294 | laiZiSize = len(laiZiDictCards)
295 | if laiZiSize == 0 {
296 | return
297 | }
298 | }
299 |
300 | // 补2
301 | for i := 0; i < len(retInfoList); i++ {
302 | if retInfoList[i].MinValue == NumTypeTwo && retInfoList[i].CardType != CardTypeZhaDan {
303 | retCardsList[i] = append(retCardsList[i], findCardsLaiZi(laiZiDictCards, 1)...)
304 |
305 | if len(retCardsList[i]) == 2 {
306 | retInfoList[i].CardType = CardTypeDui
307 | }
308 |
309 | if len(retCardsList[i]) == 3 {
310 | retInfoList[i].CardType = CardTypeSanBuDai
311 | }
312 |
313 | if len(retCardsList[i]) == 4 {
314 | retInfoList[i].CardType = CardTypeRuanZhaDan4
315 | }
316 |
317 | laiZiSize = len(laiZiDictCards)
318 | if laiZiSize == 0 {
319 | return
320 | }
321 | }
322 | }
323 |
324 | // 当做单牌用
325 | retCards := findCardsLaiZi(laiZiDictCards, 1)
326 | retCardsList = append(retCardsList, retCards)
327 |
328 | var retInfo CardTypeInfo
329 | retInfo.CardType = CardTypeDan
330 | retInfo.MinValue = int(laiZiCards[0].Num)
331 | retInfoList = append(retInfoList, retInfo)
332 | return
333 | }
334 |
335 | // 拆连炸
336 | func splitLianZha(size int, dictCards dictMap, count countList, value valueList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
337 | if size < 8 {
338 | return
339 | }
340 |
341 | for {
342 | var nums []int
343 | var exist bool
344 |
345 | for _, v := range value[4] {
346 | nums = nums[0:0]
347 |
348 | for i := v; i <= NumTypeAce; i++ {
349 | if count[i] != 4 {
350 | break
351 | }
352 |
353 | for j := 0; j < 4; j++ {
354 | nums = append(nums, i)
355 | }
356 | }
357 |
358 | if len(nums) < 8 {
359 | continue
360 | }
361 |
362 | exist = true
363 | var retCards []*Card
364 | var retInfo CardTypeInfo
365 |
366 | retCards = findCardsByNums(dictCards, nums)
367 | retCardsList = append(retCardsList, retCards)
368 |
369 | retInfo.CardType = CardTypeLianZha
370 | retInfo.MinValue = nums[0]
371 | retInfo.MaxValue = nums[len(nums)-1]
372 | retInfoList = append(retInfoList, retInfo)
373 |
374 | count, value, _ = getCountValueLine(dictCards)
375 | break
376 | }
377 |
378 | if !exist {
379 | break
380 | }
381 | }
382 | return
383 | }
384 |
385 | // 拆炸弹
386 | func splitZhaDan(size int, dictCards dictMap, value valueList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
387 | if size < 4 {
388 | return
389 | }
390 |
391 | var nums []int
392 |
393 | for _, v := range value[4] {
394 | nums = nums[0:0]
395 | for i := 0; i < 4; i++ {
396 | nums = append(nums, v)
397 | }
398 |
399 | var retCards []*Card
400 | var retInfo CardTypeInfo
401 |
402 | retCards = findCardsByNums(dictCards, nums)
403 | retCardsList = append(retCardsList, retCards)
404 |
405 | retInfo.CardType = CardTypeZhaDan
406 | retInfo.MinValue = v
407 | retInfoList = append(retInfoList, retInfo)
408 | }
409 | return
410 | }
411 |
412 | // 拆2
413 | func splitTwo(dictCards dictMap) (retCards []*Card, retInfo CardTypeInfo) {
414 | var nums []int
415 | for c := range dictCards {
416 | if c.Num == NumTypeTwo {
417 | nums = append(nums, NumTypeTwo)
418 | }
419 | }
420 |
421 | switch len(nums) {
422 | case 0:
423 | return
424 |
425 | case 1:
426 | retInfo.CardType = CardTypeDan
427 |
428 | case 2:
429 | retInfo.CardType = CardTypeDui
430 |
431 | case 3:
432 | retInfo.CardType = CardTypeSanBuDai
433 |
434 | case 4:
435 | retInfo.CardType = CardTypeZhaDan
436 | }
437 | retInfo.MinValue = NumTypeTwo
438 |
439 | retCards = findCardsByNums(dictCards, nums)
440 | return
441 | }
442 |
443 | // 拆飞机不带
444 | func splitFeiJiBuDai(size int, dictCards dictMap, count countList, value valueList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
445 | if size < 6 {
446 | return
447 | }
448 |
449 | for {
450 | var nums []int
451 | var exist bool
452 |
453 | for _, v := range value[3] {
454 | nums = nums[0:0]
455 |
456 | for i := v; i <= NumTypeAce; i++ {
457 | if count[i] != 3 {
458 | break
459 | }
460 |
461 | for j := 0; j < 3; j++ {
462 | nums = append(nums, i)
463 | }
464 | }
465 |
466 | if len(nums) < 6 {
467 | continue
468 | }
469 |
470 | exist = true
471 | var retCards []*Card
472 | var retInfo CardTypeInfo
473 |
474 | retCards = findCardsByNums(dictCards, nums)
475 | retCardsList = append(retCardsList, retCards)
476 |
477 | retInfo.CardType = CardTypeFeiJiBuDai
478 | retInfo.MinValue = nums[0]
479 | retInfo.MaxValue = nums[len(nums)-1]
480 | retInfoList = append(retInfoList, retInfo)
481 |
482 | count, value, _ = getCountValueLine(dictCards)
483 | break
484 | }
485 |
486 | if !exist {
487 | break
488 | }
489 | }
490 | return
491 | }
492 |
493 | // 拆顺子
494 | func splitShunZi(size int, dictCards dictMap, count countList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
495 | if size < 5 {
496 | return
497 | }
498 |
499 | var nums []int
500 |
501 | for {
502 | var exist bool
503 |
504 | // 取最小的5连
505 | for i := NumTypeThree; i <= NumTypeAce-4; i++ {
506 | nums = nums[0:0]
507 |
508 | for j := i; j <= i+4; j++ {
509 | if count[j] == 0 {
510 | break
511 | }
512 | nums = append(nums, j)
513 | }
514 |
515 | if len(nums) == 5 {
516 | exist = true
517 |
518 | var retCards []*Card
519 | var retInfo CardTypeInfo
520 |
521 | retCards = findCardsByNums(dictCards, nums)
522 | retCardsList = append(retCardsList, retCards)
523 |
524 | retInfo.CardType = CardTypeShunZi
525 | retInfo.MinValue = nums[0]
526 | retInfo.MaxValue = nums[len(nums)-1]
527 | retInfoList = append(retInfoList, retInfo)
528 |
529 | count, _, _ = getCountValueLine(dictCards)
530 | break
531 | }
532 | }
533 |
534 | if !exist {
535 | break
536 | }
537 | }
538 |
539 | if len(retInfoList) == 0 {
540 | return
541 | }
542 |
543 | // 剩余牌合并成新的顺子
544 | for i := 0; i < len(retInfoList); i++ {
545 | nums = nums[0:0]
546 |
547 | for j := retInfoList[i].MaxValue + 1; j <= NumTypeAce; j++ {
548 | if count[j] == 0 {
549 | break
550 | }
551 | nums = append(nums, j)
552 | }
553 |
554 | if len(nums) == 0 {
555 | continue
556 | }
557 |
558 | retCardsList[i] = append(retCardsList[i], findCardsByNums(dictCards, nums)...)
559 | retInfoList[i].MaxValue = nums[len(nums)-1]
560 | count, _, _ = getCountValueLine(dictCards)
561 | }
562 |
563 | // 顺子无缝合并
564 | for i := 0; i < len(retInfoList); {
565 | var exist bool
566 | for j := i + 1; j < len(retInfoList); j++ {
567 | if retInfoList[i].MaxValue+1 == retInfoList[j].MinValue {
568 | // 更长的顺子
569 | retInfoList[j].MinValue = retInfoList[i].MinValue
570 | cards := append(retCardsList[i], retCardsList[j]...)
571 | retCardsList[j] = cards
572 |
573 | exist = true
574 | break
575 | }
576 | }
577 |
578 | if !exist {
579 | i++
580 | } else {
581 | retInfoList = append(retInfoList[0:i], retInfoList[i+1:]...)
582 | retCardsList = append(retCardsList[0:i], retCardsList[i+1:]...)
583 | }
584 | }
585 |
586 | // 顺子完全重合,合并成连对
587 | for i := 0; i < len(retInfoList); {
588 | var exist bool
589 | for j := i + 1; j < len(retInfoList); j++ {
590 | if retInfoList[i] == retInfoList[j] {
591 | // 连对
592 | retInfoList[j].CardType = CardTypeLianDui
593 | cards := append(retCardsList[i], retCardsList[j]...)
594 | sort.Slice(cards, func(i, j int) bool {
595 | return cards[i].Num < cards[j].Num
596 | })
597 | retCardsList[j] = cards
598 |
599 | exist = true
600 | break
601 | }
602 | }
603 |
604 | if !exist {
605 | i++
606 | } else {
607 | retInfoList = append(retInfoList[0:i], retInfoList[i+1:]...)
608 | retCardsList = append(retCardsList[0:i], retCardsList[i+1:]...)
609 | }
610 | }
611 |
612 | // 超过8连的顺子,看能否和剩牌组成连对
613 | for i := 0; i < len(retInfoList); i++ {
614 | if retInfoList[i].CardType != CardTypeShunZi || len(retCardsList[i]) < 8 {
615 | continue
616 | }
617 |
618 | // 前面几张牌能否组成连对
619 | cards := retCardsList[i][0 : len(retCardsList[i])-5]
620 | for j := 0; j < len(cards)-2; j++ {
621 | nums = nums[0:0]
622 |
623 | for k := cards[j].Num; k <= cards[len(cards)-1].Num; k++ {
624 | if count[k] == 0 {
625 | break
626 | }
627 | nums = append(nums, int(k))
628 | }
629 |
630 | // 可以组成连对
631 | if len(nums) >= 3 {
632 | var retCards []*Card
633 | var retInfo CardTypeInfo
634 |
635 | // 顺子中找出连对使用的牌
636 | for _, num := range nums {
637 | for _, c := range retCardsList[i] {
638 | if int(c.Num) == num {
639 | retCards = append(retCards, c)
640 | break
641 | }
642 | }
643 | }
644 |
645 | // 剩牌中找出连对使用的牌
646 | retCards = append(retCards, findCardsByNums(dictCards, nums)...)
647 | count, _, _ = getCountValueLine(dictCards)
648 |
649 | sort.Slice(retCards, func(i, j int) bool {
650 | return retCards[i].Num < retCards[j].Num
651 | })
652 |
653 | retInfo.CardType = CardTypeLianDui
654 | retInfo.MinValue = nums[0]
655 | retInfo.MaxValue = nums[len(nums)-1]
656 |
657 | retCardsList = append(retCardsList, retCards)
658 | retInfoList = append(retInfoList, retInfo)
659 |
660 | // 修改顺子牌型,删除连对中使用的牌
661 | for _, num := range nums {
662 | for k, c := range retCardsList[i] {
663 | if int(c.Num) == num {
664 | retCardsList[i] = append(retCardsList[i][0:k], retCardsList[i][k+1:]...)
665 | break
666 | }
667 | }
668 | }
669 |
670 | // 顺子剩下的牌无法组成顺子,删除断牌,放入剩牌中
671 | for k := 0; j < len(retCardsList[i])-1; {
672 | var exist bool
673 | if retCardsList[i][k].Num+1 != retCardsList[i][k+1].Num {
674 | dictCards[retCardsList[i][j]] = true
675 | count, _, _ = getCountValueLine(dictCards)
676 |
677 | exist = true
678 | }
679 |
680 | if !exist {
681 | break
682 | }
683 | retCardsList[i] = append(retCardsList[i][0:k], retCardsList[i][k+1:]...)
684 | }
685 |
686 | // 确定顺子最终牌型
687 | retInfoList[i].MinValue = nums[len(nums)-1] + 1
688 | }
689 | }
690 |
691 | // 后面几张牌能否组成连对
692 | if len(retCardsList[i]) < 8 {
693 | continue
694 | }
695 |
696 | cards = retCardsList[i][5:len(retCardsList[i])]
697 | for j := 0; j < len(cards)-2; j++ {
698 | nums = nums[0:0]
699 |
700 | for k := cards[j].Num; k <= cards[len(cards)-1].Num; k++ {
701 | if count[k] == 0 {
702 | break
703 | }
704 | nums = append(nums, int(k))
705 | }
706 |
707 | // 可以组成连对
708 | if len(nums) >= 3 {
709 | var retCards []*Card
710 | var retInfo CardTypeInfo
711 |
712 | // 顺子中找出连对使用的牌
713 | for _, num := range nums {
714 | for _, c := range retCardsList[i] {
715 | if int(c.Num) == num {
716 | retCards = append(retCards, c)
717 | break
718 | }
719 | }
720 | }
721 |
722 | // 剩牌中找出连对使用的牌
723 | retCards = append(retCards, findCardsByNums(dictCards, nums)...)
724 | count, _, _ = getCountValueLine(dictCards)
725 |
726 | sort.Slice(retCards, func(i, j int) bool {
727 | return retCards[i].Num < retCards[j].Num
728 | })
729 |
730 | retInfo.CardType = CardTypeLianDui
731 | retInfo.MinValue = nums[0]
732 | retInfo.MaxValue = nums[len(nums)-1]
733 |
734 | retCardsList = append(retCardsList, retCards)
735 | retInfoList = append(retInfoList, retInfo)
736 |
737 | // 修改顺子牌型,删除连对中使用的牌
738 | for _, num := range nums {
739 | for k, c := range retCardsList[i] {
740 | if int(c.Num) == num {
741 | retCardsList[i] = append(retCardsList[i][0:k], retCardsList[i][k+1:]...)
742 | break
743 | }
744 | }
745 | }
746 |
747 | // 顺子剩下的牌无法组成顺子,删除断牌,放入剩牌中
748 | for k := len(retCardsList[i]) - 1; k > 0; {
749 | var exist bool
750 | if retCardsList[i][k].Num-1 != retCardsList[i][k-1].Num {
751 | dictCards[retCardsList[i][k]] = true
752 | count, _, _ = getCountValueLine(dictCards)
753 |
754 | exist = true
755 | }
756 |
757 | if !exist {
758 | break
759 | }
760 |
761 | retCardsList[i] = retCardsList[i][:k]
762 | k--
763 | }
764 |
765 | // 确定顺子最终牌型
766 | retInfoList[i].MaxValue = nums[0] - 1
767 | }
768 | }
769 | }
770 |
771 | // 超过6连的顺子,看能否和剩牌组成三张
772 | for i := 0; i < len(retInfoList); i++ {
773 | if retInfoList[i].CardType != CardTypeShunZi || len(retCardsList[i]) < 6 {
774 | continue
775 | }
776 |
777 | var nums []int
778 |
779 | // 第一张牌和剩牌能否组成三张
780 | card := retCardsList[i][0]
781 | if count[card.Num] == 2 {
782 | for j := 0; j < 2; j++ {
783 | nums = append(nums, int(card.Num))
784 | }
785 |
786 | var retCards []*Card
787 | var retInfo CardTypeInfo
788 |
789 | // 顺子中找出三张使用的牌
790 | for _, c := range retCardsList[i] {
791 | if c.Num == card.Num {
792 | retCards = append(retCards, c)
793 | break
794 | }
795 | }
796 |
797 | // 剩牌中找出三张使用的牌
798 | retCards = append(retCards, findCardsByNums(dictCards, nums)...)
799 | count, _, _ = getCountValueLine(dictCards)
800 |
801 | retInfo.CardType = CardTypeSanBuDai
802 | retInfo.MinValue = nums[0]
803 |
804 | retCardsList = append(retCardsList, retCards)
805 | retInfoList = append(retInfoList, retInfo)
806 |
807 | // 修改顺子牌型,删除三张中使用的牌
808 | for k, c := range retCardsList[i] {
809 | if c.Num == retCardsList[i][0].Num {
810 | retCardsList[i] = append(retCardsList[i][0:k], retCardsList[i][k+1:]...)
811 | break
812 | }
813 | }
814 |
815 | // 确定顺子最终牌型
816 | retInfoList[i].MinValue = retInfoList[i].MinValue + 1
817 | }
818 |
819 | // 最后一张牌和剩牌能否组成三张
820 | if len(retCardsList[i]) < 6 {
821 | continue
822 | }
823 |
824 | card = retCardsList[i][len(retCardsList[i])-1]
825 | if count[card.Num] == 2 {
826 | for j := 0; j < 2; j++ {
827 | nums = append(nums, int(card.Num))
828 | }
829 |
830 | var retCards []*Card
831 | var retInfo CardTypeInfo
832 |
833 | // 顺子中找出三张使用的牌
834 | for _, c := range retCardsList[i] {
835 | if c.Num == card.Num {
836 | retCards = append(retCards, c)
837 | break
838 | }
839 | }
840 |
841 | // 剩牌中找出三张使用的牌
842 | retCards = append(retCards, findCardsByNums(dictCards, nums)...)
843 | count, _, _ = getCountValueLine(dictCards)
844 |
845 | retInfo.CardType = CardTypeSanBuDai
846 | retInfo.MinValue = nums[0]
847 |
848 | retCardsList = append(retCardsList, retCards)
849 | retInfoList = append(retInfoList, retInfo)
850 |
851 | // 修改顺子牌型,删除三张中使用的牌
852 | for k, c := range retCardsList[i] {
853 | if c.Num == card.Num {
854 | retCardsList[i] = append(retCardsList[i][0:k], retCardsList[i][k+1:]...)
855 | break
856 | }
857 | }
858 |
859 | // 确定顺子最终牌型
860 | retInfoList[i].MaxValue = retInfoList[i].MaxValue - 1
861 | }
862 | }
863 | return
864 | }
865 |
866 | // 拆连对
867 | func splitLianDui(size int, dictCards dictMap, count countList, value valueList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
868 | if size < 6 {
869 | return
870 | }
871 |
872 | for {
873 | var nums []int
874 | var exist bool
875 |
876 | for _, v := range value[2] {
877 | nums = nums[0:0]
878 |
879 | for i := v; i <= NumTypeAce; i++ {
880 | if count[i] != 2 {
881 | break
882 | }
883 |
884 | for j := 0; j < 2; j++ {
885 | nums = append(nums, i)
886 | }
887 | }
888 |
889 | if len(nums) < 6 {
890 | continue
891 | }
892 |
893 | exist = true
894 | var retCards []*Card
895 | var retInfo CardTypeInfo
896 |
897 | retCards = findCardsByNums(dictCards, nums)
898 | retCardsList = append(retCardsList, retCards)
899 |
900 | retInfo.CardType = CardTypeLianDui
901 | retInfo.MinValue = nums[0]
902 | retInfo.MaxValue = nums[len(nums)-1]
903 | retInfoList = append(retInfoList, retInfo)
904 |
905 | count, value, _ = getCountValueLine(dictCards)
906 | break
907 | }
908 |
909 | if !exist {
910 | break
911 | }
912 | }
913 | return
914 | }
915 |
916 | // 拆三不带
917 | func splitSanBuDai(size int, dictCards dictMap, value valueList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
918 | if size < 3 {
919 | return
920 | }
921 |
922 | var nums []int
923 |
924 | for _, v := range value[3] {
925 | nums = nums[0:0]
926 |
927 | for i := 0; i < 3; i++ {
928 | nums = append(nums, v)
929 | }
930 |
931 | var retCards []*Card
932 | var retInfo CardTypeInfo
933 |
934 | retCards = findCardsByNums(dictCards, nums)
935 | retCardsList = append(retCardsList, retCards)
936 |
937 | retInfo.CardType = CardTypeSanBuDai
938 | retInfo.MinValue = v
939 | retInfoList = append(retInfoList, retInfo)
940 | }
941 | return
942 | }
943 |
944 | // 拆对子
945 | func splitDui(size int, dictCards dictMap, value valueList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
946 | if size < 2 {
947 | return
948 | }
949 |
950 | var nums []int
951 |
952 | for _, v := range value[2] {
953 | nums = nums[0:0]
954 |
955 | for i := 0; i < 2; i++ {
956 | nums = append(nums, v)
957 | }
958 |
959 | var retCards []*Card
960 | var retInfo CardTypeInfo
961 |
962 | retCards = findCardsByNums(dictCards, nums)
963 | retCardsList = append(retCardsList, retCards)
964 |
965 | retInfo.CardType = CardTypeDui
966 | retInfo.MinValue = v
967 | retInfoList = append(retInfoList, retInfo)
968 | }
969 | return
970 | }
971 |
972 | // 拆单
973 | func splitDan(size int, dictCards dictMap, value valueList) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
974 | if size < 1 {
975 | return
976 | }
977 |
978 | var nums []int
979 |
980 | for _, v := range value[1] {
981 | nums = nums[0:0]
982 |
983 | nums = append(nums, v)
984 |
985 | var retCards []*Card
986 | var retInfo CardTypeInfo
987 |
988 | retCards = findCardsByNums(dictCards, nums)
989 | retCardsList = append(retCardsList, retCards)
990 |
991 | retInfo.CardType = CardTypeDan
992 | retInfo.MinValue = v
993 | retInfoList = append(retInfoList, retInfo)
994 | }
995 | return
996 | }
997 |
998 | // 拆四软炸
999 | func splitRuanZhaDan(size int, laiZiSize int, dictCards dictMap, count countList, value valueList, laiZiDictCards dictMap) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
1000 | if size < 4 || laiZiSize == 0 {
1001 | return
1002 | }
1003 |
1004 | var nums []int
1005 |
1006 | // 补三张
1007 | for _, v := range value[3] {
1008 | for i := 0; i < 3; i++ {
1009 | nums = append(nums, v)
1010 | }
1011 |
1012 | var retCards []*Card
1013 | var retInfo CardTypeInfo
1014 |
1015 | retCards = findCardsByNums(dictCards, nums) // 非癞子牌
1016 | retCards = append(retCards, findCardsLaiZi(laiZiDictCards, 1)...) // 癞子牌
1017 | retCardsList = append(retCardsList, retCards)
1018 |
1019 | retInfo.CardType = CardTypeRuanZhaDan4
1020 | retInfo.MinValue = nums[0]
1021 | retInfoList = append(retInfoList, retInfo)
1022 |
1023 | count, value, _ = getCountValueLine(dictCards)
1024 | laiZiSize = len(laiZiDictCards)
1025 |
1026 | if laiZiSize == 0 {
1027 | return
1028 | }
1029 | }
1030 | return
1031 | }
1032 |
1033 | // 拆癞子飞机
1034 | func splitFeiJiBuDaiLaiZi(size int, laiZiSize int, dictCards dictMap, count countList, value valueList, laiZiDictCards dictMap) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
1035 | if size < 6 {
1036 | return
1037 | }
1038 |
1039 | if laiZiSize == 0 {
1040 | return splitFeiJiBuDai(size, dictCards, count, value)
1041 | }
1042 |
1043 | for i := NumTypeThree; i <= NumTypeAce; i++ {
1044 | var nums []int
1045 | var needLaiZi int
1046 |
1047 | for j := i; j <= NumTypeAce; j++ {
1048 | i = j
1049 |
1050 | if count[j] == 3 {
1051 | for k := 0; k < 3; k++ {
1052 | nums = append(nums, j)
1053 | }
1054 | continue
1055 | }
1056 |
1057 | if count[j] == 2 {
1058 | needLaiZi++
1059 | for k := 0; k < 2; k++ {
1060 | nums = append(nums, j)
1061 | }
1062 |
1063 | if needLaiZi == laiZiSize {
1064 | break
1065 | }
1066 | continue
1067 | }
1068 | break
1069 | }
1070 |
1071 | // 可以补出飞机
1072 | if len(nums) > 0 && nums[len(nums)-1]-nums[0]+1 >= 2 {
1073 | var retCards []*Card
1074 | var retInfo CardTypeInfo
1075 |
1076 | retCards = findCardsByNums(dictCards, nums) // 非癞子牌
1077 | retCards = append(retCards, findCardsLaiZi(laiZiDictCards, needLaiZi)...) // 癞子牌
1078 | retCardsList = append(retCardsList, retCards)
1079 |
1080 | retInfo.CardType = CardTypeFeiJiBuDai
1081 | retInfo.MinValue = nums[0]
1082 | retInfo.MaxValue = nums[len(nums)-1]
1083 | retInfoList = append(retInfoList, retInfo)
1084 |
1085 | count, value, _ = getCountValueLine(dictCards)
1086 | laiZiSize = len(laiZiDictCards)
1087 | }
1088 | }
1089 | return
1090 | }
1091 |
1092 | // 拆癞子三不带
1093 | func splitSanBuDaiLaiZi(size int, laiZiSize int, dictCards dictMap, count countList, value valueList, laiZiDictCards dictMap) (retCardsList [][]*Card, retInfoList []CardTypeInfo) {
1094 | if size < 3 || laiZiSize == 0 {
1095 | return
1096 | }
1097 |
1098 | var nums []int
1099 |
1100 | // 补三张
1101 | for _, v := range value[3] {
1102 | for i := 0; i < 3; i++ {
1103 | nums = append(nums, v)
1104 | }
1105 |
1106 | var retCards []*Card
1107 | var retInfo CardTypeInfo
1108 |
1109 | retCards = findCardsByNums(dictCards, nums) // 非癞子牌
1110 | retCards = append(retCards, findCardsLaiZi(laiZiDictCards, 1)...) // 癞子牌
1111 | retCardsList = append(retCardsList, retCards)
1112 |
1113 | retInfo.CardType = CardTypeRuanZhaDan4
1114 | retInfo.MinValue = nums[0]
1115 | retInfoList = append(retInfoList, retInfo)
1116 |
1117 | count, value, _ = getCountValueLine(dictCards)
1118 | laiZiSize = len(laiZiDictCards)
1119 |
1120 | if laiZiSize == 0 {
1121 | return
1122 | }
1123 | }
1124 | return
1125 | }
1126 |
1127 | // 拆癞子对
1128 |
--------------------------------------------------------------------------------
/ddz/util.go:
--------------------------------------------------------------------------------
1 | package ddz
2 |
3 | import "fmt"
4 |
5 | // 牌型
6 | type CardTypeInfo struct {
7 | CardType CardType // 牌型
8 | MinValue int // 最小值
9 | MaxValue int // 最大值
10 | }
11 |
12 | func (c *CardTypeInfo) Reset() {
13 | c.CardType = CardTypeNone
14 | c.MinValue = 0
15 | c.MaxValue = 0
16 | }
17 |
18 | func (c CardTypeInfo) String() string {
19 | return fmt.Sprintf("牌型:%s 最小值:%d 最大值:%d", c.CardType, c.MinValue, c.MaxValue)
20 | }
21 |
22 | type dictMap map[*Card]bool // 字典,方便找牌
23 | type countList [18]int // 每张牌数量
24 | type valueList [5][]int // 单张,对子,三张,四张牌的牌值
25 | type lineList []int // 所有牌的唯一牌值
26 |
27 | // 切片转map
28 | func convertToMap(cards []*Card, dictCards map[*Card]bool) map[*Card]bool {
29 | if dictCards == nil {
30 | dictCards = map[*Card]bool{}
31 | }
32 |
33 | for _, c := range cards {
34 | dictCards[c] = true
35 | }
36 | return dictCards
37 | }
38 |
39 | // count 每张牌数量
40 | // value[1] 所有单张的牌值
41 | // value[2] 所有对子的牌值
42 | // value[3] 所有三张的牌值
43 | // value[4] 所有四张的牌值
44 | // line 所有牌的唯一牌值
45 | func getCountValueLine(dictCards dictMap) (count countList, value valueList, line lineList) {
46 | // 牌值计数
47 | for c := range dictCards {
48 | count[int(c.Num)]++
49 | }
50 |
51 | for i := 3; i < 18; i++ {
52 | if count[i] > 0 {
53 | line = append(line, i)
54 | }
55 |
56 | switch count[i] {
57 | case 1:
58 | value[1] = append(value[1], i)
59 | case 2:
60 | value[2] = append(value[2], i)
61 | case 3:
62 | value[3] = append(value[3], i)
63 | case 4:
64 | value[4] = append(value[4], i)
65 | }
66 | }
67 | return
68 | }
69 |
70 | // 找牌
71 | func findCardsByNums(dictCards dictMap, nums []int) []*Card {
72 | var findCards []*Card
73 |
74 | for _, num := range nums {
75 | for c := range dictCards {
76 | if c.Num == NumType(num) {
77 | findCards = append(findCards, c)
78 | delete(dictCards, c)
79 | break
80 | }
81 | }
82 | }
83 | return findCards
84 | }
85 |
86 | // 找癞子
87 | func findCardsLaiZi(dictCards dictMap, count int) []*Card {
88 | var findCards []*Card
89 |
90 | for i := 0; i < count; i++ {
91 | for c := range dictCards {
92 | findCards = append(findCards, c)
93 | delete(dictCards, c)
94 | break
95 | }
96 | }
97 | return findCards
98 | }
99 |
100 | // 判断牌值是否是大小王
101 | func isJoker(value int) bool {
102 | if value == NumTypeSmallJoker || value == NumTypeBigJoker {
103 | return true
104 | }
105 | return false
106 | }
107 |
108 | // 判断牌值是否是大小王和2
109 | func isJokerAndTwo(value int) bool {
110 | if value == NumTypeSmallJoker || value == NumTypeBigJoker || value == NumTypeTwo {
111 | return true
112 | }
113 | return false
114 | }
115 |
--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/fattigerlee/poker
2 |
3 | go 1.12
4 |
--------------------------------------------------------------------------------
/test/test_bottom_card.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/fattigerlee/poker/ddz"
6 | )
7 |
8 | func main() {
9 | huoJian()
10 | oneJoker()
11 | tongHuaShun()
12 | tongHua()
13 | shunZi()
14 | sanBuDai()
15 | }
16 |
17 | func huoJian() {
18 | cards := []*ddz.Card{
19 | ddz.NewCard(ddz.SuitTypeJoker, 16, false),
20 | ddz.NewCard(ddz.SuitTypeJoker, 17, false),
21 | ddz.NewCard(ddz.SuitTypeHeart, 3, false),
22 | }
23 | fmt.Println("火箭:", ddz.GetBottomCardType(cards))
24 | }
25 |
26 | func oneJoker() {
27 | cards := []*ddz.Card{
28 | ddz.NewCard(ddz.SuitTypeJoker, 16, false),
29 | ddz.NewCard(ddz.SuitTypeSpade, 3, false),
30 | ddz.NewCard(ddz.SuitTypeHeart, 3, false),
31 | }
32 | fmt.Println("单王:", ddz.GetBottomCardType(cards))
33 | }
34 |
35 | func tongHuaShun() {
36 | cards := []*ddz.Card{
37 | ddz.NewCard(ddz.SuitTypeHeart, 3, false),
38 | ddz.NewCard(ddz.SuitTypeHeart, 4, false),
39 | ddz.NewCard(ddz.SuitTypeHeart, 5, false),
40 | }
41 | fmt.Println("同花顺:", ddz.GetBottomCardType(cards))
42 | }
43 |
44 | func tongHua() {
45 | cards := []*ddz.Card{
46 | ddz.NewCard(ddz.SuitTypeHeart, 3, false),
47 | ddz.NewCard(ddz.SuitTypeHeart, 4, false),
48 | ddz.NewCard(ddz.SuitTypeHeart, 7, false),
49 | }
50 | fmt.Println("同花:", ddz.GetBottomCardType(cards))
51 | }
52 |
53 | func shunZi() {
54 | cards := []*ddz.Card{
55 | ddz.NewCard(ddz.SuitTypeHeart, 3, false),
56 | ddz.NewCard(ddz.SuitTypeHeart, 4, false),
57 | ddz.NewCard(ddz.SuitTypeDiamond, 5, false),
58 | }
59 | fmt.Println("顺子:", ddz.GetBottomCardType(cards))
60 | }
61 |
62 | func sanBuDai() {
63 | cards := []*ddz.Card{
64 | ddz.NewCard(ddz.SuitTypeHeart, 4, false),
65 | ddz.NewCard(ddz.SuitTypeHeart, 4, false),
66 | ddz.NewCard(ddz.SuitTypeDiamond, 4, false),
67 | }
68 | fmt.Println("三不带:", ddz.GetBottomCardType(cards))
69 | }
70 |
--------------------------------------------------------------------------------
/test/test_card_find.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/fattigerlee/poker/ddz"
6 | )
7 |
8 | func main() {
9 | findDan()
10 | findDui()
11 |
12 | findSanBuDai()
13 | findSanDaiYi()
14 | findSanDaiEr()
15 |
16 | findSiDaiDan()
17 | findSiDaiDui()
18 |
19 | findShunZi()
20 | findLianDui()
21 | findFeiJiBuDai()
22 |
23 | findFeiJiDaiYi()
24 | findFeiJiDaiEr()
25 |
26 | findZhaDan()
27 | findHuoJian()
28 | findLianZha()
29 | }
30 |
31 | func findDan() {
32 | var cards []*ddz.Card
33 | var info *ddz.CardTypeInfo
34 | var retCards []*ddz.Card
35 | var retInfo ddz.CardTypeInfo
36 |
37 | cards = []*ddz.Card{
38 | ddz.NewCard(ddz.SuitTypeHeart, 3),
39 | ddz.NewCard(ddz.SuitTypeSpade, 3),
40 | ddz.NewCard(ddz.SuitTypeHeart, 10),
41 | ddz.NewCard(ddz.SuitTypeSpade, 10),
42 | ddz.NewCard(ddz.SuitTypeClub, 7),
43 | }
44 |
45 | info = &ddz.CardTypeInfo{
46 | CardType: ddz.CardTypeDan,
47 | MinValue: 15,
48 | }
49 |
50 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
51 | fmt.Println("单:", retCards, retInfo)
52 |
53 | info = &ddz.CardTypeInfo{
54 | CardType: ddz.CardTypeDan,
55 | MinValue: 3,
56 | }
57 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
58 | fmt.Println("单:", retCards, retInfo)
59 |
60 | info = &ddz.CardTypeInfo{
61 | CardType: ddz.CardTypeDan,
62 | MinValue: 8,
63 | }
64 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
65 | fmt.Println("单:", retCards, retInfo)
66 | }
67 |
68 | func findDui() {
69 | var cards []*ddz.Card
70 | var info *ddz.CardTypeInfo
71 | var retCards []*ddz.Card
72 | var retInfo ddz.CardTypeInfo
73 |
74 | cards = []*ddz.Card{
75 | ddz.NewCard(ddz.SuitTypeHeart, 3),
76 | ddz.NewCard(ddz.SuitTypeSpade, 3),
77 | ddz.NewCard(ddz.SuitTypeClub, 7),
78 | ddz.NewCard(ddz.SuitTypeSpade, 7),
79 | ddz.NewCard(ddz.SuitTypeHeart, 6),
80 | ddz.NewCard(ddz.SuitTypeSpade, 6),
81 | ddz.NewCard(ddz.SuitTypeClub, 4),
82 | ddz.NewCard(ddz.SuitTypeSpade, 4),
83 | ddz.NewCard(ddz.SuitTypeHeart, 5),
84 | ddz.NewCard(ddz.SuitTypeSpade, 5),
85 | ddz.NewCard(ddz.SuitTypeClub, 5),
86 | ddz.NewCard(ddz.SuitTypeSpade, 5),
87 | }
88 |
89 | info = &ddz.CardTypeInfo{
90 | CardType: ddz.CardTypeDui,
91 | MinValue: 3,
92 | }
93 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
94 | fmt.Println("对:", retCards, retInfo)
95 |
96 | info = &ddz.CardTypeInfo{
97 | CardType: ddz.CardTypeDui,
98 | MinValue: 6,
99 | }
100 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
101 | fmt.Println("对:", retCards, retInfo)
102 |
103 | info = &ddz.CardTypeInfo{
104 | CardType: ddz.CardTypeDui,
105 | MinValue: 8,
106 | }
107 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
108 | fmt.Println("对:", retCards, retInfo)
109 |
110 | cards = []*ddz.Card{
111 | ddz.NewCard(ddz.SuitTypeSpade, 12),
112 | ddz.NewCard(ddz.SuitTypeClub, 12),
113 | ddz.NewCard(ddz.SuitTypeSpade, 12),
114 | }
115 |
116 | info = &ddz.CardTypeInfo{
117 | CardType: ddz.CardTypeDui,
118 | MinValue: 3,
119 | }
120 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
121 | fmt.Println("对:", retCards, retInfo)
122 | }
123 |
124 | func findSanBuDai() {
125 | var cards []*ddz.Card
126 | var info *ddz.CardTypeInfo
127 | var retCards []*ddz.Card
128 | var retInfo ddz.CardTypeInfo
129 |
130 | cards = []*ddz.Card{
131 | ddz.NewCard(ddz.SuitTypeHeart, 4),
132 | ddz.NewCard(ddz.SuitTypeSpade, 4),
133 | ddz.NewCard(ddz.SuitTypeClub, 4),
134 | ddz.NewCard(ddz.SuitTypeSpade, 4),
135 | }
136 |
137 | info = &ddz.CardTypeInfo{
138 | CardType: ddz.CardTypeSanBuDai,
139 | MinValue: 3,
140 | }
141 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
142 | fmt.Println("三不带:", retCards, retInfo)
143 | }
144 |
145 | func findSanDaiYi() {
146 | var cards []*ddz.Card
147 | var info *ddz.CardTypeInfo
148 | var retCards []*ddz.Card
149 | var retInfo ddz.CardTypeInfo
150 |
151 | cards = []*ddz.Card{
152 | ddz.NewCard(ddz.SuitTypeJoker, 17),
153 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
154 | ddz.NewCard(ddz.SuitTypeSpade, 4),
155 | ddz.NewCard(ddz.SuitTypeClub, 4),
156 | ddz.NewCard(ddz.SuitTypeHeart, 6),
157 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
158 | ddz.NewCard(ddz.SuitTypeSpade, 5),
159 | ddz.NewCard(ddz.SuitTypeClub, 5),
160 | ddz.NewCard(ddz.SuitTypeHeart, 5),
161 | }
162 |
163 | info = &ddz.CardTypeInfo{
164 | CardType: ddz.CardTypeSanDaiYi,
165 | MinValue: 3,
166 | }
167 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
168 | fmt.Println("三带一:", retCards, retInfo)
169 |
170 | cards = []*ddz.Card{
171 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
172 | ddz.NewCard(ddz.SuitTypeSpade, 4),
173 | ddz.NewCard(ddz.SuitTypeClub, 4),
174 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
175 | ddz.NewCard(ddz.SuitTypeSpade, 5),
176 | ddz.NewCard(ddz.SuitTypeClub, 5),
177 | ddz.NewCard(ddz.SuitTypeHeart, 5),
178 | }
179 |
180 | info = &ddz.CardTypeInfo{
181 | CardType: ddz.CardTypeSanDaiYi,
182 | MinValue: 3,
183 | }
184 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
185 | fmt.Println("三带一:", retCards, retInfo)
186 | }
187 |
188 | func findSanDaiEr() {
189 | var cards []*ddz.Card
190 | var info *ddz.CardTypeInfo
191 | var retCards []*ddz.Card
192 | var retInfo ddz.CardTypeInfo
193 |
194 | cards = []*ddz.Card{
195 | ddz.NewCard(ddz.SuitTypeSpade, 3),
196 | ddz.NewCard(ddz.SuitTypeClub, 3),
197 | ddz.NewCard(ddz.SuitTypeSpade, 12),
198 | ddz.NewCard(ddz.SuitTypeClub, 12),
199 | ddz.NewCard(ddz.SuitTypeHeart, 12),
200 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
201 | ddz.NewCard(ddz.SuitTypeSpade, 13),
202 | ddz.NewCard(ddz.SuitTypeClub, 13),
203 | ddz.NewCard(ddz.SuitTypeHeart, 13),
204 | }
205 |
206 | info = &ddz.CardTypeInfo{
207 | CardType: ddz.CardTypeSanDaiEr,
208 | MinValue: 8,
209 | }
210 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
211 | fmt.Println("三带二:", retCards, retInfo)
212 |
213 | info = &ddz.CardTypeInfo{
214 | CardType: ddz.CardTypeSanDaiEr,
215 | MinValue: 14,
216 | }
217 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
218 | fmt.Println("三带二:", retCards, retInfo)
219 | }
220 |
221 | func findSiDaiDan() {
222 | var cards []*ddz.Card
223 | var info *ddz.CardTypeInfo
224 | var retCards []*ddz.Card
225 | var retInfo ddz.CardTypeInfo
226 |
227 | cards = []*ddz.Card{
228 | ddz.NewCard(ddz.SuitTypeSpade, 3),
229 | ddz.NewCard(ddz.SuitTypeClub, 3),
230 | ddz.NewCard(ddz.SuitTypeSpade, 12),
231 | ddz.NewCard(ddz.SuitTypeClub, 12),
232 | ddz.NewCard(ddz.SuitTypeHeart, 12),
233 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
234 | ddz.NewCard(ddz.SuitTypeSpade, 13),
235 | ddz.NewCard(ddz.SuitTypeClub, 13),
236 | ddz.NewCard(ddz.SuitTypeHeart, 13),
237 | }
238 |
239 | info = &ddz.CardTypeInfo{
240 | CardType: ddz.CardTypeSiDaiDan,
241 | MinValue: 8,
242 | }
243 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
244 | fmt.Println("四带单:", retCards, retInfo)
245 |
246 | info = &ddz.CardTypeInfo{
247 | CardType: ddz.CardTypeSiDaiDan,
248 | MinValue: 14,
249 | }
250 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
251 | fmt.Println("四带单:", retCards, retInfo)
252 | }
253 |
254 | func findSiDaiDui() {
255 | var cards []*ddz.Card
256 | var info *ddz.CardTypeInfo
257 | var retCards []*ddz.Card
258 | var retInfo ddz.CardTypeInfo
259 |
260 | cards = []*ddz.Card{
261 | ddz.NewCard(ddz.SuitTypeSpade, 3),
262 | ddz.NewCard(ddz.SuitTypeClub, 3),
263 | ddz.NewCard(ddz.SuitTypeSpade, 4),
264 | ddz.NewCard(ddz.SuitTypeClub, 4),
265 | ddz.NewCard(ddz.SuitTypeSpade, 12),
266 | ddz.NewCard(ddz.SuitTypeClub, 12),
267 | ddz.NewCard(ddz.SuitTypeHeart, 12),
268 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
269 | ddz.NewCard(ddz.SuitTypeSpade, 13),
270 | ddz.NewCard(ddz.SuitTypeClub, 13),
271 | ddz.NewCard(ddz.SuitTypeHeart, 13),
272 | }
273 |
274 | info = &ddz.CardTypeInfo{
275 | CardType: ddz.CardTypeSiDaiDui,
276 | MinValue: 8,
277 | }
278 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
279 | fmt.Println("四带对:", retCards, retInfo)
280 |
281 | info = &ddz.CardTypeInfo{
282 | CardType: ddz.CardTypeSiDaiDui,
283 | MinValue: 14,
284 | }
285 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
286 | fmt.Println("四带对:", retCards, retInfo)
287 | }
288 |
289 | func findShunZi() {
290 | var cards []*ddz.Card
291 | var info *ddz.CardTypeInfo
292 | var retCards []*ddz.Card
293 | var retInfo ddz.CardTypeInfo
294 |
295 | cards = []*ddz.Card{
296 | ddz.NewCard(ddz.SuitTypeSpade, 4),
297 | ddz.NewCard(ddz.SuitTypeClub, 5),
298 | ddz.NewCard(ddz.SuitTypeSpade, 7),
299 | ddz.NewCard(ddz.SuitTypeHeart, 6),
300 | ddz.NewCard(ddz.SuitTypeSpade, 8),
301 | ddz.NewCard(ddz.SuitTypeClub, 9),
302 | ddz.NewCard(ddz.SuitTypeSpade, 10),
303 | ddz.NewCard(ddz.SuitTypeHeart, 11),
304 | ddz.NewCard(ddz.SuitTypeSpade, 12),
305 | ddz.NewCard(ddz.SuitTypeSpade, 13),
306 | ddz.NewCard(ddz.SuitTypeSpade, 14),
307 | ddz.NewCard(ddz.SuitTypeJoker, 16),
308 | ddz.NewCard(ddz.SuitTypeJoker, 17),
309 | }
310 |
311 | info = &ddz.CardTypeInfo{
312 | CardType: ddz.CardTypeShunZi,
313 | MinValue: 3,
314 | MaxValue: 13,
315 | }
316 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
317 | fmt.Println("顺子:", retCards, retInfo)
318 |
319 | info = &ddz.CardTypeInfo{
320 | CardType: ddz.CardTypeShunZi,
321 | MinValue: 6,
322 | MaxValue: 13,
323 | }
324 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
325 | fmt.Println("顺子:", retCards, retInfo)
326 |
327 | info = &ddz.CardTypeInfo{
328 | CardType: ddz.CardTypeShunZi,
329 | MinValue: 10,
330 | MaxValue: 14,
331 | }
332 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
333 | fmt.Println("顺子:", retCards, retInfo)
334 | }
335 |
336 | func findLianDui() {
337 | var cards []*ddz.Card
338 | var info *ddz.CardTypeInfo
339 | var retCards []*ddz.Card
340 | var retInfo ddz.CardTypeInfo
341 |
342 | cards = []*ddz.Card{
343 | ddz.NewCard(ddz.SuitTypeHeart, 3),
344 | ddz.NewCard(ddz.SuitTypeSpade, 3),
345 | ddz.NewCard(ddz.SuitTypeClub, 4),
346 | ddz.NewCard(ddz.SuitTypeSpade, 4),
347 | ddz.NewCard(ddz.SuitTypeHeart, 5),
348 | ddz.NewCard(ddz.SuitTypeSpade, 5),
349 | ddz.NewCard(ddz.SuitTypeClub, 5),
350 | ddz.NewCard(ddz.SuitTypeSpade, 5),
351 | ddz.NewCard(ddz.SuitTypeHeart, 6),
352 | ddz.NewCard(ddz.SuitTypeSpade, 6),
353 | ddz.NewCard(ddz.SuitTypeClub, 7),
354 | ddz.NewCard(ddz.SuitTypeSpade, 7),
355 | ddz.NewCard(ddz.SuitTypeClub, 8),
356 | ddz.NewCard(ddz.SuitTypeSpade, 8),
357 | }
358 |
359 | info = &ddz.CardTypeInfo{
360 | CardType: ddz.CardTypeLianDui,
361 | MinValue: 3,
362 | MaxValue: 5,
363 | }
364 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
365 | fmt.Println("连对:", retCards, retInfo)
366 |
367 | info = &ddz.CardTypeInfo{
368 | CardType: ddz.CardTypeLianDui,
369 | MinValue: 4,
370 | MaxValue: 6,
371 | }
372 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
373 | fmt.Println("连对:", retCards, retInfo)
374 |
375 | info = &ddz.CardTypeInfo{
376 | CardType: ddz.CardTypeLianDui,
377 | MinValue: 5,
378 | MaxValue: 8,
379 | }
380 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
381 | fmt.Println("连对:", retCards, retInfo)
382 | }
383 |
384 | func findFeiJiBuDai() {
385 | var cards []*ddz.Card
386 | var info *ddz.CardTypeInfo
387 | var retCards []*ddz.Card
388 | var retInfo ddz.CardTypeInfo
389 |
390 | cards = []*ddz.Card{
391 | ddz.NewCard(ddz.SuitTypeHeart, 13),
392 | ddz.NewCard(ddz.SuitTypeSpade, 13),
393 | ddz.NewCard(ddz.SuitTypeClub, 13),
394 | ddz.NewCard(ddz.SuitTypeSpade, 14),
395 | ddz.NewCard(ddz.SuitTypeHeart, 14),
396 | ddz.NewCard(ddz.SuitTypeSpade, 14),
397 | ddz.NewCard(ddz.SuitTypeClub, 9),
398 | ddz.NewCard(ddz.SuitTypeSpade, 10),
399 | ddz.NewCard(ddz.SuitTypeHeart, 11),
400 | ddz.NewCard(ddz.SuitTypeSpade, 12),
401 | }
402 |
403 | info = &ddz.CardTypeInfo{
404 | CardType: ddz.CardTypeFeiJiBuDai,
405 | MinValue: 12,
406 | MaxValue: 13,
407 | }
408 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
409 | fmt.Println("飞机不带:", retCards, retInfo)
410 | }
411 |
412 | func findFeiJiDaiYi() {
413 | var cards []*ddz.Card
414 | var info *ddz.CardTypeInfo
415 | var retCards []*ddz.Card
416 | var retInfo ddz.CardTypeInfo
417 |
418 | cards = []*ddz.Card{
419 | ddz.NewCard(ddz.SuitTypeHeart, 11),
420 | ddz.NewCard(ddz.SuitTypeSpade, 11),
421 | ddz.NewCard(ddz.SuitTypeClub, 11),
422 | ddz.NewCard(ddz.SuitTypeHeart, 12),
423 | ddz.NewCard(ddz.SuitTypeSpade, 12),
424 | ddz.NewCard(ddz.SuitTypeClub, 12),
425 | ddz.NewCard(ddz.SuitTypeHeart, 13),
426 | ddz.NewCard(ddz.SuitTypeSpade, 13),
427 | ddz.NewCard(ddz.SuitTypeClub, 13),
428 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
429 | ddz.NewCard(ddz.SuitTypeHeart, 14),
430 | ddz.NewCard(ddz.SuitTypeSpade, 14),
431 | ddz.NewCard(ddz.SuitTypeClub, 14),
432 | ddz.NewCard(ddz.SuitTypeSpade, 10),
433 | }
434 |
435 | info = &ddz.CardTypeInfo{
436 | CardType: ddz.CardTypeFeiJiDaiYi,
437 | MinValue: 12,
438 | MaxValue: 13,
439 | }
440 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
441 | fmt.Println("飞机带一:", retCards, retInfo)
442 |
443 | info = &ddz.CardTypeInfo{
444 | CardType: ddz.CardTypeFeiJiDaiYi,
445 | MinValue: 9,
446 | MaxValue: 10,
447 | }
448 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
449 | fmt.Println("飞机带一:", retCards, retInfo)
450 | }
451 |
452 | func findFeiJiDaiEr() {
453 | var cards []*ddz.Card
454 | var info *ddz.CardTypeInfo
455 | var retCards []*ddz.Card
456 | var retInfo ddz.CardTypeInfo
457 |
458 | cards = []*ddz.Card{
459 | ddz.NewCard(ddz.SuitTypeHeart, 9),
460 | ddz.NewCard(ddz.SuitTypeSpade, 9),
461 | ddz.NewCard(ddz.SuitTypeClub, 9),
462 | ddz.NewCard(ddz.SuitTypeHeart, 10),
463 | ddz.NewCard(ddz.SuitTypeSpade, 10),
464 | ddz.NewCard(ddz.SuitTypeClub, 10),
465 | ddz.NewCard(ddz.SuitTypeHeart, 13),
466 | ddz.NewCard(ddz.SuitTypeSpade, 13),
467 | ddz.NewCard(ddz.SuitTypeClub, 13),
468 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
469 | ddz.NewCard(ddz.SuitTypeHeart, 14),
470 | ddz.NewCard(ddz.SuitTypeSpade, 14),
471 | ddz.NewCard(ddz.SuitTypeClub, 14),
472 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
473 | ddz.NewCard(ddz.SuitTypeSpade, 3),
474 | ddz.NewCard(ddz.SuitTypeClub, 3),
475 | ddz.NewCard(ddz.SuitTypeSpade, 15),
476 | ddz.NewCard(ddz.SuitTypeClub, 15),
477 | }
478 |
479 | info = &ddz.CardTypeInfo{
480 | CardType: ddz.CardTypeFeiJiDaiEr,
481 | MinValue: 7,
482 | MaxValue: 8,
483 | }
484 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
485 | fmt.Println("飞机带二:", retCards, retInfo)
486 |
487 | info = &ddz.CardTypeInfo{
488 | CardType: ddz.CardTypeFeiJiDaiEr,
489 | MinValue: 7,
490 | MaxValue: 9,
491 | }
492 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
493 | fmt.Println("飞机带二:", retCards, retInfo)
494 | }
495 |
496 | func findZhaDan() {
497 | var cards []*ddz.Card
498 | var info *ddz.CardTypeInfo
499 | var retCards []*ddz.Card
500 | var retInfo ddz.CardTypeInfo
501 |
502 | cards = []*ddz.Card{
503 | ddz.NewCard(ddz.SuitTypeHeart, 10),
504 | ddz.NewCard(ddz.SuitTypeSpade, 10),
505 | ddz.NewCard(ddz.SuitTypeClub, 10),
506 | ddz.NewCard(ddz.SuitTypeHeart, 10),
507 | ddz.NewCard(ddz.SuitTypeHeart, 13),
508 | ddz.NewCard(ddz.SuitTypeSpade, 13),
509 | ddz.NewCard(ddz.SuitTypeClub, 13),
510 | ddz.NewCard(ddz.SuitTypeHeart, 14),
511 | ddz.NewCard(ddz.SuitTypeSpade, 14),
512 | ddz.NewCard(ddz.SuitTypeClub, 14),
513 | ddz.NewCard(ddz.SuitTypeSpade, 12),
514 | ddz.NewCard(ddz.SuitTypeClub, 12),
515 | ddz.NewCard(ddz.SuitTypeJoker, 16),
516 | ddz.NewCard(ddz.SuitTypeJoker, 17),
517 | }
518 |
519 | info = &ddz.CardTypeInfo{
520 | CardType: ddz.CardTypeZhaDan,
521 | MinValue: 12,
522 | MaxValue: 0,
523 | }
524 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
525 | fmt.Println("炸弹:", retCards, retInfo)
526 |
527 | info = &ddz.CardTypeInfo{
528 | CardType: ddz.CardTypeZhaDan,
529 | MinValue: 14,
530 | MaxValue: 0,
531 | }
532 | retCards, retInfo = ddz.FindCardsJingDian(info, cards)
533 | fmt.Println("炸弹:", retCards, retInfo)
534 | }
535 |
536 | func findHuoJian() {
537 | var cards []*ddz.Card
538 | var info *ddz.CardTypeInfo
539 | var retCards []*ddz.Card
540 | var retInfo ddz.CardTypeInfo
541 |
542 | cards = []*ddz.Card{
543 | ddz.NewCard(ddz.SuitTypeHeart, 13),
544 | ddz.NewCard(ddz.SuitTypeSpade, 13),
545 | ddz.NewCard(ddz.SuitTypeClub, 13),
546 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
547 | ddz.NewCard(ddz.SuitTypeHeart, 14),
548 | ddz.NewCard(ddz.SuitTypeSpade, 14),
549 | ddz.NewCard(ddz.SuitTypeClub, 14),
550 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
551 | ddz.NewCard(ddz.SuitTypeSpade, 12),
552 | ddz.NewCard(ddz.SuitTypeClub, 12),
553 | ddz.NewCard(ddz.SuitTypeSpade, 11),
554 | ddz.NewCard(ddz.SuitTypeClub, 11),
555 | ddz.NewCard(ddz.SuitTypeJoker, 16),
556 | ddz.NewCard(ddz.SuitTypeJoker, 17),
557 | }
558 |
559 | info = &ddz.CardTypeInfo{
560 | CardType: ddz.CardTypeHuoJian,
561 | MinValue: 0,
562 | MaxValue: 0,
563 | }
564 | retCards, retInfo = ddz.FindCardsBuXiPai(info, cards)
565 | fmt.Println("火箭:", retCards, retInfo)
566 | }
567 |
568 | func findLianZha() {
569 | var cards []*ddz.Card
570 | var info *ddz.CardTypeInfo
571 | var retCards []*ddz.Card
572 | var retInfo ddz.CardTypeInfo
573 |
574 | cards = []*ddz.Card{
575 | ddz.NewCard(ddz.SuitTypeHeart, 7),
576 | ddz.NewCard(ddz.SuitTypeSpade, 7),
577 | ddz.NewCard(ddz.SuitTypeClub, 7),
578 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
579 | ddz.NewCard(ddz.SuitTypeHeart, 8),
580 | ddz.NewCard(ddz.SuitTypeSpade, 8),
581 | ddz.NewCard(ddz.SuitTypeClub, 8),
582 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
583 | ddz.NewCard(ddz.SuitTypeSpade, 9),
584 | ddz.NewCard(ddz.SuitTypeClub, 9),
585 | ddz.NewCard(ddz.SuitTypeSpade, 9),
586 | ddz.NewCard(ddz.SuitTypeClub, 9),
587 | ddz.NewCard(ddz.SuitTypeHeart, 10),
588 | ddz.NewCard(ddz.SuitTypeSpade, 10),
589 | ddz.NewCard(ddz.SuitTypeClub, 10),
590 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
591 | }
592 |
593 | info = &ddz.CardTypeInfo{
594 | CardType: ddz.CardTypeZhaDan,
595 | MinValue: 12,
596 | MaxValue: 0,
597 | }
598 | retCards, retInfo = ddz.FindCardsBuXiPai(info, cards)
599 | fmt.Println("连炸:", retCards, retInfo)
600 |
601 | info = &ddz.CardTypeInfo{
602 | CardType: ddz.CardTypeLianZha,
603 | MinValue: 13,
604 | MaxValue: 14,
605 | }
606 | retCards, retInfo = ddz.FindCardsBuXiPai(info, cards)
607 | fmt.Println("连炸:", retCards, retInfo)
608 |
609 | cards = []*ddz.Card{
610 | ddz.NewCard(ddz.SuitTypeHeart, 14),
611 | ddz.NewCard(ddz.SuitTypeSpade, 14),
612 | ddz.NewCard(ddz.SuitTypeClub, 14),
613 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
614 | ddz.NewCard(ddz.SuitTypeHeart, 15),
615 | ddz.NewCard(ddz.SuitTypeSpade, 15),
616 | ddz.NewCard(ddz.SuitTypeClub, 15),
617 | ddz.NewCard(ddz.SuitTypeDiamond, 15),
618 | ddz.NewCard(ddz.SuitTypeSpade, 9),
619 | ddz.NewCard(ddz.SuitTypeClub, 9),
620 | ddz.NewCard(ddz.SuitTypeSpade, 9),
621 | ddz.NewCard(ddz.SuitTypeClub, 9),
622 | }
623 |
624 | info = &ddz.CardTypeInfo{
625 | CardType: ddz.CardTypeHuoJian,
626 | MinValue: 0,
627 | MaxValue: 0,
628 | }
629 | retCards, retInfo = ddz.FindCardsBuXiPai(info, cards)
630 | fmt.Println("连炸:", retCards, retInfo)
631 | }
632 |
--------------------------------------------------------------------------------
/test/test_card_find_lai_zi.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/fattigerlee/poker/ddz"
6 | )
7 |
8 | func main() {
9 | laiZiNums := []ddz.NumType{16, 17}
10 |
11 | findDanLaiZi(laiZiNums)
12 | findDuiLaiZi(laiZiNums)
13 |
14 | findSanBuDaiLaiZi(laiZiNums)
15 | findSanDaiYiLaiZi(laiZiNums)
16 | findSanDaiErLaiZi(laiZiNums)
17 |
18 | findShunZiLaiZi(laiZiNums)
19 |
20 | findSiDaiDanLaiZi(laiZiNums)
21 | findSiDaiDuiLaiZi(laiZiNums)
22 |
23 | findZhaDanLaiZi(laiZiNums)
24 | findRuanZhaDan4(laiZiNums)
25 | findRuanZhaDan5(laiZiNums)
26 | findLaiZiZhaDan4(laiZiNums)
27 | findChunLaiZiZhaDan(laiZiNums)
28 |
29 | findHuoJianLaiZi(laiZiNums)
30 | findRuanLianZha(laiZiNums)
31 | findLianZhaLaiZi(laiZiNums)
32 |
33 | findRuanZhaDan6(laiZiNums)
34 | }
35 |
36 | // 单张
37 | func findDanLaiZi(laiZiNums []ddz.NumType) {
38 | var cards []*ddz.Card
39 | var info *ddz.CardTypeInfo
40 | var retCards []*ddz.Card
41 | var retInfo ddz.CardTypeInfo
42 |
43 | cards = []*ddz.Card{
44 | ddz.NewCard(ddz.SuitTypeClub, 9),
45 | ddz.NewCard(ddz.SuitTypeSpade, 10),
46 | ddz.NewCard(ddz.SuitTypeHeart, 11),
47 | }
48 |
49 | info = &ddz.CardTypeInfo{
50 | CardType: ddz.CardTypeDan,
51 | MinValue: 8,
52 | }
53 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
54 | fmt.Println("单张:", retCards, retInfo)
55 |
56 | cards = []*ddz.Card{
57 | ddz.NewCard(ddz.SuitTypeClub, 9),
58 | ddz.NewCard(ddz.SuitTypeSpade, 10),
59 | }
60 |
61 | info = &ddz.CardTypeInfo{
62 | CardType: ddz.CardTypeDan,
63 | MinValue: 8,
64 | }
65 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
66 | fmt.Println("单张:", retCards, retInfo)
67 |
68 | cards = []*ddz.Card{
69 | ddz.NewCard(ddz.SuitTypeClub, 9),
70 | ddz.NewCard(ddz.SuitTypeSpade, 10),
71 | ddz.NewCard(ddz.SuitTypeHeart, 13),
72 | ddz.NewCard(ddz.SuitTypeSpade, 13),
73 | ddz.NewCard(ddz.SuitTypeClub, 13),
74 | }
75 |
76 | info = &ddz.CardTypeInfo{
77 | CardType: ddz.CardTypeDan,
78 | MinValue: 14,
79 | }
80 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
81 | fmt.Println("单张:", retCards, retInfo)
82 |
83 | cards = []*ddz.Card{
84 | ddz.NewCard(ddz.SuitTypeJoker, 16),
85 | ddz.NewCard(ddz.SuitTypeJoker, 17),
86 | }
87 |
88 | info = &ddz.CardTypeInfo{
89 | CardType: ddz.CardTypeDan,
90 | MinValue: 14,
91 | }
92 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
93 | fmt.Println("单张:", retCards, retInfo)
94 |
95 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
96 | fmt.Println("单张:", retCards, retInfo)
97 | }
98 |
99 | // 对子
100 | func findDuiLaiZi(laiZiNums []ddz.NumType) {
101 | var cards []*ddz.Card
102 | var info *ddz.CardTypeInfo
103 | var retCards []*ddz.Card
104 | var retInfo ddz.CardTypeInfo
105 |
106 | cards = []*ddz.Card{
107 | ddz.NewCard(ddz.SuitTypeClub, 9),
108 | ddz.NewCard(ddz.SuitTypeHeart, 9),
109 | ddz.NewCard(ddz.SuitTypeSpade, 10),
110 | ddz.NewCard(ddz.SuitTypeHeart, 10),
111 | ddz.NewCard(ddz.SuitTypeHeart, 11),
112 | }
113 |
114 | info = &ddz.CardTypeInfo{
115 | CardType: ddz.CardTypeDui,
116 | MinValue: 8,
117 | }
118 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
119 | fmt.Println("对子:", retCards, retInfo)
120 |
121 | cards = []*ddz.Card{
122 | ddz.NewCard(ddz.SuitTypeClub, 9),
123 | ddz.NewCard(ddz.SuitTypeSpade, 9),
124 | ddz.NewCard(ddz.SuitTypeSpade, 10),
125 | }
126 |
127 | info = &ddz.CardTypeInfo{
128 | CardType: ddz.CardTypeDui,
129 | MinValue: 8,
130 | }
131 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
132 | fmt.Println("对子:", retCards, retInfo)
133 |
134 | cards = []*ddz.Card{
135 | ddz.NewCard(ddz.SuitTypeClub, 8),
136 | ddz.NewCard(ddz.SuitTypeSpade, 8),
137 | ddz.NewCard(ddz.SuitTypeSpade, 11),
138 | ddz.NewCard(ddz.SuitTypeJoker, 17),
139 | }
140 |
141 | info = &ddz.CardTypeInfo{
142 | CardType: ddz.CardTypeDui,
143 | MinValue: 8,
144 | }
145 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
146 | fmt.Println("对子:", retCards, retInfo)
147 | }
148 |
149 | // 三不带
150 | func findSanBuDaiLaiZi(laiZiNums []ddz.NumType) {
151 | var cards []*ddz.Card
152 | var info *ddz.CardTypeInfo
153 | var retCards []*ddz.Card
154 | var retInfo ddz.CardTypeInfo
155 |
156 | cards = []*ddz.Card{
157 | ddz.NewCard(ddz.SuitTypeClub, 9),
158 | ddz.NewCard(ddz.SuitTypeSpade, 9),
159 | ddz.NewCard(ddz.SuitTypeSpade, 10),
160 | ddz.NewCard(ddz.SuitTypeHeart, 11),
161 | }
162 |
163 | info = &ddz.CardTypeInfo{
164 | CardType: ddz.CardTypeSanBuDai,
165 | MinValue: 8,
166 | }
167 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
168 | fmt.Println("三不带:", retCards, retInfo)
169 |
170 | cards = []*ddz.Card{
171 | ddz.NewCard(ddz.SuitTypeClub, 9),
172 | ddz.NewCard(ddz.SuitTypeSpade, 9),
173 | ddz.NewCard(ddz.SuitTypeHeart, 9),
174 | }
175 |
176 | info = &ddz.CardTypeInfo{
177 | CardType: ddz.CardTypeSanBuDai,
178 | MinValue: 8,
179 | }
180 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
181 | fmt.Println("三不带:", retCards, retInfo)
182 | }
183 |
184 | // 三带一
185 | func findSanDaiYiLaiZi(laiZiNums []ddz.NumType) {
186 | var cards []*ddz.Card
187 | var info *ddz.CardTypeInfo
188 | var retCards []*ddz.Card
189 | var retInfo ddz.CardTypeInfo
190 |
191 | cards = []*ddz.Card{
192 | ddz.NewCard(ddz.SuitTypeSpade, 3),
193 | ddz.NewCard(ddz.SuitTypeClub, 9),
194 | ddz.NewCard(ddz.SuitTypeSpade, 9),
195 | ddz.NewCard(ddz.SuitTypeSpade, 10),
196 | ddz.NewCard(ddz.SuitTypeHeart, 11),
197 | ddz.NewCard(ddz.SuitTypeClub, 11),
198 | ddz.NewCard(ddz.SuitTypeSpade, 11),
199 | }
200 |
201 | info = &ddz.CardTypeInfo{
202 | CardType: ddz.CardTypeSanDaiYi,
203 | MinValue: 8,
204 | }
205 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
206 | fmt.Println("三带一:", retCards, retInfo)
207 |
208 | cards = []*ddz.Card{
209 | ddz.NewCard(ddz.SuitTypeSpade, 3),
210 | ddz.NewCard(ddz.SuitTypeClub, 9),
211 | ddz.NewCard(ddz.SuitTypeSpade, 9),
212 | ddz.NewCard(ddz.SuitTypeHeart, 9),
213 | ddz.NewCard(ddz.SuitTypeClub, 11),
214 | ddz.NewCard(ddz.SuitTypeSpade, 11),
215 | }
216 |
217 | info = &ddz.CardTypeInfo{
218 | CardType: ddz.CardTypeSanDaiYi,
219 | MinValue: 8,
220 | }
221 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
222 | fmt.Println("三带一:", retCards, retInfo)
223 |
224 | cards = []*ddz.Card{
225 | ddz.NewCard(ddz.SuitTypeSpade, 3),
226 | ddz.NewCard(ddz.SuitTypeClub, 9),
227 | ddz.NewCard(ddz.SuitTypeSpade, 9),
228 | ddz.NewCard(ddz.SuitTypeHeart, 9),
229 | ddz.NewCard(ddz.SuitTypeClub, 11),
230 | }
231 |
232 | info = &ddz.CardTypeInfo{
233 | CardType: ddz.CardTypeSanDaiYi,
234 | MinValue: 8,
235 | }
236 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
237 | fmt.Println("三带一:", retCards, retInfo)
238 |
239 | cards = []*ddz.Card{
240 | ddz.NewCard(ddz.SuitTypeSpade, 3),
241 | ddz.NewCard(ddz.SuitTypeClub, 3),
242 | ddz.NewCard(ddz.SuitTypeClub, 5),
243 | ddz.NewCard(ddz.SuitTypeSpade, 14),
244 | ddz.NewCard(ddz.SuitTypeJoker, 16),
245 | ddz.NewCard(ddz.SuitTypeJoker, 17),
246 | }
247 |
248 | info = &ddz.CardTypeInfo{
249 | CardType: ddz.CardTypeSanDaiYi,
250 | MinValue: 11,
251 | }
252 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
253 | fmt.Println("三带一:", retCards, retInfo)
254 | }
255 |
256 | // 三带二
257 | func findSanDaiErLaiZi(laiZiNums []ddz.NumType) {
258 | var cards []*ddz.Card
259 | var info *ddz.CardTypeInfo
260 | var retCards []*ddz.Card
261 | var retInfo ddz.CardTypeInfo
262 |
263 | cards = []*ddz.Card{
264 | ddz.NewCard(ddz.SuitTypeHeart, 11),
265 | ddz.NewCard(ddz.SuitTypeClub, 11),
266 | ddz.NewCard(ddz.SuitTypeSpade, 11),
267 | ddz.NewCard(ddz.SuitTypeSpade, 12),
268 | ddz.NewCard(ddz.SuitTypeSpade, 16),
269 | }
270 |
271 | info = &ddz.CardTypeInfo{
272 | CardType: ddz.CardTypeSanDaiEr,
273 | MinValue: 8,
274 | }
275 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
276 | fmt.Println("三带二:", retCards, retInfo)
277 | }
278 |
279 | // 顺子
280 | func findShunZiLaiZi(laiZiNums []ddz.NumType) {
281 | var cards []*ddz.Card
282 | var info *ddz.CardTypeInfo
283 | var retCards []*ddz.Card
284 | var retInfo ddz.CardTypeInfo
285 |
286 | cards = []*ddz.Card{
287 | ddz.NewCard(ddz.SuitTypeSpade, 4),
288 | ddz.NewCard(ddz.SuitTypeClub, 9),
289 | ddz.NewCard(ddz.SuitTypeSpade, 9),
290 | ddz.NewCard(ddz.SuitTypeSpade, 7),
291 | ddz.NewCard(ddz.SuitTypeHeart, 8),
292 | ddz.NewCard(ddz.SuitTypeClub, 11),
293 | ddz.NewCard(ddz.SuitTypeSpade, 11),
294 | }
295 |
296 | info = &ddz.CardTypeInfo{
297 | CardType: ddz.CardTypeShunZi,
298 | MinValue: 3,
299 | MaxValue: 7,
300 | }
301 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
302 | fmt.Println("顺子:", retCards, retInfo)
303 |
304 | cards = []*ddz.Card{
305 | ddz.NewCard(ddz.SuitTypeSpade, 3),
306 | ddz.NewCard(ddz.SuitTypeClub, 9),
307 | ddz.NewCard(ddz.SuitTypeSpade, 11),
308 | ddz.NewCard(ddz.SuitTypeHeart, 12),
309 | ddz.NewCard(ddz.SuitTypeClub, 13),
310 | ddz.NewCard(ddz.SuitTypeSpade, 14),
311 | }
312 |
313 | info = &ddz.CardTypeInfo{
314 | CardType: ddz.CardTypeShunZi,
315 | MinValue: 3,
316 | MaxValue: 7,
317 | }
318 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
319 | fmt.Println("顺子:", retCards, retInfo)
320 |
321 | cards = []*ddz.Card{
322 | ddz.NewCard(ddz.SuitTypeSpade, 4),
323 | ddz.NewCard(ddz.SuitTypeClub, 9),
324 | ddz.NewCard(ddz.SuitTypeSpade, 9),
325 | ddz.NewCard(ddz.SuitTypeHeart, 8),
326 | ddz.NewCard(ddz.SuitTypeClub, 11),
327 | ddz.NewCard(ddz.SuitTypeSpade, 11),
328 | }
329 |
330 | info = &ddz.CardTypeInfo{
331 | CardType: ddz.CardTypeShunZi,
332 | MinValue: 3,
333 | MaxValue: 7,
334 | }
335 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
336 | fmt.Println("顺子:", retCards, retInfo)
337 |
338 | cards = []*ddz.Card{
339 | ddz.NewCard(ddz.SuitTypeSpade, 4),
340 | ddz.NewCard(ddz.SuitTypeClub, 5),
341 | ddz.NewCard(ddz.SuitTypeSpade, 6),
342 | ddz.NewCard(ddz.SuitTypeHeart, 8),
343 | ddz.NewCard(ddz.SuitTypeClub, 7),
344 | ddz.NewCard(ddz.SuitTypeSpade, 11),
345 | }
346 |
347 | info = &ddz.CardTypeInfo{
348 | CardType: ddz.CardTypeShunZi,
349 | MinValue: 3,
350 | MaxValue: 7,
351 | }
352 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
353 | fmt.Println("顺子:", retCards, retInfo)
354 |
355 | cards = []*ddz.Card{
356 | ddz.NewCard(ddz.SuitTypeSpade, 3),
357 | ddz.NewCard(ddz.SuitTypeSpade, 4),
358 | ddz.NewCard(ddz.SuitTypeClub, 5),
359 | ddz.NewCard(ddz.SuitTypeSpade, 6),
360 | ddz.NewCard(ddz.SuitTypeHeart, 7),
361 | ddz.NewCard(ddz.SuitTypeClub, 8),
362 | ddz.NewCard(ddz.SuitTypeSpade, 8),
363 | ddz.NewCard(ddz.SuitTypeHeart, 9),
364 | ddz.NewCard(ddz.SuitTypeSpade, 9),
365 | ddz.NewCard(ddz.SuitTypeClub, 9),
366 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
367 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
368 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
369 | ddz.NewCard(ddz.SuitTypeHeart, 15),
370 | ddz.NewCard(ddz.SuitTypeSpade, 15),
371 | ddz.NewCard(ddz.SuitTypeClub, 15),
372 | ddz.NewCard(ddz.SuitTypeJoker, 17),
373 | }
374 |
375 | info = &ddz.CardTypeInfo{
376 | CardType: ddz.CardTypeShunZi,
377 | MinValue: 3,
378 | MaxValue: 8,
379 | }
380 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
381 | fmt.Println("顺子:", retCards, retInfo)
382 | }
383 |
384 | // 四带单
385 | func findSiDaiDanLaiZi(laiZiNums []ddz.NumType) {
386 | var cards []*ddz.Card
387 | var info *ddz.CardTypeInfo
388 | var retCards []*ddz.Card
389 | var retInfo ddz.CardTypeInfo
390 |
391 | cards = []*ddz.Card{
392 | ddz.NewCard(ddz.SuitTypeSpade, 3),
393 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
394 | ddz.NewCard(ddz.SuitTypeHeart, 13),
395 | ddz.NewCard(ddz.SuitTypeSpade, 13),
396 | ddz.NewCard(ddz.SuitTypeClub, 13),
397 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
398 | ddz.NewCard(ddz.SuitTypeClub, 14),
399 | ddz.NewCard(ddz.SuitTypeSpade, 14),
400 | ddz.NewCard(ddz.SuitTypeHeart, 14),
401 | }
402 |
403 | info = &ddz.CardTypeInfo{
404 | CardType: ddz.CardTypeSiDaiDan,
405 | MinValue: 15,
406 | }
407 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
408 | fmt.Println("四带单:", retCards, retInfo)
409 | }
410 |
411 | // 四带对
412 | func findSiDaiDuiLaiZi(laiZiNums []ddz.NumType) {
413 | var cards []*ddz.Card
414 | var info *ddz.CardTypeInfo
415 | var retCards []*ddz.Card
416 | var retInfo ddz.CardTypeInfo
417 |
418 | cards = []*ddz.Card{
419 | ddz.NewCard(ddz.SuitTypeSpade, 3),
420 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
421 | ddz.NewCard(ddz.SuitTypeClub, 3),
422 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
423 | ddz.NewCard(ddz.SuitTypeDiamond, 12),
424 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
425 | ddz.NewCard(ddz.SuitTypeHeart, 13),
426 | ddz.NewCard(ddz.SuitTypeSpade, 13),
427 | ddz.NewCard(ddz.SuitTypeClub, 13),
428 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
429 | ddz.NewCard(ddz.SuitTypeClub, 14),
430 | ddz.NewCard(ddz.SuitTypeSpade, 14),
431 | ddz.NewCard(ddz.SuitTypeHeart, 14),
432 | ddz.NewCard(ddz.SuitTypeDiamond, 15),
433 | ddz.NewCard(ddz.SuitTypeJoker, 17),
434 | }
435 |
436 | info = &ddz.CardTypeInfo{
437 | CardType: ddz.CardTypeSiDaiDui,
438 | MinValue: 10,
439 | }
440 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
441 | fmt.Println("四带对:", retCards, retInfo)
442 | }
443 |
444 | // 硬炸弹
445 | func findZhaDanLaiZi(laiZiNums []ddz.NumType) {
446 | var cards []*ddz.Card
447 | var info *ddz.CardTypeInfo
448 | var retCards []*ddz.Card
449 | var retInfo ddz.CardTypeInfo
450 |
451 | cards = []*ddz.Card{
452 | ddz.NewCard(ddz.SuitTypeHeart, 14),
453 | ddz.NewCard(ddz.SuitTypeSpade, 14),
454 | ddz.NewCard(ddz.SuitTypeClub, 14),
455 | ddz.NewCard(ddz.SuitTypeDiamond, 16),
456 | }
457 |
458 | info = &ddz.CardTypeInfo{
459 | CardType: ddz.CardTypeZhaDan,
460 | MinValue: 7,
461 | MaxValue: 0,
462 | }
463 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
464 | fmt.Println("硬炸弹:", retCards, retInfo)
465 |
466 | cards = []*ddz.Card{
467 | ddz.NewCard(ddz.SuitTypeClub, 4),
468 | ddz.NewCard(ddz.SuitTypeHeart, 4),
469 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
470 | ddz.NewCard(ddz.SuitTypeSpade, 4),
471 | ddz.NewCard(ddz.SuitTypeHeart, 6),
472 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
473 | ddz.NewCard(ddz.SuitTypeClub, 6),
474 | ddz.NewCard(ddz.SuitTypeSpade, 6),
475 | ddz.NewCard(ddz.SuitTypeHeart, 8),
476 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
477 | ddz.NewCard(ddz.SuitTypeClub, 8),
478 | ddz.NewCard(ddz.SuitTypeSpade, 8),
479 | ddz.NewCard(ddz.SuitTypeHeart, 15),
480 | ddz.NewCard(ddz.SuitTypeDiamond, 15),
481 | ddz.NewCard(ddz.SuitTypeClub, 15),
482 | ddz.NewCard(ddz.SuitTypeSpade, 15),
483 | ddz.NewCard(ddz.SuitTypeJoker, 17),
484 | }
485 |
486 | info = &ddz.CardTypeInfo{
487 | CardType: ddz.CardTypeSiDaiDui,
488 | MinValue: 12,
489 | MaxValue: 0,
490 | }
491 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
492 | fmt.Println("硬炸弹:", retCards, retInfo)
493 | }
494 |
495 | // 四软炸
496 | func findRuanZhaDan4(laiZiNums []ddz.NumType) {
497 | var cards []*ddz.Card
498 | var info *ddz.CardTypeInfo
499 | var retCards []*ddz.Card
500 | var retInfo ddz.CardTypeInfo
501 |
502 | cards = []*ddz.Card{
503 | ddz.NewCard(ddz.SuitTypeHeart, 13),
504 | ddz.NewCard(ddz.SuitTypeSpade, 13),
505 | ddz.NewCard(ddz.SuitTypeClub, 13),
506 | ddz.NewCard(ddz.SuitTypeSpade, 14),
507 | ddz.NewCard(ddz.SuitTypeHeart, 14),
508 | ddz.NewCard(ddz.SuitTypeClub, 9),
509 | ddz.NewCard(ddz.SuitTypeSpade, 10),
510 | ddz.NewCard(ddz.SuitTypeHeart, 11),
511 | ddz.NewCard(ddz.SuitTypeSpade, 12),
512 | }
513 |
514 | info = &ddz.CardTypeInfo{
515 | CardType: ddz.CardTypeFeiJiBuDai,
516 | MinValue: 12,
517 | MaxValue: 14,
518 | }
519 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
520 | fmt.Println("四软炸:", retCards, retInfo)
521 | }
522 |
523 | // 五软炸
524 | func findRuanZhaDan5(laiZiNums []ddz.NumType) {
525 | var cards []*ddz.Card
526 | var info *ddz.CardTypeInfo
527 | var retCards []*ddz.Card
528 | var retInfo ddz.CardTypeInfo
529 |
530 | cards = []*ddz.Card{
531 | ddz.NewCard(ddz.SuitTypeHeart, 6),
532 | ddz.NewCard(ddz.SuitTypeSpade, 6),
533 | ddz.NewCard(ddz.SuitTypeClub, 6),
534 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
535 | ddz.NewCard(ddz.SuitTypeJoker, 17),
536 | }
537 |
538 | info = &ddz.CardTypeInfo{
539 | CardType: ddz.CardTypeZhaDan,
540 | MinValue: 10,
541 | MaxValue: 0,
542 | }
543 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
544 | fmt.Println("五软炸:", retCards, retInfo)
545 | }
546 |
547 | // 四癞子炸
548 | func findLaiZiZhaDan4(laiZiNums []ddz.NumType) {
549 | var cards []*ddz.Card
550 | var info *ddz.CardTypeInfo
551 | var retCards []*ddz.Card
552 | var retInfo ddz.CardTypeInfo
553 |
554 | cards = []*ddz.Card{
555 | ddz.NewCard(ddz.SuitTypeClub, 9),
556 | ddz.NewCard(ddz.SuitTypeSpade, 9),
557 | ddz.NewCard(ddz.SuitTypeHeart, 9),
558 | ddz.NewCard(ddz.SuitTypeSpade, 10),
559 | }
560 |
561 | info = &ddz.CardTypeInfo{
562 | CardType: ddz.CardTypeFeiJiBuDai,
563 | MinValue: 12,
564 | MaxValue: 13,
565 | }
566 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
567 | fmt.Println("四癞子炸:", retCards, retInfo)
568 | }
569 |
570 | // 四纯癞子炸
571 | func findChunLaiZiZhaDan(laiZiNums []ddz.NumType) {
572 | var cards []*ddz.Card
573 | var info *ddz.CardTypeInfo
574 | var retCards []*ddz.Card
575 | var retInfo ddz.CardTypeInfo
576 |
577 | cards = []*ddz.Card{
578 | ddz.NewCard(ddz.SuitTypeClub, 10),
579 | ddz.NewCard(ddz.SuitTypeSpade, 10),
580 | ddz.NewCard(ddz.SuitTypeClub, 9),
581 | ddz.NewCard(ddz.SuitTypeSpade, 9),
582 | ddz.NewCard(ddz.SuitTypeHeart, 9),
583 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
584 | }
585 |
586 | info = &ddz.CardTypeInfo{
587 | CardType: ddz.CardTypeLaiZiZhaDan4,
588 | MinValue: 8,
589 | }
590 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
591 | fmt.Println("四纯癞子炸:", retCards, retInfo)
592 |
593 | cards = []*ddz.Card{
594 | ddz.NewCard(ddz.SuitTypeClub, 9),
595 | ddz.NewCard(ddz.SuitTypeSpade, 9),
596 | ddz.NewCard(ddz.SuitTypeHeart, 9),
597 | ddz.NewCard(ddz.SuitTypeJoker, 16),
598 | ddz.NewCard(ddz.SuitTypeJoker, 17),
599 | }
600 |
601 | info = &ddz.CardTypeInfo{
602 | CardType: ddz.CardTypeZhaDan,
603 | MinValue: 12,
604 | MaxValue: 0,
605 | }
606 | retCards, retInfo = ddz.FindCardsTianDiLaiZi(info, cards, laiZiNums...)
607 | fmt.Println("四纯癞子炸:", retCards, retInfo)
608 | }
609 |
610 | // 火箭
611 | func findHuoJianLaiZi(laiZiNums []ddz.NumType) {
612 | var cards []*ddz.Card
613 | var info *ddz.CardTypeInfo
614 | var retCards []*ddz.Card
615 | var retInfo ddz.CardTypeInfo
616 |
617 | cards = []*ddz.Card{
618 | ddz.NewCard(ddz.SuitTypeClub, 7),
619 | ddz.NewCard(ddz.SuitTypeSpade, 7),
620 | ddz.NewCard(ddz.SuitTypeHeart, 7),
621 | ddz.NewCard(ddz.SuitTypeClub, 8),
622 | ddz.NewCard(ddz.SuitTypeSpade, 8),
623 | ddz.NewCard(ddz.SuitTypeHeart, 8),
624 | ddz.NewCard(ddz.SuitTypeJoker, 16),
625 | ddz.NewCard(ddz.SuitTypeJoker, 17),
626 | }
627 |
628 | info = &ddz.CardTypeInfo{
629 | CardType: ddz.CardTypeHuoJian,
630 | MinValue: 0,
631 | MaxValue: 0,
632 | }
633 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
634 | fmt.Println("火箭:", retCards, retInfo)
635 |
636 | cards = []*ddz.Card{
637 | ddz.NewCard(ddz.SuitTypeClub, 6),
638 | ddz.NewCard(ddz.SuitTypeSpade, 6),
639 | ddz.NewCard(ddz.SuitTypeHeart, 6),
640 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
641 | ddz.NewCard(ddz.SuitTypeClub, 7),
642 | ddz.NewCard(ddz.SuitTypeSpade, 7),
643 | ddz.NewCard(ddz.SuitTypeHeart, 7),
644 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
645 | ddz.NewCard(ddz.SuitTypeClub, 8),
646 | ddz.NewCard(ddz.SuitTypeSpade, 8),
647 | ddz.NewCard(ddz.SuitTypeHeart, 8),
648 | }
649 |
650 | info = &ddz.CardTypeInfo{
651 | CardType: ddz.CardTypeHuoJian,
652 | MinValue: 0,
653 | MaxValue: 0,
654 | }
655 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
656 | fmt.Println("火箭:", retCards, retInfo)
657 |
658 | cards = []*ddz.Card{
659 | ddz.NewCard(ddz.SuitTypeClub, 4),
660 | ddz.NewCard(ddz.SuitTypeSpade, 4),
661 | ddz.NewCard(ddz.SuitTypeHeart, 4),
662 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
663 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
664 | ddz.NewCard(ddz.SuitTypeClub, 8),
665 | ddz.NewCard(ddz.SuitTypeSpade, 8),
666 | ddz.NewCard(ddz.SuitTypeHeart, 8),
667 | ddz.NewCard(ddz.SuitTypeClub, 9),
668 | ddz.NewCard(ddz.SuitTypeSpade, 11),
669 | ddz.NewCard(ddz.SuitTypeHeart, 11),
670 | ddz.NewCard(ddz.SuitTypeClub, 11),
671 | ddz.NewCard(ddz.SuitTypeSpade, 12),
672 | ddz.NewCard(ddz.SuitTypeHeart, 12),
673 | ddz.NewCard(ddz.SuitTypeHeart, 14),
674 | ddz.NewCard(ddz.SuitTypeClub, 16),
675 | ddz.NewCard(ddz.SuitTypeSpade, 17),
676 | }
677 |
678 | info = &ddz.CardTypeInfo{
679 | CardType: ddz.CardTypeZhaDan,
680 | MinValue: 13,
681 | MaxValue: 0,
682 | }
683 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
684 | fmt.Println("火箭:", retCards, retInfo)
685 | }
686 |
687 | // 软连炸
688 | func findRuanLianZha(laiZiNums []ddz.NumType) {
689 | var cards []*ddz.Card
690 | var info *ddz.CardTypeInfo
691 | var retCards []*ddz.Card
692 | var retInfo ddz.CardTypeInfo
693 |
694 | cards = []*ddz.Card{
695 | ddz.NewCard(ddz.SuitTypeClub, 7),
696 | ddz.NewCard(ddz.SuitTypeSpade, 7),
697 | ddz.NewCard(ddz.SuitTypeHeart, 7),
698 | ddz.NewCard(ddz.SuitTypeClub, 8),
699 | ddz.NewCard(ddz.SuitTypeSpade, 8),
700 | ddz.NewCard(ddz.SuitTypeHeart, 8),
701 | ddz.NewCard(ddz.SuitTypeJoker, 16),
702 | ddz.NewCard(ddz.SuitTypeJoker, 17),
703 | }
704 |
705 | info = &ddz.CardTypeInfo{
706 | CardType: ddz.CardTypeRuanLianZha,
707 | MinValue: 3,
708 | MaxValue: 4,
709 | }
710 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
711 | fmt.Println("软连炸:", retCards, retInfo)
712 |
713 | cards = []*ddz.Card{
714 | ddz.NewCard(ddz.SuitTypeClub, 6),
715 | ddz.NewCard(ddz.SuitTypeSpade, 6),
716 | ddz.NewCard(ddz.SuitTypeHeart, 6),
717 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
718 | ddz.NewCard(ddz.SuitTypeClub, 7),
719 | ddz.NewCard(ddz.SuitTypeSpade, 7),
720 | ddz.NewCard(ddz.SuitTypeHeart, 7),
721 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
722 | ddz.NewCard(ddz.SuitTypeClub, 8),
723 | ddz.NewCard(ddz.SuitTypeSpade, 8),
724 | ddz.NewCard(ddz.SuitTypeHeart, 8),
725 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
726 | ddz.NewCard(ddz.SuitTypeClub, 9),
727 | ddz.NewCard(ddz.SuitTypeSpade, 9),
728 | }
729 |
730 | info = &ddz.CardTypeInfo{
731 | CardType: ddz.CardTypeRuanLianZha,
732 | MinValue: 11,
733 | MaxValue: 12,
734 | }
735 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
736 | fmt.Println("软连炸:", retCards, retInfo)
737 | }
738 |
739 | // 硬连炸
740 | func findLianZhaLaiZi(laiZiNums []ddz.NumType) {
741 | var cards []*ddz.Card
742 | var info *ddz.CardTypeInfo
743 | var retCards []*ddz.Card
744 | var retInfo ddz.CardTypeInfo
745 |
746 | cards = []*ddz.Card{
747 | ddz.NewCard(ddz.SuitTypeClub, 7),
748 | ddz.NewCard(ddz.SuitTypeSpade, 7),
749 | ddz.NewCard(ddz.SuitTypeHeart, 7),
750 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
751 | ddz.NewCard(ddz.SuitTypeClub, 8),
752 | ddz.NewCard(ddz.SuitTypeSpade, 8),
753 | ddz.NewCard(ddz.SuitTypeHeart, 8),
754 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
755 | }
756 |
757 | info = &ddz.CardTypeInfo{
758 | CardType: ddz.CardTypeRuanZhaDan6,
759 | MinValue: 3,
760 | MaxValue: 0,
761 | }
762 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
763 | fmt.Println("硬连炸:", retCards, retInfo)
764 |
765 | cards = []*ddz.Card{
766 | ddz.NewCard(ddz.SuitTypeClub, 7),
767 | ddz.NewCard(ddz.SuitTypeSpade, 7),
768 | ddz.NewCard(ddz.SuitTypeHeart, 7),
769 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
770 | ddz.NewCard(ddz.SuitTypeClub, 8),
771 | ddz.NewCard(ddz.SuitTypeSpade, 8),
772 | ddz.NewCard(ddz.SuitTypeHeart, 8),
773 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
774 | ddz.NewCard(ddz.SuitTypeClub, 9),
775 | ddz.NewCard(ddz.SuitTypeSpade, 9),
776 | ddz.NewCard(ddz.SuitTypeHeart, 9),
777 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
778 | }
779 |
780 | info = &ddz.CardTypeInfo{
781 | CardType: ddz.CardTypeRuanZhaDan6,
782 | MinValue: 3,
783 | MaxValue: 0,
784 | }
785 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
786 | fmt.Println("硬连炸:", retCards, retInfo)
787 | }
788 |
789 | // 六软炸
790 | func findRuanZhaDan6(laiZiNums []ddz.NumType) {
791 | var cards []*ddz.Card
792 | var info *ddz.CardTypeInfo
793 | var retCards []*ddz.Card
794 | var retInfo ddz.CardTypeInfo
795 |
796 | cards = []*ddz.Card{
797 | ddz.NewCard(ddz.SuitTypeClub, 7),
798 | ddz.NewCard(ddz.SuitTypeSpade, 7),
799 | ddz.NewCard(ddz.SuitTypeHeart, 7),
800 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
801 | ddz.NewCard(ddz.SuitTypeJoker, 16),
802 | ddz.NewCard(ddz.SuitTypeJoker, 17),
803 | }
804 |
805 | info = &ddz.CardTypeInfo{
806 | CardType: ddz.CardTypeLianZha,
807 | MinValue: 8,
808 | MaxValue: 9,
809 | }
810 | retCards, retInfo = ddz.FindCardsBuXiPaiLaiZi(info, cards, laiZiNums)
811 | fmt.Println("六软炸:", retCards, retInfo)
812 | }
813 |
--------------------------------------------------------------------------------
/test/test_card_split.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/fattigerlee/poker/ddz"
6 | )
7 |
8 | func main() {
9 | splitJingDian()
10 | splitBuXiPai()
11 | splitBuXiPaiLaiZi()
12 | }
13 |
14 | func splitJingDian() {
15 | var cards []*ddz.Card
16 | var infoList []ddz.CardTypeInfo
17 | var cardsList [][]*ddz.Card
18 |
19 | cards = []*ddz.Card{
20 | ddz.NewCard(ddz.SuitTypeJoker, 16),
21 | ddz.NewCard(ddz.SuitTypeJoker, 17),
22 | ddz.NewCard(ddz.SuitTypeHeart, 3),
23 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
24 | ddz.NewCard(ddz.SuitTypeSpade, 3),
25 | ddz.NewCard(ddz.SuitTypeClub, 3),
26 | ddz.NewCard(ddz.SuitTypeHeart, 4),
27 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
28 | ddz.NewCard(ddz.SuitTypeHeart, 5),
29 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
30 | ddz.NewCard(ddz.SuitTypeSpade, 5),
31 | ddz.NewCard(ddz.SuitTypeHeart, 6),
32 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
33 | ddz.NewCard(ddz.SuitTypeSpade, 6),
34 | ddz.NewCard(ddz.SuitTypeHeart, 10),
35 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
36 | ddz.NewCard(ddz.SuitTypeSpade, 10),
37 | ddz.NewCard(ddz.SuitTypeHeart, 7),
38 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
39 | ddz.NewCard(ddz.SuitTypeSpade, 7),
40 | }
41 |
42 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
43 | fmt.Println("拆牌(经典模式)1:", cardsList, infoList)
44 |
45 | cards = []*ddz.Card{
46 | ddz.NewCard(ddz.SuitTypeHeart, 3),
47 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
48 | ddz.NewCard(ddz.SuitTypeHeart, 4),
49 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
50 | ddz.NewCard(ddz.SuitTypeHeart, 5),
51 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
52 | ddz.NewCard(ddz.SuitTypeHeart, 6),
53 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
54 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
55 | ddz.NewCard(ddz.SuitTypeSpade, 7),
56 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
57 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
58 | ddz.NewCard(ddz.SuitTypeSpade, 10),
59 | }
60 |
61 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
62 | fmt.Println("拆牌(经典模式)2:", cardsList, infoList)
63 |
64 | cards = []*ddz.Card{
65 | ddz.NewCard(ddz.SuitTypeHeart, 3),
66 | ddz.NewCard(ddz.SuitTypeHeart, 4),
67 | ddz.NewCard(ddz.SuitTypeHeart, 5),
68 | ddz.NewCard(ddz.SuitTypeHeart, 6),
69 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
70 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
71 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
72 | ddz.NewCard(ddz.SuitTypeSpade, 10),
73 | ddz.NewCard(ddz.SuitTypeHeart, 11),
74 | ddz.NewCard(ddz.SuitTypeHeart, 12),
75 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
76 | }
77 |
78 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
79 | fmt.Println("拆牌(经典模式)3:", cardsList, infoList)
80 |
81 | cards = []*ddz.Card{
82 | ddz.NewCard(ddz.SuitTypeHeart, 3),
83 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
84 | ddz.NewCard(ddz.SuitTypeHeart, 4),
85 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
86 | ddz.NewCard(ddz.SuitTypeHeart, 5),
87 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
88 | ddz.NewCard(ddz.SuitTypeHeart, 6),
89 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
90 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
91 | ddz.NewCard(ddz.SuitTypeSpade, 7),
92 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
93 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
94 | ddz.NewCard(ddz.SuitTypeSpade, 10),
95 | ddz.NewCard(ddz.SuitTypeHeart, 11),
96 | ddz.NewCard(ddz.SuitTypeHeart, 12),
97 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
98 | }
99 |
100 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
101 | fmt.Println("拆牌(经典模式)4:", cardsList, infoList)
102 |
103 | cards = []*ddz.Card{
104 | ddz.NewCard(ddz.SuitTypeHeart, 3),
105 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
106 | ddz.NewCard(ddz.SuitTypeSpade, 3),
107 | ddz.NewCard(ddz.SuitTypeSpade, 4),
108 | ddz.NewCard(ddz.SuitTypeHeart, 4),
109 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
110 | ddz.NewCard(ddz.SuitTypeHeart, 5),
111 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
112 | ddz.NewCard(ddz.SuitTypeHeart, 6),
113 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
114 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
115 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
116 | ddz.NewCard(ddz.SuitTypeSpade, 10),
117 | ddz.NewCard(ddz.SuitTypeHeart, 11),
118 | ddz.NewCard(ddz.SuitTypeHeart, 12),
119 | ddz.NewCard(ddz.SuitTypeHeart, 14),
120 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
121 | ddz.NewCard(ddz.SuitTypeSpade, 14),
122 | }
123 |
124 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
125 | fmt.Println("拆牌(经典模式)5:", cardsList, infoList)
126 |
127 | cards = []*ddz.Card{
128 | ddz.NewCard(ddz.SuitTypeHeart, 3),
129 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
130 | ddz.NewCard(ddz.SuitTypeSpade, 5),
131 | ddz.NewCard(ddz.SuitTypeSpade, 6),
132 | ddz.NewCard(ddz.SuitTypeHeart, 6),
133 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
134 | ddz.NewCard(ddz.SuitTypeHeart, 7),
135 | ddz.NewCard(ddz.SuitTypeClub, 7),
136 | ddz.NewCard(ddz.SuitTypeHeart, 8),
137 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
138 | ddz.NewCard(ddz.SuitTypeClub, 9),
139 | ddz.NewCard(ddz.SuitTypeSpade, 10),
140 | ddz.NewCard(ddz.SuitTypeDiamond, 11),
141 | ddz.NewCard(ddz.SuitTypeSpade, 12),
142 | ddz.NewCard(ddz.SuitTypeHeart, 13),
143 | ddz.NewCard(ddz.SuitTypeHeart, 14),
144 | ddz.NewCard(ddz.SuitTypeDiamond, 15),
145 | }
146 |
147 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
148 | fmt.Println("拆牌(经典模式)6:", cardsList, infoList)
149 |
150 | cards = []*ddz.Card{
151 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
152 | ddz.NewCard(ddz.SuitTypeSpade, 5),
153 | ddz.NewCard(ddz.SuitTypeSpade, 6),
154 | ddz.NewCard(ddz.SuitTypeHeart, 6),
155 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
156 | ddz.NewCard(ddz.SuitTypeHeart, 7),
157 | ddz.NewCard(ddz.SuitTypeHeart, 8),
158 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
159 | ddz.NewCard(ddz.SuitTypeSpade, 10),
160 | ddz.NewCard(ddz.SuitTypeDiamond, 11),
161 | ddz.NewCard(ddz.SuitTypeSpade, 12),
162 | }
163 |
164 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
165 | fmt.Println("拆牌(经典模式)7:", cardsList, infoList)
166 |
167 | cards = []*ddz.Card{
168 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
169 | ddz.NewCard(ddz.SuitTypeSpade, 5),
170 | ddz.NewCard(ddz.SuitTypeSpade, 6),
171 | ddz.NewCard(ddz.SuitTypeHeart, 6),
172 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
173 | ddz.NewCard(ddz.SuitTypeHeart, 7),
174 | ddz.NewCard(ddz.SuitTypeHeart, 8),
175 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
176 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
177 | ddz.NewCard(ddz.SuitTypeHeart, 9),
178 | }
179 |
180 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
181 | fmt.Println("拆牌(经典模式)8:", cardsList, infoList)
182 |
183 | cards = []*ddz.Card{
184 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
185 | ddz.NewCard(ddz.SuitTypeSpade, 5),
186 | ddz.NewCard(ddz.SuitTypeSpade, 6),
187 | ddz.NewCard(ddz.SuitTypeHeart, 6),
188 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
189 | ddz.NewCard(ddz.SuitTypeHeart, 7),
190 | ddz.NewCard(ddz.SuitTypeHeart, 8),
191 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
192 | }
193 |
194 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
195 | fmt.Println("拆牌(经典模式)9:", cardsList, infoList)
196 |
197 | cards = []*ddz.Card{
198 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
199 | ddz.NewCard(ddz.SuitTypeSpade, 5),
200 | ddz.NewCard(ddz.SuitTypeSpade, 6),
201 | ddz.NewCard(ddz.SuitTypeHeart, 6),
202 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
203 | ddz.NewCard(ddz.SuitTypeHeart, 7),
204 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
205 | ddz.NewCard(ddz.SuitTypeSpade, 9),
206 | ddz.NewCard(ddz.SuitTypeSpade, 10),
207 | ddz.NewCard(ddz.SuitTypeHeart, 11),
208 | ddz.NewCard(ddz.SuitTypeDiamond, 12),
209 | }
210 |
211 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
212 | fmt.Println("拆牌(经典模式)10:", cardsList, infoList)
213 |
214 | cards = []*ddz.Card{
215 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
216 | ddz.NewCard(ddz.SuitTypeSpade, 5),
217 | ddz.NewCard(ddz.SuitTypeSpade, 6),
218 | ddz.NewCard(ddz.SuitTypeHeart, 6),
219 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
220 | ddz.NewCard(ddz.SuitTypeHeart, 7),
221 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
222 | ddz.NewCard(ddz.SuitTypeHeart, 8),
223 | ddz.NewCard(ddz.SuitTypeSpade, 9),
224 | ddz.NewCard(ddz.SuitTypeSpade, 10),
225 | ddz.NewCard(ddz.SuitTypeHeart, 11),
226 | ddz.NewCard(ddz.SuitTypeDiamond, 12),
227 | }
228 |
229 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
230 | fmt.Println("拆牌(经典模式)11:", cardsList, infoList)
231 |
232 | cards = []*ddz.Card{
233 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
234 | ddz.NewCard(ddz.SuitTypeSpade, 6),
235 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
236 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
237 | ddz.NewCard(ddz.SuitTypeSpade, 9),
238 | ddz.NewCard(ddz.SuitTypeSpade, 10),
239 | ddz.NewCard(ddz.SuitTypeHeart, 10),
240 | ddz.NewCard(ddz.SuitTypeSpade, 11),
241 | ddz.NewCard(ddz.SuitTypeHeart, 11),
242 | ddz.NewCard(ddz.SuitTypeDiamond, 12),
243 | ddz.NewCard(ddz.SuitTypeHeart, 12),
244 | ddz.NewCard(ddz.SuitTypeHeart, 13),
245 | }
246 |
247 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
248 | fmt.Println("拆牌(经典模式)12:", cardsList, infoList)
249 |
250 | cards = []*ddz.Card{
251 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
252 | ddz.NewCard(ddz.SuitTypeSpade, 3),
253 | ddz.NewCard(ddz.SuitTypeSpade, 4),
254 | ddz.NewCard(ddz.SuitTypeHeart, 4),
255 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
256 | ddz.NewCard(ddz.SuitTypeHeart, 5),
257 | ddz.NewCard(ddz.SuitTypeSpade, 6),
258 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
259 | ddz.NewCard(ddz.SuitTypeSpade, 7),
260 | ddz.NewCard(ddz.SuitTypeSpade, 8),
261 | ddz.NewCard(ddz.SuitTypeHeart, 8),
262 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
263 | ddz.NewCard(ddz.SuitTypeHeart, 9),
264 | ddz.NewCard(ddz.SuitTypeHeart, 10),
265 | ddz.NewCard(ddz.SuitTypeHeart, 11),
266 | ddz.NewCard(ddz.SuitTypeHeart, 12),
267 | ddz.NewCard(ddz.SuitTypeHeart, 13),
268 | ddz.NewCard(ddz.SuitTypeHeart, 14),
269 | }
270 |
271 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
272 | fmt.Println("拆牌(经典模式)13:", cardsList, infoList)
273 |
274 | cards = []*ddz.Card{
275 | ddz.NewCard(ddz.SuitTypeHeart, 9),
276 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
277 | ddz.NewCard(ddz.SuitTypeSpade, 9),
278 | ddz.NewCard(ddz.SuitTypeHeart, 10),
279 | ddz.NewCard(ddz.SuitTypeHeart, 11),
280 | ddz.NewCard(ddz.SuitTypeHeart, 12),
281 | ddz.NewCard(ddz.SuitTypeHeart, 13),
282 | ddz.NewCard(ddz.SuitTypeHeart, 14),
283 | }
284 |
285 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
286 | fmt.Println("拆牌(经典模式)14:", cardsList, infoList)
287 |
288 | cards = []*ddz.Card{
289 | ddz.NewCard(ddz.SuitTypeHeart, 9),
290 | ddz.NewCard(ddz.SuitTypeHeart, 10),
291 | ddz.NewCard(ddz.SuitTypeHeart, 11),
292 | ddz.NewCard(ddz.SuitTypeHeart, 12),
293 | ddz.NewCard(ddz.SuitTypeHeart, 13),
294 | ddz.NewCard(ddz.SuitTypeHeart, 14),
295 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
296 | ddz.NewCard(ddz.SuitTypeSpade, 14),
297 | }
298 |
299 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
300 | fmt.Println("拆牌(经典模式)15:", cardsList, infoList)
301 |
302 | cards = []*ddz.Card{
303 | ddz.NewCard(ddz.SuitTypeHeart, 3),
304 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
305 | ddz.NewCard(ddz.SuitTypeSpade, 3),
306 | ddz.NewCard(ddz.SuitTypeSpade, 4),
307 | ddz.NewCard(ddz.SuitTypeHeart, 4),
308 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
309 | ddz.NewCard(ddz.SuitTypeHeart, 5),
310 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
311 | ddz.NewCard(ddz.SuitTypeSpade, 5),
312 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
313 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
314 | ddz.NewCard(ddz.SuitTypeHeart, 14),
315 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
316 | ddz.NewCard(ddz.SuitTypeSpade, 14),
317 | }
318 |
319 | cardsList, infoList = ddz.SplitCardsJingDian(cards)
320 | fmt.Println("拆牌(经典模式)16:", cardsList, infoList)
321 | }
322 |
323 | func splitBuXiPai() {
324 | var cards []*ddz.Card
325 | var infoList []ddz.CardTypeInfo
326 | var cardsList [][]*ddz.Card
327 |
328 | cards = []*ddz.Card{
329 | ddz.NewCard(ddz.SuitTypeClub, 3),
330 | ddz.NewCard(ddz.SuitTypeHeart, 3),
331 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
332 | ddz.NewCard(ddz.SuitTypeSpade, 3),
333 | ddz.NewCard(ddz.SuitTypeHeart, 4),
334 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
335 | ddz.NewCard(ddz.SuitTypeClub, 4),
336 | ddz.NewCard(ddz.SuitTypeSpade, 4),
337 | ddz.NewCard(ddz.SuitTypeHeart, 5),
338 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
339 | ddz.NewCard(ddz.SuitTypeSpade, 5),
340 | ddz.NewCard(ddz.SuitTypeHeart, 6),
341 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
342 | ddz.NewCard(ddz.SuitTypeSpade, 6),
343 | ddz.NewCard(ddz.SuitTypeHeart, 10),
344 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
345 | ddz.NewCard(ddz.SuitTypeSpade, 10),
346 | }
347 |
348 | cardsList, infoList = ddz.SplitCardsBuXiPai(cards)
349 | fmt.Println("拆牌(不洗牌模式):", cardsList, infoList)
350 | }
351 |
352 | func splitBuXiPaiLaiZi() {
353 | laiZiNums := []ddz.NumType{16, 17}
354 |
355 | var cards []*ddz.Card
356 | var infoList []ddz.CardTypeInfo
357 | var cardsList [][]*ddz.Card
358 |
359 | cards = []*ddz.Card{
360 | ddz.NewCard(ddz.SuitTypeClub, 4),
361 | ddz.NewCard(ddz.SuitTypeHeart, 4),
362 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
363 | ddz.NewCard(ddz.SuitTypeSpade, 4),
364 | ddz.NewCard(ddz.SuitTypeHeart, 6),
365 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
366 | ddz.NewCard(ddz.SuitTypeClub, 6),
367 | ddz.NewCard(ddz.SuitTypeSpade, 6),
368 | ddz.NewCard(ddz.SuitTypeHeart, 8),
369 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
370 | ddz.NewCard(ddz.SuitTypeClub, 8),
371 | ddz.NewCard(ddz.SuitTypeSpade, 8),
372 | ddz.NewCard(ddz.SuitTypeHeart, 15),
373 | ddz.NewCard(ddz.SuitTypeDiamond, 15),
374 | ddz.NewCard(ddz.SuitTypeClub, 15),
375 | ddz.NewCard(ddz.SuitTypeSpade, 15),
376 | ddz.NewCard(ddz.SuitTypeJoker, 17),
377 | }
378 |
379 | cardsList, infoList = ddz.SplitCardsBuXiPaiLaiZi(cards, laiZiNums)
380 | fmt.Println("拆牌(不洗牌癞子模式):", cardsList, infoList)
381 |
382 | cards = []*ddz.Card{
383 | ddz.NewCard(ddz.SuitTypeClub, 14),
384 | ddz.NewCard(ddz.SuitTypeHeart, 14),
385 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
386 | ddz.NewCard(ddz.SuitTypeSpade, 14),
387 | ddz.NewCard(ddz.SuitTypeHeart, 5),
388 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
389 | ddz.NewCard(ddz.SuitTypeClub, 9),
390 | ddz.NewCard(ddz.SuitTypeJoker, 17),
391 | }
392 |
393 | cardsList, infoList = ddz.SplitCardsBuXiPaiLaiZi(cards, laiZiNums)
394 | fmt.Println("拆牌2(不洗牌癞子模式):", cardsList, infoList)
395 |
396 | cards = []*ddz.Card{
397 | ddz.NewCard(ddz.SuitTypeClub, 14),
398 | ddz.NewCard(ddz.SuitTypeHeart, 14),
399 | ddz.NewCard(ddz.SuitTypeHeart, 5),
400 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
401 | ddz.NewCard(ddz.SuitTypeClub, 9),
402 | ddz.NewCard(ddz.SuitTypeJoker, 17),
403 | }
404 |
405 | cardsList, infoList = ddz.SplitCardsBuXiPaiLaiZi(cards, laiZiNums)
406 | fmt.Println("拆牌3(不洗牌癞子模式):", cardsList, infoList)
407 | }
408 |
--------------------------------------------------------------------------------
/test/test_card_type.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/fattigerlee/poker/ddz"
6 | )
7 |
8 | func main() {
9 | isDan()
10 | isDui()
11 | isLianDui()
12 | isSanBuDai()
13 | isSanDaiYi()
14 | isSanDaiEr()
15 | isSiDaiDan()
16 | isSiDaiDui()
17 | isShunZi()
18 | isFeiJiBuDai()
19 | isFeiJiDaiYi()
20 | isFeiJiDaiEr()
21 | isZhaDan()
22 | isHuoJian()
23 | isLianZha()
24 | }
25 |
26 | func isDan() {
27 | var cards []*ddz.Card
28 |
29 | cards = []*ddz.Card{
30 | ddz.NewCard(ddz.SuitTypeJoker, 16),
31 | }
32 | fmt.Println("单:", ddz.GetCardType(cards))
33 |
34 | cards = []*ddz.Card{
35 | ddz.NewCard(ddz.SuitTypeJoker, 17),
36 | }
37 | fmt.Println("单:", ddz.GetCardType(cards))
38 | }
39 |
40 | func isDui() {
41 | var cards []*ddz.Card
42 |
43 | cards = []*ddz.Card{
44 | ddz.NewCard(ddz.SuitTypeJoker, 3),
45 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
46 | }
47 | fmt.Println("对:", ddz.GetCardType(cards))
48 |
49 | cards = []*ddz.Card{
50 | ddz.NewCard(ddz.SuitTypeSpade, 3),
51 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
52 | }
53 | fmt.Println("对:", ddz.GetCardType(cards))
54 | }
55 |
56 | func isLianDui() {
57 | var cards []*ddz.Card
58 |
59 | cards = []*ddz.Card{
60 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
61 | ddz.NewCard(ddz.SuitTypeClub, 4),
62 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
63 | ddz.NewCard(ddz.SuitTypeClub, 3),
64 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
65 | ddz.NewCard(ddz.SuitTypeClub, 5),
66 | }
67 | fmt.Println("连对:", ddz.GetCardType(cards))
68 |
69 | cards = []*ddz.Card{
70 | ddz.NewCard(ddz.SuitTypeDiamond, 12),
71 | ddz.NewCard(ddz.SuitTypeDiamond, 12),
72 | ddz.NewCard(ddz.SuitTypeClub, 14),
73 | ddz.NewCard(ddz.SuitTypeSpade, 14),
74 | ddz.NewCard(ddz.SuitTypeDiamond, 13),
75 | ddz.NewCard(ddz.SuitTypeClub, 13),
76 | }
77 | fmt.Println("连对:", ddz.GetCardType(cards))
78 | }
79 |
80 | func isSanBuDai() {
81 | var cards []*ddz.Card
82 |
83 | cards = []*ddz.Card{
84 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
85 | ddz.NewCard(ddz.SuitTypeSpade, 3),
86 | ddz.NewCard(ddz.SuitTypeClub, 3),
87 | }
88 | fmt.Println("三不带:", ddz.GetCardType(cards))
89 | }
90 |
91 | func isSanDaiYi() {
92 | cards := []*ddz.Card{
93 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
94 | ddz.NewCard(ddz.SuitTypeSpade, 3),
95 | ddz.NewCard(ddz.SuitTypeClub, 3),
96 | ddz.NewCard(ddz.SuitTypeClub, 5),
97 | }
98 | fmt.Println("三带一:", ddz.GetCardType(cards))
99 | }
100 |
101 | func isSanDaiEr() {
102 | var cards []*ddz.Card
103 |
104 | cards = []*ddz.Card{
105 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
106 | ddz.NewCard(ddz.SuitTypeSpade, 3),
107 | ddz.NewCard(ddz.SuitTypeClub, 3),
108 | ddz.NewCard(ddz.SuitTypeClub, 5),
109 | ddz.NewCard(ddz.SuitTypeSpade, 5),
110 | }
111 | fmt.Println("三带二:", ddz.GetCardType(cards))
112 | }
113 |
114 | func isSiDaiDan() {
115 | var cards []*ddz.Card
116 |
117 | cards = []*ddz.Card{
118 | ddz.NewCard(ddz.SuitTypeHeart, 3),
119 | ddz.NewCard(ddz.SuitTypeSpade, 3),
120 | ddz.NewCard(ddz.SuitTypeClub, 3),
121 | ddz.NewCard(ddz.SuitTypeSpade, 3),
122 | ddz.NewCard(ddz.SuitTypeSpade, 5),
123 | ddz.NewCard(ddz.SuitTypeSpade, 6),
124 | }
125 | fmt.Println("四带单:", ddz.GetCardType(cards))
126 |
127 | cards = []*ddz.Card{
128 | ddz.NewCard(ddz.SuitTypeHeart, 3),
129 | ddz.NewCard(ddz.SuitTypeSpade, 3),
130 | ddz.NewCard(ddz.SuitTypeClub, 3),
131 | ddz.NewCard(ddz.SuitTypeSpade, 3),
132 | ddz.NewCard(ddz.SuitTypeJoker, 16),
133 | ddz.NewCard(ddz.SuitTypeJoker, 17),
134 | }
135 | fmt.Println("四带单:", ddz.GetCardType(cards))
136 | }
137 |
138 | func isSiDaiDui() {
139 | var cards []*ddz.Card
140 |
141 | cards = []*ddz.Card{
142 | ddz.NewCard(ddz.SuitTypeHeart, 3),
143 | ddz.NewCard(ddz.SuitTypeSpade, 3),
144 | ddz.NewCard(ddz.SuitTypeClub, 3),
145 | ddz.NewCard(ddz.SuitTypeSpade, 3),
146 | ddz.NewCard(ddz.SuitTypeSpade, 5),
147 | ddz.NewCard(ddz.SuitTypeHeart, 5),
148 | ddz.NewCard(ddz.SuitTypeSpade, 7),
149 | ddz.NewCard(ddz.SuitTypeHeart, 7),
150 | }
151 | fmt.Println("四带对:", ddz.GetCardType(cards))
152 |
153 | cards = []*ddz.Card{
154 | ddz.NewCard(ddz.SuitTypeHeart, 4),
155 | ddz.NewCard(ddz.SuitTypeSpade, 4),
156 | ddz.NewCard(ddz.SuitTypeClub, 4),
157 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
158 | ddz.NewCard(ddz.SuitTypeSpade, 14),
159 | ddz.NewCard(ddz.SuitTypeHeart, 14),
160 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
161 | ddz.NewCard(ddz.SuitTypeClub, 14),
162 | }
163 | fmt.Println("四带对:", ddz.GetCardType(cards))
164 |
165 | cards = []*ddz.Card{
166 | ddz.NewCard(ddz.SuitTypeHeart, 14),
167 | ddz.NewCard(ddz.SuitTypeSpade, 14),
168 | ddz.NewCard(ddz.SuitTypeClub, 14),
169 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
170 | ddz.NewCard(ddz.SuitTypeSpade, 15),
171 | ddz.NewCard(ddz.SuitTypeHeart, 15),
172 | ddz.NewCard(ddz.SuitTypeDiamond, 15),
173 | ddz.NewCard(ddz.SuitTypeClub, 15),
174 | }
175 | fmt.Println("四带对:", ddz.GetCardType(cards))
176 | }
177 |
178 | func isShunZi() {
179 | var cards []*ddz.Card
180 |
181 | cards = []*ddz.Card{
182 | ddz.NewCard(ddz.SuitTypeHeart, 10),
183 | ddz.NewCard(ddz.SuitTypeSpade, 11),
184 | ddz.NewCard(ddz.SuitTypeClub, 12),
185 | ddz.NewCard(ddz.SuitTypeSpade, 13),
186 | ddz.NewCard(ddz.SuitTypeSpade, 14),
187 | }
188 | fmt.Println("顺子:", ddz.GetCardType(cards))
189 | }
190 |
191 | func isFeiJiBuDai() {
192 | var cards []*ddz.Card
193 |
194 | cards = []*ddz.Card{
195 | ddz.NewCard(ddz.SuitTypeHeart, 12),
196 | ddz.NewCard(ddz.SuitTypeSpade, 12),
197 | ddz.NewCard(ddz.SuitTypeClub, 12),
198 | ddz.NewCard(ddz.SuitTypeHeart, 13),
199 | ddz.NewCard(ddz.SuitTypeSpade, 13),
200 | ddz.NewCard(ddz.SuitTypeClub, 13),
201 | ddz.NewCard(ddz.SuitTypeHeart, 14),
202 | ddz.NewCard(ddz.SuitTypeClub, 14),
203 | ddz.NewCard(ddz.SuitTypeSpade, 14),
204 | }
205 | fmt.Println("飞机不带:", ddz.GetCardType(cards))
206 | }
207 |
208 | func isFeiJiDaiYi() {
209 | var cards []*ddz.Card
210 |
211 | cards = []*ddz.Card{
212 | ddz.NewCard(ddz.SuitTypeHeart, 14),
213 | ddz.NewCard(ddz.SuitTypeSpade, 14),
214 | ddz.NewCard(ddz.SuitTypeClub, 14),
215 | ddz.NewCard(ddz.SuitTypeSpade, 14),
216 | ddz.NewCard(ddz.SuitTypeHeart, 13),
217 | ddz.NewCard(ddz.SuitTypeSpade, 13),
218 | ddz.NewCard(ddz.SuitTypeClub, 13),
219 | ddz.NewCard(ddz.SuitTypeHeart, 5),
220 | }
221 | fmt.Println("飞机带一:", ddz.GetCardType(cards))
222 |
223 | cards = []*ddz.Card{
224 | ddz.NewCard(ddz.SuitTypeHeart, 8),
225 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
226 | ddz.NewCard(ddz.SuitTypeHeart, 9),
227 | ddz.NewCard(ddz.SuitTypeSpade, 9),
228 | ddz.NewCard(ddz.SuitTypeClub, 9),
229 | ddz.NewCard(ddz.SuitTypeHeart, 10),
230 | ddz.NewCard(ddz.SuitTypeSpade, 10),
231 | ddz.NewCard(ddz.SuitTypeClub, 10),
232 | ddz.NewCard(ddz.SuitTypeHeart, 11),
233 | ddz.NewCard(ddz.SuitTypeSpade, 11),
234 | ddz.NewCard(ddz.SuitTypeClub, 11),
235 | ddz.NewCard(ddz.SuitTypeHeart, 12),
236 | ddz.NewCard(ddz.SuitTypeSpade, 12),
237 | ddz.NewCard(ddz.SuitTypeClub, 12),
238 | ddz.NewCard(ddz.SuitTypeHeart, 13),
239 | ddz.NewCard(ddz.SuitTypeSpade, 13),
240 | ddz.NewCard(ddz.SuitTypeClub, 13),
241 | ddz.NewCard(ddz.SuitTypeHeart, 14),
242 | ddz.NewCard(ddz.SuitTypeSpade, 14),
243 | ddz.NewCard(ddz.SuitTypeClub, 14),
244 | }
245 | fmt.Println("飞机带一:", ddz.GetCardType(cards))
246 |
247 | cards = []*ddz.Card{
248 | ddz.NewCard(ddz.SuitTypeHeart, 7),
249 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
250 | ddz.NewCard(ddz.SuitTypeHeart, 8),
251 | ddz.NewCard(ddz.SuitTypeSpade, 8),
252 | ddz.NewCard(ddz.SuitTypeClub, 8),
253 | ddz.NewCard(ddz.SuitTypeHeart, 9),
254 | ddz.NewCard(ddz.SuitTypeSpade, 9),
255 | ddz.NewCard(ddz.SuitTypeClub, 9),
256 | ddz.NewCard(ddz.SuitTypeHeart, 10),
257 | ddz.NewCard(ddz.SuitTypeSpade, 10),
258 | ddz.NewCard(ddz.SuitTypeClub, 10),
259 | ddz.NewCard(ddz.SuitTypeHeart, 11),
260 | ddz.NewCard(ddz.SuitTypeSpade, 11),
261 | ddz.NewCard(ddz.SuitTypeClub, 11),
262 | ddz.NewCard(ddz.SuitTypeHeart, 12),
263 | ddz.NewCard(ddz.SuitTypeSpade, 12),
264 | ddz.NewCard(ddz.SuitTypeClub, 12),
265 | ddz.NewCard(ddz.SuitTypeHeart, 13),
266 | ddz.NewCard(ddz.SuitTypeSpade, 13),
267 | ddz.NewCard(ddz.SuitTypeClub, 13),
268 | }
269 | fmt.Println("飞机带一:", ddz.GetCardType(cards))
270 |
271 | cards = []*ddz.Card{
272 | ddz.NewCard(ddz.SuitTypeHeart, 8),
273 | ddz.NewCard(ddz.SuitTypeHeart, 9),
274 | ddz.NewCard(ddz.SuitTypeSpade, 9),
275 | ddz.NewCard(ddz.SuitTypeClub, 9),
276 | ddz.NewCard(ddz.SuitTypeHeart, 10),
277 | ddz.NewCard(ddz.SuitTypeSpade, 10),
278 | ddz.NewCard(ddz.SuitTypeClub, 10),
279 | ddz.NewCard(ddz.SuitTypeHeart, 11),
280 | ddz.NewCard(ddz.SuitTypeSpade, 11),
281 | ddz.NewCard(ddz.SuitTypeClub, 11),
282 | ddz.NewCard(ddz.SuitTypeHeart, 12),
283 | ddz.NewCard(ddz.SuitTypeSpade, 12),
284 | ddz.NewCard(ddz.SuitTypeClub, 12),
285 | ddz.NewCard(ddz.SuitTypeHeart, 13),
286 | ddz.NewCard(ddz.SuitTypeSpade, 13),
287 | ddz.NewCard(ddz.SuitTypeClub, 13),
288 | ddz.NewCard(ddz.SuitTypeHeart, 14),
289 | ddz.NewCard(ddz.SuitTypeSpade, 14),
290 | ddz.NewCard(ddz.SuitTypeClub, 14),
291 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
292 | }
293 | fmt.Println("飞机带一:", ddz.GetCardType(cards))
294 | }
295 |
296 | func isFeiJiDaiEr() {
297 | var cards []*ddz.Card
298 |
299 | cards = []*ddz.Card{
300 | ddz.NewCard(ddz.SuitTypeHeart, 13),
301 | ddz.NewCard(ddz.SuitTypeSpade, 13),
302 | ddz.NewCard(ddz.SuitTypeClub, 13),
303 | ddz.NewCard(ddz.SuitTypeHeart, 14),
304 | ddz.NewCard(ddz.SuitTypeSpade, 14),
305 | ddz.NewCard(ddz.SuitTypeClub, 14),
306 | ddz.NewCard(ddz.SuitTypeSpade, 5),
307 | ddz.NewCard(ddz.SuitTypeHeart, 5),
308 | ddz.NewCard(ddz.SuitTypeClub, 6),
309 | ddz.NewCard(ddz.SuitTypeSpade, 6),
310 | }
311 | fmt.Println("飞机带二:", ddz.GetCardType(cards))
312 |
313 | cards = []*ddz.Card{
314 | ddz.NewCard(ddz.SuitTypeHeart, 8),
315 | ddz.NewCard(ddz.SuitTypeSpade, 8),
316 | ddz.NewCard(ddz.SuitTypeClub, 8),
317 | ddz.NewCard(ddz.SuitTypeHeart, 9),
318 | ddz.NewCard(ddz.SuitTypeSpade, 9),
319 | ddz.NewCard(ddz.SuitTypeClub, 9),
320 | ddz.NewCard(ddz.SuitTypeSpade, 10),
321 | ddz.NewCard(ddz.SuitTypeHeart, 10),
322 | ddz.NewCard(ddz.SuitTypeClub, 10),
323 | ddz.NewCard(ddz.SuitTypeSpade, 10),
324 | }
325 | fmt.Println("飞机带二:", ddz.GetCardType(cards))
326 |
327 | cards = []*ddz.Card{
328 | ddz.NewCard(ddz.SuitTypeHeart, 5),
329 | ddz.NewCard(ddz.SuitTypeSpade, 5),
330 | ddz.NewCard(ddz.SuitTypeClub, 6),
331 | ddz.NewCard(ddz.SuitTypeHeart, 6),
332 | ddz.NewCard(ddz.SuitTypeSpade, 6),
333 | ddz.NewCard(ddz.SuitTypeClub, 6),
334 | ddz.NewCard(ddz.SuitTypeSpade, 9),
335 | ddz.NewCard(ddz.SuitTypeHeart, 9),
336 | ddz.NewCard(ddz.SuitTypeClub, 9),
337 | ddz.NewCard(ddz.SuitTypeSpade, 10),
338 | ddz.NewCard(ddz.SuitTypeHeart, 10),
339 | ddz.NewCard(ddz.SuitTypeClub, 10),
340 | ddz.NewCard(ddz.SuitTypeSpade, 11),
341 | ddz.NewCard(ddz.SuitTypeHeart, 11),
342 | ddz.NewCard(ddz.SuitTypeClub, 11),
343 | ddz.NewCard(ddz.SuitTypeSpade, 12),
344 | ddz.NewCard(ddz.SuitTypeHeart, 12),
345 | ddz.NewCard(ddz.SuitTypeClub, 12),
346 | ddz.NewCard(ddz.SuitTypeHeart, 15),
347 | ddz.NewCard(ddz.SuitTypeClub, 15),
348 | }
349 | fmt.Println("飞机带二:", ddz.GetCardType(cards))
350 | }
351 |
352 | func isZhaDan() {
353 | var cards []*ddz.Card
354 |
355 | cards = []*ddz.Card{
356 | ddz.NewCard(ddz.SuitTypeHeart, 5),
357 | ddz.NewCard(ddz.SuitTypeSpade, 5),
358 | ddz.NewCard(ddz.SuitTypeClub, 5),
359 | ddz.NewCard(ddz.SuitTypeSpade, 5),
360 | }
361 | fmt.Println("炸弹:", ddz.GetCardType(cards))
362 | }
363 |
364 | func isLianZha() {
365 | var cards []*ddz.Card
366 |
367 | cards = []*ddz.Card{
368 | ddz.NewCard(ddz.SuitTypeHeart, 13),
369 | ddz.NewCard(ddz.SuitTypeSpade, 13),
370 | ddz.NewCard(ddz.SuitTypeClub, 13),
371 | ddz.NewCard(ddz.SuitTypeSpade, 13),
372 | ddz.NewCard(ddz.SuitTypeHeart, 14),
373 | ddz.NewCard(ddz.SuitTypeSpade, 14),
374 | ddz.NewCard(ddz.SuitTypeClub, 14),
375 | ddz.NewCard(ddz.SuitTypeSpade, 14),
376 | }
377 | fmt.Println("连炸:", ddz.GetCardType(cards))
378 | }
379 |
380 | func isHuoJian() {
381 | var cards []*ddz.Card
382 |
383 | cards = []*ddz.Card{
384 | ddz.NewCard(ddz.SuitTypeJoker, 17),
385 | ddz.NewCard(ddz.SuitTypeJoker, 16),
386 | }
387 | fmt.Println("火箭:", ddz.GetCardType(cards))
388 | }
389 |
--------------------------------------------------------------------------------
/test/test_card_type_lai_zi.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/fattigerlee/poker/ddz"
6 | )
7 |
8 | func main() {
9 | laiZiNums := []ddz.NumType{16, 17}
10 |
11 | isDanLaiZi(laiZiNums)
12 | isDuiLaiZi(laiZiNums)
13 |
14 | isSanBuDaiLaiZi(laiZiNums)
15 | isSanDaiYiLaiZi(laiZiNums)
16 | isSanDaiErLaiZi(laiZiNums)
17 |
18 | isSiDaiDanLaiZi(laiZiNums)
19 | isSiDaiDuiLaiZi(laiZiNums)
20 |
21 | isShunZiLaiZi(laiZiNums)
22 | isLianDuiLaiZi(laiZiNums)
23 |
24 | isFeiJiBuDaiLaiZi(laiZiNums)
25 | isFeiJiDaiYiLaiZi(laiZiNums)
26 | isFeiJiDaiErLaiZi(laiZiNums)
27 |
28 | isLaiZiHuoJian(laiZiNums)
29 |
30 | isLaiZiZhaDan4(laiZiNums)
31 | isChunLaiZiZhaDan(laiZiNums)
32 |
33 | isRuanZhaDan4(laiZiNums)
34 | isRuanZhaDan5(laiZiNums)
35 | isRuanLianZhaDan(laiZiNums)
36 | }
37 |
38 | func isDanLaiZi(laiZiNums []ddz.NumType) {
39 | var cards []*ddz.Card
40 |
41 | cards = []*ddz.Card{
42 | ddz.NewCard(ddz.SuitTypeSpade, 3),
43 | }
44 | fmt.Println("单:", ddz.GetCardType(cards, laiZiNums...))
45 |
46 | cards = []*ddz.Card{
47 | ddz.NewCard(ddz.SuitTypeSpade, 9),
48 | }
49 | fmt.Println("单:", ddz.GetCardType(cards))
50 | }
51 |
52 | func isDuiLaiZi(laiZiNums []ddz.NumType) {
53 | var cards []*ddz.Card
54 |
55 | cards = []*ddz.Card{
56 | ddz.NewCard(ddz.SuitTypeHeart, 3),
57 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
58 | }
59 | fmt.Println("对:", ddz.GetCardType(cards, laiZiNums...))
60 |
61 | cards = []*ddz.Card{
62 | ddz.NewCard(ddz.SuitTypeSpade, 9),
63 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
64 | }
65 | fmt.Println("对:", ddz.GetCardType(cards, laiZiNums...))
66 | }
67 |
68 | func isSanBuDaiLaiZi(laiZiNums []ddz.NumType) {
69 | var cards []*ddz.Card
70 |
71 | cards = []*ddz.Card{
72 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
73 | ddz.NewCard(ddz.SuitTypeSpade, 9),
74 | ddz.NewCard(ddz.SuitTypeClub, 9),
75 | }
76 | fmt.Println("三不带:", ddz.GetCardType(cards, laiZiNums...))
77 |
78 | cards = []*ddz.Card{
79 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
80 | ddz.NewCard(ddz.SuitTypeSpade, 3),
81 | ddz.NewCard(ddz.SuitTypeClub, 9),
82 | }
83 | fmt.Println("三不带:", ddz.GetCardType(cards, laiZiNums...))
84 |
85 | cards = []*ddz.Card{
86 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
87 | ddz.NewCard(ddz.SuitTypeSpade, 9),
88 | ddz.NewCard(ddz.SuitTypeClub, 9),
89 | }
90 | fmt.Println("三不带:", ddz.GetCardType(cards, laiZiNums...))
91 | }
92 |
93 | func isSanDaiYiLaiZi(laiZiNums []ddz.NumType) {
94 | var cards []*ddz.Card
95 |
96 | cards = []*ddz.Card{
97 | ddz.NewCard(ddz.SuitTypeHeart, 3),
98 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
99 | ddz.NewCard(ddz.SuitTypeSpade, 3),
100 | ddz.NewCard(ddz.SuitTypeClub, 9),
101 | }
102 | fmt.Println("三带一:", ddz.GetCardType(cards, laiZiNums...))
103 |
104 | cards = []*ddz.Card{
105 | ddz.NewCard(ddz.SuitTypeHeart, 3),
106 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
107 | ddz.NewCard(ddz.SuitTypeSpade, 9),
108 | ddz.NewCard(ddz.SuitTypeClub, 9),
109 | }
110 | fmt.Println("三带一:", ddz.GetCardType(cards, laiZiNums...))
111 | }
112 |
113 | func isSanDaiErLaiZi(laiZiNums []ddz.NumType) {
114 | var cards []*ddz.Card
115 |
116 | cards = []*ddz.Card{
117 | ddz.NewCard(ddz.SuitTypeHeart, 3),
118 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
119 | ddz.NewCard(ddz.SuitTypeHeart, 4),
120 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
121 | ddz.NewCard(ddz.SuitTypeClub, 9),
122 | }
123 | fmt.Println("三带二:", ddz.GetCardType(cards, laiZiNums...))
124 |
125 | cards = []*ddz.Card{
126 | ddz.NewCard(ddz.SuitTypeHeart, 3),
127 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
128 | ddz.NewCard(ddz.SuitTypeHeart, 9),
129 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
130 | ddz.NewCard(ddz.SuitTypeClub, 9),
131 | }
132 | fmt.Println("三带二:", ddz.GetCardType(cards, laiZiNums...))
133 |
134 | cards = []*ddz.Card{
135 | ddz.NewCard(ddz.SuitTypeHeart, 3),
136 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
137 | ddz.NewCard(ddz.SuitTypeHeart, 4),
138 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
139 | ddz.NewCard(ddz.SuitTypeClub, 9),
140 | }
141 | fmt.Println("三带二:", ddz.GetCardType(cards, laiZiNums...))
142 |
143 | cards = []*ddz.Card{
144 | ddz.NewCard(ddz.SuitTypeHeart, 8),
145 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
146 | ddz.NewCard(ddz.SuitTypeHeart, 8),
147 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
148 | ddz.NewCard(ddz.SuitTypeClub, 3),
149 | }
150 | fmt.Println("三带二:", ddz.GetCardType(cards, laiZiNums...))
151 | }
152 |
153 | func isSiDaiDanLaiZi(laiZiNums []ddz.NumType) {
154 | var cards []*ddz.Card
155 |
156 | cards = []*ddz.Card{
157 | ddz.NewCard(ddz.SuitTypeHeart, 3),
158 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
159 | ddz.NewCard(ddz.SuitTypeHeart, 3),
160 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
161 | ddz.NewCard(ddz.SuitTypeClub, 8),
162 | ddz.NewCard(ddz.SuitTypeClub, 9),
163 | }
164 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
165 |
166 | cards = []*ddz.Card{
167 | ddz.NewCard(ddz.SuitTypeHeart, 3),
168 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
169 | ddz.NewCard(ddz.SuitTypeHeart, 3),
170 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
171 | ddz.NewCard(ddz.SuitTypeClub, 8),
172 | ddz.NewCard(ddz.SuitTypeClub, 9),
173 | }
174 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
175 |
176 | cards = []*ddz.Card{
177 | ddz.NewCard(ddz.SuitTypeHeart, 3),
178 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
179 | ddz.NewCard(ddz.SuitTypeHeart, 3),
180 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
181 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
182 | ddz.NewCard(ddz.SuitTypeClub, 9),
183 | }
184 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
185 |
186 | cards = []*ddz.Card{
187 | ddz.NewCard(ddz.SuitTypeHeart, 3),
188 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
189 | ddz.NewCard(ddz.SuitTypeHeart, 4),
190 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
191 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
192 | ddz.NewCard(ddz.SuitTypeClub, 9),
193 | }
194 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
195 |
196 | cards = []*ddz.Card{
197 | ddz.NewCard(ddz.SuitTypeHeart, 3),
198 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
199 | ddz.NewCard(ddz.SuitTypeHeart, 4),
200 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
201 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
202 | ddz.NewCard(ddz.SuitTypeClub, 9),
203 | }
204 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
205 |
206 | cards = []*ddz.Card{
207 | ddz.NewCard(ddz.SuitTypeHeart, 3),
208 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
209 | ddz.NewCard(ddz.SuitTypeHeart, 4),
210 | ddz.NewCard(ddz.SuitTypeSpade, 9),
211 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
212 | ddz.NewCard(ddz.SuitTypeClub, 9),
213 | }
214 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
215 |
216 | cards = []*ddz.Card{
217 | ddz.NewCard(ddz.SuitTypeHeart, 3),
218 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
219 | ddz.NewCard(ddz.SuitTypeHeart, 4),
220 | ddz.NewCard(ddz.SuitTypeSpade, 9),
221 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
222 | ddz.NewCard(ddz.SuitTypeClub, 9),
223 | }
224 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
225 |
226 | cards = []*ddz.Card{
227 | ddz.NewCard(ddz.SuitTypeHeart, 3),
228 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
229 | ddz.NewCard(ddz.SuitTypeHeart, 9),
230 | ddz.NewCard(ddz.SuitTypeSpade, 9),
231 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
232 | ddz.NewCard(ddz.SuitTypeClub, 9),
233 | }
234 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
235 |
236 | cards = []*ddz.Card{
237 | ddz.NewCard(ddz.SuitTypeJoker, 16),
238 | ddz.NewCard(ddz.SuitTypeJoker, 17),
239 | ddz.NewCard(ddz.SuitTypeHeart, 9),
240 | ddz.NewCard(ddz.SuitTypeSpade, 9),
241 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
242 | ddz.NewCard(ddz.SuitTypeClub, 9),
243 | }
244 | fmt.Println("四带单:", ddz.GetCardType(cards, laiZiNums...))
245 | }
246 |
247 | func isSiDaiDuiLaiZi(laiZiNums []ddz.NumType) {
248 | var cards []*ddz.Card
249 |
250 | cards = []*ddz.Card{
251 | ddz.NewCard(ddz.SuitTypeHeart, 3),
252 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
253 | ddz.NewCard(ddz.SuitTypeHeart, 4),
254 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
255 | ddz.NewCard(ddz.SuitTypeHeart, 8),
256 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
257 | ddz.NewCard(ddz.SuitTypeHeart, 6),
258 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
259 | }
260 | fmt.Println("四带对:", ddz.GetCardType(cards, laiZiNums...))
261 |
262 | cards = []*ddz.Card{
263 | ddz.NewCard(ddz.SuitTypeHeart, 3),
264 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
265 | ddz.NewCard(ddz.SuitTypeHeart, 3),
266 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
267 | ddz.NewCard(ddz.SuitTypeHeart, 8),
268 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
269 | ddz.NewCard(ddz.SuitTypeHeart, 6),
270 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
271 | }
272 | fmt.Println("四带对:", ddz.GetCardType(cards, laiZiNums...))
273 |
274 | cards = []*ddz.Card{
275 | ddz.NewCard(ddz.SuitTypeHeart, 7),
276 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
277 | ddz.NewCard(ddz.SuitTypeHeart, 9),
278 | ddz.NewCard(ddz.SuitTypeSpade, 9),
279 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
280 | ddz.NewCard(ddz.SuitTypeClub, 9),
281 | ddz.NewCard(ddz.SuitTypeHeart, 10),
282 | ddz.NewCard(ddz.SuitTypeSpade, 10),
283 | }
284 | fmt.Println("四带对:", ddz.GetCardType(cards, laiZiNums...))
285 |
286 | cards = []*ddz.Card{
287 | ddz.NewCard(ddz.SuitTypeHeart, 8),
288 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
289 | ddz.NewCard(ddz.SuitTypeSpade, 8),
290 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
291 | ddz.NewCard(ddz.SuitTypeClub, 7),
292 | ddz.NewCard(ddz.SuitTypeJoker, 16),
293 | }
294 | fmt.Println("四带对:", ddz.GetCardType(cards, laiZiNums...))
295 | }
296 |
297 | func isShunZiLaiZi(laiZiNums []ddz.NumType) {
298 | var cards []*ddz.Card
299 |
300 | cards = []*ddz.Card{
301 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
302 | ddz.NewCard(ddz.SuitTypeClub, 4),
303 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
304 | ddz.NewCard(ddz.SuitTypeClub, 6),
305 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
306 | ddz.NewCard(ddz.SuitTypeClub, 8),
307 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
308 | }
309 | fmt.Println("顺子:", ddz.GetCardType(cards, laiZiNums...))
310 |
311 | cards = []*ddz.Card{
312 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
313 | ddz.NewCard(ddz.SuitTypeClub, 8),
314 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
315 | ddz.NewCard(ddz.SuitTypeClub, 9),
316 | ddz.NewCard(ddz.SuitTypeSpade, 9),
317 | ddz.NewCard(ddz.SuitTypeHeart, 9),
318 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
319 | ddz.NewCard(ddz.SuitTypeClub, 10),
320 | ddz.NewCard(ddz.SuitTypeSpade, 10),
321 | ddz.NewCard(ddz.SuitTypeHeart, 10),
322 | }
323 | fmt.Println("顺子:", ddz.GetCardType(cards, laiZiNums...))
324 |
325 | cards = []*ddz.Card{
326 | ddz.NewCard(ddz.SuitTypeDiamond, 11),
327 | ddz.NewCard(ddz.SuitTypeClub, 12),
328 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
329 | ddz.NewCard(ddz.SuitTypeClub, 9),
330 | ddz.NewCard(ddz.SuitTypeSpade, 9),
331 | ddz.NewCard(ddz.SuitTypeHeart, 9),
332 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
333 | ddz.NewCard(ddz.SuitTypeClub, 10),
334 | ddz.NewCard(ddz.SuitTypeSpade, 10),
335 | ddz.NewCard(ddz.SuitTypeHeart, 10),
336 | }
337 | fmt.Println("顺子:", ddz.GetCardType(cards, laiZiNums...))
338 | }
339 |
340 | func isLianDuiLaiZi(laiZiNums []ddz.NumType) {
341 | var cards []*ddz.Card
342 |
343 | cards = []*ddz.Card{
344 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
345 | ddz.NewCard(ddz.SuitTypeClub, 3),
346 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
347 | ddz.NewCard(ddz.SuitTypeClub, 4),
348 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
349 | ddz.NewCard(ddz.SuitTypeClub, 8),
350 | }
351 | fmt.Println("连对:", ddz.GetCardType(cards, laiZiNums...))
352 |
353 | cards = []*ddz.Card{
354 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
355 | ddz.NewCard(ddz.SuitTypeClub, 3),
356 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
357 | ddz.NewCard(ddz.SuitTypeClub, 4),
358 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
359 | ddz.NewCard(ddz.SuitTypeClub, 5),
360 | }
361 | fmt.Println("连对:", ddz.GetCardType(cards, laiZiNums...))
362 |
363 | cards = []*ddz.Card{
364 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
365 | ddz.NewCard(ddz.SuitTypeClub, 8),
366 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
367 | ddz.NewCard(ddz.SuitTypeClub, 8),
368 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
369 | ddz.NewCard(ddz.SuitTypeClub, 8),
370 | }
371 | fmt.Println("连对:", ddz.GetCardType(cards, laiZiNums...))
372 |
373 | cards = []*ddz.Card{
374 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
375 | ddz.NewCard(ddz.SuitTypeClub, 7),
376 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
377 | ddz.NewCard(ddz.SuitTypeClub, 8),
378 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
379 | ddz.NewCard(ddz.SuitTypeClub, 9),
380 | ddz.NewCard(ddz.SuitTypeSpade, 9),
381 | ddz.NewCard(ddz.SuitTypeHeart, 9),
382 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
383 | ddz.NewCard(ddz.SuitTypeClub, 10),
384 | ddz.NewCard(ddz.SuitTypeSpade, 10),
385 | ddz.NewCard(ddz.SuitTypeHeart, 10),
386 | }
387 | fmt.Println("连对:", ddz.GetCardType(cards, laiZiNums...))
388 |
389 | cards = []*ddz.Card{
390 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
391 | ddz.NewCard(ddz.SuitTypeClub, 7),
392 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
393 | ddz.NewCard(ddz.SuitTypeClub, 8),
394 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
395 | ddz.NewCard(ddz.SuitTypeClub, 9),
396 | ddz.NewCard(ddz.SuitTypeSpade, 9),
397 | ddz.NewCard(ddz.SuitTypeHeart, 9),
398 | }
399 | fmt.Println("连对:", ddz.GetCardType(cards, laiZiNums...))
400 | }
401 |
402 | func isFeiJiBuDaiLaiZi(laiZiNums []ddz.NumType) {
403 | var cards []*ddz.Card
404 |
405 | cards = []*ddz.Card{
406 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
407 | ddz.NewCard(ddz.SuitTypeClub, 3),
408 | ddz.NewCard(ddz.SuitTypeSpade, 3),
409 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
410 | ddz.NewCard(ddz.SuitTypeClub, 4),
411 | ddz.NewCard(ddz.SuitTypeSpade, 4),
412 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
413 | ddz.NewCard(ddz.SuitTypeClub, 9),
414 | ddz.NewCard(ddz.SuitTypeSpade, 9),
415 | }
416 | fmt.Println("飞机不带:", ddz.GetCardType(cards, laiZiNums...))
417 |
418 | cards = []*ddz.Card{
419 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
420 | ddz.NewCard(ddz.SuitTypeClub, 4),
421 | ddz.NewCard(ddz.SuitTypeClub, 5),
422 | ddz.NewCard(ddz.SuitTypeClub, 6),
423 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
424 | ddz.NewCard(ddz.SuitTypeClub, 9),
425 | ddz.NewCard(ddz.SuitTypeSpade, 9),
426 | ddz.NewCard(ddz.SuitTypeHeart, 9),
427 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
428 | ddz.NewCard(ddz.SuitTypeClub, 10),
429 | ddz.NewCard(ddz.SuitTypeSpade, 10),
430 | ddz.NewCard(ddz.SuitTypeHeart, 10),
431 | }
432 | fmt.Println("飞机不带:", ddz.GetCardType(cards, laiZiNums...))
433 |
434 | cards = []*ddz.Card{
435 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
436 | ddz.NewCard(ddz.SuitTypeClub, 4),
437 | ddz.NewCard(ddz.SuitTypeClub, 3),
438 | ddz.NewCard(ddz.SuitTypeClub, 5),
439 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
440 | ddz.NewCard(ddz.SuitTypeClub, 9),
441 | ddz.NewCard(ddz.SuitTypeSpade, 9),
442 | ddz.NewCard(ddz.SuitTypeHeart, 9),
443 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
444 | ddz.NewCard(ddz.SuitTypeClub, 10),
445 | ddz.NewCard(ddz.SuitTypeSpade, 10),
446 | ddz.NewCard(ddz.SuitTypeHeart, 10),
447 | }
448 | fmt.Println("飞机不带:", ddz.GetCardType(cards, laiZiNums...))
449 |
450 | cards = []*ddz.Card{
451 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
452 | ddz.NewCard(ddz.SuitTypeClub, 5),
453 | ddz.NewCard(ddz.SuitTypeSpade, 5),
454 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
455 | ddz.NewCard(ddz.SuitTypeClub, 4),
456 | ddz.NewCard(ddz.SuitTypeSpade, 4),
457 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
458 | ddz.NewCard(ddz.SuitTypeClub, 9),
459 | ddz.NewCard(ddz.SuitTypeSpade, 9),
460 | }
461 | fmt.Println("飞机不带:", ddz.GetCardType(cards, laiZiNums...))
462 | }
463 |
464 | func isFeiJiDaiYiLaiZi(laiZiNums []ddz.NumType) {
465 | var cards []*ddz.Card
466 |
467 | cards = []*ddz.Card{
468 | ddz.NewCard(ddz.SuitTypeClub, 3),
469 | ddz.NewCard(ddz.SuitTypeSpade, 3),
470 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
471 | ddz.NewCard(ddz.SuitTypeClub, 4),
472 | ddz.NewCard(ddz.SuitTypeSpade, 4),
473 | ddz.NewCard(ddz.SuitTypeDiamond, 5),
474 | ddz.NewCard(ddz.SuitTypeClub, 6),
475 | ddz.NewCard(ddz.SuitTypeSpade, 9),
476 | }
477 | fmt.Println("飞机带一:", ddz.GetCardType(cards, laiZiNums...))
478 |
479 | cards = []*ddz.Card{
480 | ddz.NewCard(ddz.SuitTypeClub, 5),
481 | ddz.NewCard(ddz.SuitTypeSpade, 5),
482 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
483 | ddz.NewCard(ddz.SuitTypeClub, 4),
484 | ddz.NewCard(ddz.SuitTypeSpade, 5),
485 | ddz.NewCard(ddz.SuitTypeDiamond, 4),
486 | ddz.NewCard(ddz.SuitTypeClub, 6),
487 | ddz.NewCard(ddz.SuitTypeSpade, 6),
488 | ddz.NewCard(ddz.SuitTypeDiamond, 6),
489 | ddz.NewCard(ddz.SuitTypeSpade, 7),
490 | ddz.NewCard(ddz.SuitTypeDiamond, 17),
491 | ddz.NewCard(ddz.SuitTypeClub, 10),
492 | ddz.NewCard(ddz.SuitTypeSpade, 10),
493 | ddz.NewCard(ddz.SuitTypeClub, 10),
494 | ddz.NewCard(ddz.SuitTypeSpade, 10),
495 | ddz.NewCard(ddz.SuitTypeSpade, 9),
496 | }
497 | fmt.Println("飞机带一:", ddz.GetCardType(cards, laiZiNums...))
498 |
499 | cards = []*ddz.Card{
500 | ddz.NewCard(ddz.SuitTypeSpade, 7),
501 | ddz.NewCard(ddz.SuitTypeDiamond, 7),
502 | ddz.NewCard(ddz.SuitTypeSpade, 8),
503 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
504 | ddz.NewCard(ddz.SuitTypeClub, 10),
505 | ddz.NewCard(ddz.SuitTypeSpade, 10),
506 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
507 | ddz.NewCard(ddz.SuitTypeHeart, 10),
508 | ddz.NewCard(ddz.SuitTypeClub, 9),
509 | ddz.NewCard(ddz.SuitTypeSpade, 9),
510 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
511 | ddz.NewCard(ddz.SuitTypeHeart, 9),
512 | }
513 | fmt.Println("飞机带一:", ddz.GetCardType(cards, laiZiNums...))
514 |
515 | cards = []*ddz.Card{
516 | ddz.NewCard(ddz.SuitTypeSpade, 7),
517 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
518 | ddz.NewCard(ddz.SuitTypeClub, 10),
519 | ddz.NewCard(ddz.SuitTypeSpade, 10),
520 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
521 | ddz.NewCard(ddz.SuitTypeHeart, 10),
522 | ddz.NewCard(ddz.SuitTypeClub, 9),
523 | ddz.NewCard(ddz.SuitTypeSpade, 9),
524 | }
525 | fmt.Println("飞机带一:", ddz.GetCardType(cards, laiZiNums...))
526 | }
527 |
528 | func isFeiJiDaiErLaiZi(laiZiNums []ddz.NumType) {
529 | var cards []*ddz.Card
530 |
531 | cards = []*ddz.Card{
532 | ddz.NewCard(ddz.SuitTypeSpade, 7),
533 | ddz.NewCard(ddz.SuitTypeSpade, 8),
534 | ddz.NewCard(ddz.SuitTypeClub, 10),
535 | ddz.NewCard(ddz.SuitTypeSpade, 10),
536 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
537 | ddz.NewCard(ddz.SuitTypeHeart, 10),
538 | ddz.NewCard(ddz.SuitTypeClub, 9),
539 | ddz.NewCard(ddz.SuitTypeSpade, 9),
540 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
541 | ddz.NewCard(ddz.SuitTypeHeart, 9),
542 | }
543 | fmt.Println("飞机带二:", ddz.GetCardType(cards, laiZiNums...))
544 |
545 | cards = []*ddz.Card{
546 | ddz.NewCard(ddz.SuitTypeSpade, 3),
547 | ddz.NewCard(ddz.SuitTypeSpade, 7),
548 | ddz.NewCard(ddz.SuitTypeSpade, 8),
549 | ddz.NewCard(ddz.SuitTypeClub, 10),
550 | ddz.NewCard(ddz.SuitTypeSpade, 10),
551 | ddz.NewCard(ddz.SuitTypeDiamond, 10),
552 | ddz.NewCard(ddz.SuitTypeHeart, 10),
553 | ddz.NewCard(ddz.SuitTypeClub, 9),
554 | ddz.NewCard(ddz.SuitTypeSpade, 9),
555 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
556 | }
557 | fmt.Println("飞机带二:", ddz.GetCardType(cards, laiZiNums...))
558 | }
559 |
560 | func isLaiZiHuoJian(laiZiNums []ddz.NumType) {
561 | laiZiNums = []ddz.NumType{16, 17}
562 |
563 | var cards []*ddz.Card
564 |
565 | cards = []*ddz.Card{
566 | ddz.NewCard(ddz.SuitTypeJoker, 17),
567 | ddz.NewCard(ddz.SuitTypeJoker, 16),
568 | }
569 | fmt.Println("火箭:", ddz.GetCardType(cards, laiZiNums...))
570 | }
571 |
572 | func isLaiZiZhaDan4(laiZiNums []ddz.NumType) {
573 | var cards []*ddz.Card
574 |
575 | cards = []*ddz.Card{
576 | ddz.NewCard(ddz.SuitTypeHeart, 9),
577 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
578 | ddz.NewCard(ddz.SuitTypeSpade, 9),
579 | ddz.NewCard(ddz.SuitTypeClub, 10),
580 | }
581 | fmt.Println("四癞子炸:", ddz.GetCardType(cards, laiZiNums...))
582 | }
583 |
584 | func isChunLaiZiZhaDan(laiZiNums []ddz.NumType) {
585 | var cards []*ddz.Card
586 |
587 | cards = []*ddz.Card{
588 | ddz.NewCard(ddz.SuitTypeHeart, 9),
589 | ddz.NewCard(ddz.SuitTypeDiamond, 9),
590 | ddz.NewCard(ddz.SuitTypeSpade, 9),
591 | ddz.NewCard(ddz.SuitTypeClub, 9),
592 | }
593 | fmt.Println("四纯癞子炸:", ddz.GetCardType(cards, laiZiNums...))
594 | }
595 |
596 | func isRuanZhaDan4(laiZiNums []ddz.NumType) {
597 | var cards []*ddz.Card
598 |
599 | cards = []*ddz.Card{
600 | ddz.NewCard(ddz.SuitTypeHeart, 3),
601 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
602 | ddz.NewCard(ddz.SuitTypeSpade, 3),
603 | ddz.NewCard(ddz.SuitTypeClub, 8),
604 | }
605 | fmt.Println("四软炸:", ddz.GetCardType(cards, laiZiNums...))
606 |
607 | cards = []*ddz.Card{
608 | ddz.NewCard(ddz.SuitTypeHeart, 3),
609 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
610 | ddz.NewCard(ddz.SuitTypeSpade, 8),
611 | ddz.NewCard(ddz.SuitTypeClub, 8),
612 | }
613 | fmt.Println("四软炸:", ddz.GetCardType(cards, laiZiNums...))
614 |
615 | cards = []*ddz.Card{
616 | ddz.NewCard(ddz.SuitTypeHeart, 3),
617 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
618 | ddz.NewCard(ddz.SuitTypeSpade, 8),
619 | ddz.NewCard(ddz.SuitTypeClub, 8),
620 | }
621 | fmt.Println("四软炸:", ddz.GetCardType(cards, laiZiNums...))
622 | }
623 |
624 | func isRuanZhaDan5(laiZiNums []ddz.NumType) {
625 | var cards []*ddz.Card
626 |
627 | cards = []*ddz.Card{
628 | ddz.NewCard(ddz.SuitTypeHeart, 3),
629 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
630 | ddz.NewCard(ddz.SuitTypeSpade, 3),
631 | ddz.NewCard(ddz.SuitTypeClub, 3),
632 | ddz.NewCard(ddz.SuitTypeClub, 8),
633 | }
634 | fmt.Println("五软炸:", ddz.GetCardType(cards, laiZiNums...))
635 |
636 | cards = []*ddz.Card{
637 | ddz.NewCard(ddz.SuitTypeHeart, 3),
638 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
639 | ddz.NewCard(ddz.SuitTypeSpade, 3),
640 | ddz.NewCard(ddz.SuitTypeClub, 9),
641 | ddz.NewCard(ddz.SuitTypeClub, 8),
642 | }
643 | fmt.Println("五软炸:", ddz.GetCardType(cards, laiZiNums...))
644 |
645 | cards = []*ddz.Card{
646 | ddz.NewCard(ddz.SuitTypeHeart, 3),
647 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
648 | ddz.NewCard(ddz.SuitTypeSpade, 9),
649 | ddz.NewCard(ddz.SuitTypeClub, 9),
650 | ddz.NewCard(ddz.SuitTypeClub, 8),
651 | }
652 | fmt.Println("五软炸:", ddz.GetCardType(cards, laiZiNums...))
653 |
654 | cards = []*ddz.Card{
655 | ddz.NewCard(ddz.SuitTypeHeart, 3),
656 | ddz.NewCard(ddz.SuitTypeDiamond, 8),
657 | ddz.NewCard(ddz.SuitTypeSpade, 9),
658 | ddz.NewCard(ddz.SuitTypeClub, 9),
659 | ddz.NewCard(ddz.SuitTypeClub, 8),
660 | }
661 | fmt.Println("五软炸:", ddz.GetCardType(cards, laiZiNums...))
662 |
663 | cards = []*ddz.Card{
664 | ddz.NewCard(ddz.SuitTypeHeart, 11),
665 | ddz.NewCard(ddz.SuitTypeDiamond, 11),
666 | ddz.NewCard(ddz.SuitTypeSpade, 11),
667 | ddz.NewCard(ddz.SuitTypeJoker, 17),
668 | ddz.NewCard(ddz.SuitTypeJoker, 16),
669 | }
670 | fmt.Println("五软炸:", ddz.GetCardType(cards, laiZiNums...))
671 | }
672 |
673 | func isRuanLianZhaDan(laiZiNums []ddz.NumType) {
674 | var cards []*ddz.Card
675 |
676 | cards = []*ddz.Card{
677 | ddz.NewCard(ddz.SuitTypeClub, 3),
678 | ddz.NewCard(ddz.SuitTypeSpade, 3),
679 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
680 | ddz.NewCard(ddz.SuitTypeHeart, 3),
681 | ddz.NewCard(ddz.SuitTypeClub, 4),
682 | ddz.NewCard(ddz.SuitTypeSpade, 4),
683 | ddz.NewCard(ddz.SuitTypeJoker, 16),
684 | ddz.NewCard(ddz.SuitTypeJoker, 17),
685 | }
686 | fmt.Println("软连炸:", ddz.GetCardType(cards, laiZiNums...))
687 |
688 | cards = []*ddz.Card{
689 | ddz.NewCard(ddz.SuitTypeClub, 3),
690 | ddz.NewCard(ddz.SuitTypeSpade, 3),
691 | ddz.NewCard(ddz.SuitTypeDiamond, 3),
692 | ddz.NewCard(ddz.SuitTypeHeart, 4),
693 | ddz.NewCard(ddz.SuitTypeClub, 4),
694 | ddz.NewCard(ddz.SuitTypeSpade, 4),
695 | ddz.NewCard(ddz.SuitTypeJoker, 16),
696 | ddz.NewCard(ddz.SuitTypeJoker, 17),
697 | }
698 | fmt.Println("软连炸:", ddz.GetCardType(cards, laiZiNums...))
699 |
700 | cards = []*ddz.Card{
701 | ddz.NewCard(ddz.SuitTypeClub, 14),
702 | ddz.NewCard(ddz.SuitTypeSpade, 14),
703 | ddz.NewCard(ddz.SuitTypeDiamond, 14),
704 | ddz.NewCard(ddz.SuitTypeHeart, 14),
705 | ddz.NewCard(ddz.SuitTypeClub, 15),
706 | ddz.NewCard(ddz.SuitTypeSpade, 15),
707 | ddz.NewCard(ddz.SuitTypeHeart, 15),
708 | ddz.NewCard(ddz.SuitTypeJoker, 16),
709 | }
710 | fmt.Println("软连炸:", ddz.GetCardType(cards, laiZiNums...))
711 | }
712 |
--------------------------------------------------------------------------------