go开发斗地主

最新推荐文章于 2021-03-07 12:52:34 发布
最新推荐文章于 2021-03-07 12:52:34 发布
阅读量1k 收藏 3
点赞数
分类专栏： go 文章标签： 斗地主 服务端 逻辑实现 牌型判断 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smile__everyday/article/details/108853228
版权
斗地主服务端的主要逻辑

出牌判断

package main

import (
	"errors"
	"math/rand"
	"sort"
)

// 简单的斗地主程序

// 一副牌
type OneDeckOfCards struct {
	Intact   map[int]*Card // 完整的牌
	Discard  map[int]*Card // 打过的牌
	LastPlay *LastCards    // 最后一次出的牌
}

// 单张牌的结构
type Card struct {
	Name     string // 扑克牌的名称
	Number   int    // 这张牌在这负牌创建时的位置
	Current  int    // 在当前牌中的位置
	Color    string // 这张牌的花色
	Size     int    // 这张牌对应的大小
	UsedUser int    // 这张牌是谁打掉的，用于记牌器，防止客户端篡改牌
}

// 最后一次出牌
type LastCards struct {
	PokerType        int         // 牌型
	CountSameCardMax int         // 便于快速判断
	SortCard         []int       // 排序后的出牌
	CountCard        map[int]int // 统计的出牌（包含所有的牌）
}

// 单次出牌
type PlayingCards struct {
	Cards []Card
}

const (
	PokerNumbers           = 54
	PokerKing              = 14 // 小王编号
	PokerBigKing           = 15 // 大王编号
	PokerTypeError         = -1 // 出牌错误
	PokerTypeEmpty         = 0  // 没人出牌，什么牌都可以出
	PokerTypeSingle        = 1  // 单牌
	PokerTypeDouble        = 2  // 对子
	PokerTypeThree         = 3  // 三张
	PokerTypeThreeBeltsOne = 4  // 三带一
	PokerTypeThreeBeltsTwo = 5  // 三带二
	PokerTypeShunZi        = 6  // 顺子678910
	PokerTypeLianDui       = 7  // 连对778899
	PokerTypeFlay          = 8  // 飞机666777888
	PokerTypeFlayBeltsOne  = 9  // 飞机带单
	PokerTypeFlayBeltsTwo  = 10 // 飞机带队
	PokerTypeBoomBeltsOne  = 11 // 炸弹带单张,两个单张或者一个对子
	PokerTypeBoomBeltsTwo  = 12 // 炸弹带对子
	PokerTypeBoom          = 13 // 炸弹
	PokerTypeBoomKing      = 99 // 王炸
)

func main() {
	// 创建牌
	cards, _ := CreatePoker()
	// 洗牌
	cards.ShuffleToPoker()
	// 判断牌的大小

}

// 判断牌是否合理，顺子 三带一 四带二
// 判断牌的类型
func (poker *PlayingCards) CheckType() (*CurrentCards, error) {
	// 对牌进行判断，判断牌型
	// 单 双 三 三带1  三带2 连对  顺子 飞机（带1 带二） 炸弹  王炸
	list := make([]int, len(poker.Cards))
	for key, card := range poker.Cards {
		list[key] = card.Size
	}
	// 对牌进行排序,[2 2 4 6 7 7 10 11 13 13]
	sort.Ints(list)
	// fmt.Println(list)
	// 开始判断牌型
	// 相同牌最多的是多少
	countSameCardMax := 1
	countCard := make(map[int]int, len(poker.Cards))
	sortCard := make([]int, 0)
	for _, value := range list {
		if _, ok := countCard[value]; !ok {
			countCard[value] = 1
			sortCard = append(sortCard, value)
			continue
		}
		countCard[value]++
		if countSameCardMax < countCard[value] {
			countSameCardMax = countCard[value]
		}
	}
	playPoker := &CurrentCards{
		CardTotal: len(poker.Cards),
		SortCard:  sortCard,
		CountCard: countCard,
	}
	// 1 单 或者顺子 王炸 2对子 连队  3 三带一 三带2  飞机带  4 炸弹
	var err error
	switch countSameCardMax {
	case 1:
		// 1 单,顺子 或者 王炸
		playPoker.PokerType, err = poker.countSameCardMaxOne(countCard, sortCard)
		return playPoker, err
	case 2:
		//  2对子 连队
		playPoker.PokerType, err = poker.countSameCardMaxTwo(countCard, sortCard)
		return playPoker, err
	case 3:
		// 3 三带一 三带2  飞机带
		playPoker.PokerType, err = poker.countSameCardMaxThree(countCard)
		return playPoker, err
	case 4:
		// 4 炸弹
		playPoker.PokerType, err = poker.bomb(countCard)
		return playPoker, err
	default:
		return playPoker, errors.New("错误的牌")
	}
}

// 最大值是一张牌的判断(重复牌)
func (poker *PlayingCards) countSameCardMaxOne(countCard map[int]int, sortCard []int) (int, error) {
	// 单牌
	if len(poker.Cards) == len(countCard) && len(countCard) == 1 {
		// 单牌,判断是否可以出牌
		return PokerTypeSingle, nil
	}
	_, king := countCard[PokerKing]
	_, bigKing := countCard[PokerBigKing]
	if king && bigKing {
		// 王炸
		return PokerTypeBoomKing, nil
	}
	if err := poker.checkContinuous(sortCard); err != nil {
		return PokerTypeError, err
	}
	if len(sortCard) < 5 {
		// 未达到最小值
		return PokerTypeError, errors.New("未达到5或以上的顺子，不符合规则")
	}
	return PokerTypeShunZi, nil
}

// 最大值是两张牌的判断(重复牌)
func (poker *PlayingCards) countSameCardMaxTwo(countCard map[int]int, sortCard []int) (int, error) {
	count := len(poker.Cards)
	if count/2 != len(countCard) {
		return PokerTypeError, errors.New("错误的牌，存在单张的牌")
	}
	if count == 2 {
		return PokerTypeDouble, nil
	}
	// 判断是否是连队
	if err := poker.checkContinuous(sortCard); err != nil {
		return PokerTypeError, err
	}
	// 至少要用三队才能是连队
	if len(countCard) < 3 {
		return PokerTypeError, errors.New("未达到连队要求，三队及以上")
	}
	return PokerTypeLianDui, nil
}

// 最大值是三张牌的判断(重复牌)
func (poker *PlayingCards) countSameCardMaxThree(countCard map[int]int) (int, error) {
	// 3 三带一 三带2  飞机带
	count := len(poker.Cards)
	if count == 3 {
		// 三 没带
		return PokerTypeThree, nil
	}
	if count == 4 {
		// 三带1
		return PokerTypeThreeBeltsOne, nil
	}
	if count == 5 && len(countCard) == 2 {
		// 三带二
		return PokerTypeThreeBeltsTwo, nil
	}
	sortCard := make([]int, 0)
	for key, value := range countCard {
		if value == 3 {
			sortCard = append(sortCard, key)
		}
	}
	// 飞机带判断,注意极限情况 三带1 那个1 就是四个三个的
	sort.Ints(sortCard)
	if err := poker.checkContinuous(sortCard); err != nil {
		// 极限情况判断,注意一副牌的斗地主不会出现6对带的情况
		// 头尾去除后都要不是连的情况才是失败的情况
		if len(sortCard) == 4 &&
			len(sortCard) == len(countCard) &&
			((poker.checkContinuous(sortCard[1:]) != nil) ||
				(poker.checkContinuous(sortCard[:3]) != nil)) {
			return PokerTypeFlayBeltsOne, nil
		}
		return PokerTypeError, err
	}
	if len(sortCard) == len(countCard) {
		// 飞机啥也没带
		return PokerTypeFlay, nil
	}
	// 判断带的是否正常
	// 飞机带队
	difference := len(countCard) - len(sortCard)
	if difference == len(sortCard) && count == (len(sortCard)*3+(difference*2)) {
		return PokerTypeFlayBeltsTwo, nil
	}
	// 飞机带单 注意单中有可能是对拆开的，这时候判断牌的数量即可
	if len(poker.Cards) == len(sortCard)*4 {
		return PokerTypeFlayBeltsOne, nil
	}
	return PokerTypeError, errors.New("未知的牌类型，不允许的牌规则")
}

// 炸弹
func (poker *PlayingCards) bomb(countCard map[int]int) (int, error) {
	count := len(poker.Cards)
	if count == 4 {
		// 炸弹
		return PokerTypeBoom, nil
	}
	if count%2 != 0 || len(countCard) > 3 {
		return PokerTypeError, errors.New("错误的带牌")
	}
	if count == 6 {
		// 4 带 二 连张单 或者一个队都是 算为两张单
		return PokerTypeBoomBeltsOne, nil
	}
	// count == 8  四带两对
	return PokerTypeBoomBeltsTwo, nil
}

// 判断牌是否连续
func (poker *PlayingCards) checkContinuous(sortCard []int) error {
	tmp := 0
	for _, value := range sortCard {
		if value >= 13 {
			// 失败，有大于A的牌
			return errors.New("不合理的牌,存在大于A的牌")
		}
		if tmp == 0 {
			tmp = value
			continue
		}
		if value-1 == tmp {
			// 正常
			tmp = value
			continue
		}
		return errors.New("不合理的牌,非连续的牌")
	}
	return nil
}

// 创建扑克牌
func CreatePoker() (*OneDeckOfCards, error) {
	// 扑克的大小
	pokerNumbers := map[string]int{"3": 1, "4": 2, "5": 3, "6": 4, "7": 5, "8": 6, "9": 7, "10": 8, "J": 9, "Q": 10, "K": 11, "A": 12, "2": 13, "小王": 14, "大王": 15}
	// 扑克的花色,注意王的红比黑的大
	pokerColor := map[string]int{"黑桃": 1, "红桃": 2, "方块": 3, "梅花": 4}
	number := 1
	pokers := OneDeckOfCards{
		Intact:  make(map[int]*Card, PokerNumbers),
		Discard: make(map[int]*Card, PokerNumbers),
	}
	for key, value := range pokerNumbers {
		for k, v := range pokerColor {
			if value > 13 && v >= 2 {
				break
			}
			pokers.Intact[number] = &Card{
				Name:    key,
				Number:  number,
				Current: number,
				Color:   k,
				Size:    value,
			}
			number++
		}
	}
	return &pokers, nil
}

// 随机洗牌 Fisher–Yates
func (poker *OneDeckOfCards) ShuffleToPoker() {
	for key, value := range poker.Intact {
		// 获取随机数，通过取余的方法让其落在范围内
		// 交换目标位置和当前位置的值
		current := (rand.Int()) % PokerTotal
		if current == 0 {
			continue
		}
		// 洗牌后需要把编号也修改一下,方便记牌器和后面的判断牌是否被打出去的时候使用
		value.Current = current
		poker.Intact[key] = poker.Intact[current]
		poker.Intact[key].Current = key
		poker.Intact[current] = value
	}
	return
}

测试代码，测试牌型的判断

package main

import (
	"log"
	"testing"
)

func TestOneDeckOfCards_CheckType(t *testing.T) {
	// 创建一副牌，取前10张
	cards, _ := CreatePoker()
	cards.ShuffleToPoker()
	play := &PlayingCards{
		Cards: make([]Card, 10),
	}
	i := 0
	for _, value := range cards.Intact {
		if i > 9 {
			break
		}
		play.Cards[i] = *value
		i++
	}
	play.CheckType()
}

// 判断牌型
func TestPlayingCards_CheckType(t *testing.T) {
	var play PlayingCards
	play = PlayingCards{Cards: make([]Card, 1)}
	play.Cards[0] = Card{Name: "4", Number: 8, Current: 15, Color: "黑桃", Size: 2}
	log.Println(play.CheckType()) // 1 <nil> 单牌

	play = PlayingCards{Cards: make([]Card, 2)}
	play.Cards[0] = Card{Name: "3", Number: 8, Current: 15, Color: "黑桃", Size: 1}
	play.Cards[1] = Card{Name: "3", Number: 9, Current: 20, Color: "红桃", Size: 1}
	log.Println(play.CheckType()) // 2 <nil>  对子

	play = PlayingCards{Cards: make([]Card, 3)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 9, Current: 21, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 10, Current: 22, Color: "梅花", Size: 3}
	log.Println(play.CheckType()) // 3 <nil>

	play = PlayingCards{Cards: make([]Card, 4)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 9, Current: 21, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 10, Current: 22, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "9", Number: 25, Current: 26, Color: "梅花", Size: 7}
	log.Println(play.CheckType()) // 4 <nil>

	play = PlayingCards{Cards: make([]Card, 5)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 9, Current: 21, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 10, Current: 22, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "9", Number: 25, Current: 26, Color: "梅花", Size: 7}
	play.Cards[4] = Card{Name: "9", Number: 27, Current: 30, Color: "黑桃", Size: 7}
	log.Println(play.CheckType()) // 5 <nil>

	play = PlayingCards{Cards: make([]Card, 5)}
	play.Cards[0] = Card{Name: "3", Number: 8, Current: 15, Color: "黑桃", Size: 1}
	play.Cards[1] = Card{Name: "4", Number: 9, Current: 21, Color: "红桃", Size: 2}
	play.Cards[2] = Card{Name: "5", Number: 10, Current: 22, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "6", Number: 25, Current: 26, Color: "梅花", Size: 4}
	play.Cards[4] = Card{Name: "7", Number: 27, Current: 30, Color: "黑桃", Size: 5}
	log.Println(play.CheckType()) // 6 <nil>

	play = PlayingCards{Cards: make([]Card, 6)}
	play.Cards[0] = Card{Name: "10", Number: 8, Current: 15, Color: "黑桃", Size: 8}
	play.Cards[5] = Card{Name: "2", Number: 7, Current: 12, Color: "黑桃", Size: 13}
	play.Cards[1] = Card{Name: "J", Number: 9, Current: 21, Color: "红桃", Size: 9}
	play.Cards[2] = Card{Name: "Q", Number: 10, Current: 22, Color: "梅花", Size: 10}
	play.Cards[3] = Card{Name: "K", Number: 25, Current: 26, Color: "梅花", Size: 11}
	play.Cards[4] = Card{Name: "A", Number: 27, Current: 30, Color: "黑桃", Size: 12}
	log.Println(play.CheckType()) // -1 不合理的牌,存在大于A的牌

	play = PlayingCards{Cards: make([]Card, 4)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 7, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "6", Number: 9, Current: 21, Color: "红桃", Size: 4}
	play.Cards[3] = Card{Name: "6", Number: 10, Current: 22, Color: "梅花", Size: 4}
	log.Println(play.CheckType()) // -1 未达到连队要求，三队及以上

	play = PlayingCards{Cards: make([]Card, 6)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 7, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "6", Number: 9, Current: 21, Color: "红桃", Size: 4}
	play.Cards[3] = Card{Name: "6", Number: 10, Current: 22, Color: "梅花", Size: 4}
	play.Cards[4] = Card{Name: "7", Number: 12, Current: 25, Color: "红桃", Size: 5}
	play.Cards[5] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	log.Println(play.CheckType()) // 7 <nil>

	play = PlayingCards{Cards: make([]Card, 6)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 7, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 9, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "6", Number: 10, Current: 22, Color: "黑桃", Size: 4}
	play.Cards[4] = Card{Name: "6", Number: 12, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "6", Number: 15, Current: 30, Color: "梅花", Size: 4}
	log.Println(play.CheckType()) // 8 <nil>

	play = PlayingCards{Cards: make([]Card, 12)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 7, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 9, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "6", Number: 10, Current: 22, Color: "黑桃", Size: 4}
	play.Cards[4] = Card{Name: "6", Number: 12, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "6", Number: 15, Current: 30, Color: "梅花", Size: 4}
	play.Cards[6] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[7] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[8] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[9] = Card{Name: "8", Number: 15, Current: 30, Color: "梅花", Size: 6}
	play.Cards[10] = Card{Name: "8", Number: 15, Current: 30, Color: "梅花", Size: 6}
	play.Cards[11] = Card{Name: "8", Number: 15, Current: 30, Color: "梅花", Size: 6}
	log.Println(play.CheckType()) // 8 <nil>

	play = PlayingCards{Cards: make([]Card, 12)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 7, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 9, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "6", Number: 10, Current: 22, Color: "黑桃", Size: 4}
	play.Cards[4] = Card{Name: "6", Number: 12, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "6", Number: 15, Current: 30, Color: "梅花", Size: 4}
	play.Cards[6] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[7] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[8] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[9] = Card{Name: "10", Number: 15, Current: 30, Color: "梅花", Size: 8}
	play.Cards[10] = Card{Name: "10", Number: 15, Current: 30, Color: "梅花", Size: 8}
	play.Cards[11] = Card{Name: "10", Number: 15, Current: 30, Color: "梅花", Size: 8}
	log.Println(play.CheckType()) // 9 <nil>

	play = PlayingCards{Cards: make([]Card, 12)}
	play.Cards[0] = Card{Name: "5", Number: 8, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 7, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 9, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "6", Number: 10, Current: 22, Color: "黑桃", Size: 4}
	play.Cards[4] = Card{Name: "6", Number: 12, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "6", Number: 15, Current: 30, Color: "梅花", Size: 4}
	play.Cards[6] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[7] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[8] = Card{Name: "7", Number: 15, Current: 30, Color: "梅花", Size: 5}
	play.Cards[9] = Card{Name: "J", Number: 15, Current: 30, Color: "梅花", Size: 9}
	play.Cards[10] = Card{Name: "K", Number: 15, Current: 30, Color: "梅花", Size: 11}
	play.Cards[11] = Card{Name: "2", Number: 15, Current: 30, Color: "梅花", Size: 13}
	log.Println(play.CheckType()) // 9 <nil>

	play = PlayingCards{Cards: make([]Card, 10)}
	play.Cards[0] = Card{Name: "5", Number: 5, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 6, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 7, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "6", Number: 8, Current: 22, Color: "黑桃", Size: 4}
	play.Cards[4] = Card{Name: "6", Number: 9, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "6", Number: 10, Current: 26, Color: "梅花", Size: 4}
	play.Cards[6] = Card{Name: "7", Number: 11, Current: 27, Color: "梅花", Size: 5}
	play.Cards[7] = Card{Name: "7", Number: 12, Current: 28, Color: "梅花", Size: 5}
	play.Cards[8] = Card{Name: "K", Number: 13, Current: 29, Color: "梅花", Size: 11}
	play.Cards[9] = Card{Name: "K", Number: 15, Current: 30, Color: "梅花", Size: 11}
	log.Println(play.CheckType()) // 10 <nil>

	play = PlayingCards{Cards: make([]Card, 6)}
	play.Cards[0] = Card{Name: "5", Number: 5, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 6, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 7, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "5", Number: 8, Current: 22, Color: "黑桃", Size: 3}
	play.Cards[4] = Card{Name: "6", Number: 9, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "6", Number: 10, Current: 26, Color: "梅花", Size: 4}
	log.Println(play.CheckType()) // 11 <nil>

	play = PlayingCards{Cards: make([]Card, 6)}
	play.Cards[0] = Card{Name: "5", Number: 5, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 6, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 7, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "5", Number: 8, Current: 22, Color: "黑桃", Size: 3}
	play.Cards[4] = Card{Name: "6", Number: 9, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "7", Number: 10, Current: 26, Color: "梅花", Size: 5}
	log.Println(play.CheckType()) // 11 <nil>

	play = PlayingCards{Cards: make([]Card, 8)}
	play.Cards[0] = Card{Name: "5", Number: 5, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 6, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 7, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "5", Number: 8, Current: 22, Color: "黑桃", Size: 3}
	play.Cards[4] = Card{Name: "6", Number: 9, Current: 25, Color: "红桃", Size: 4}
	play.Cards[5] = Card{Name: "6", Number: 10, Current: 26, Color: "梅花", Size: 4}
	play.Cards[6] = Card{Name: "9", Number: 10, Current: 26, Color: "梅花", Size: 7}
	play.Cards[7] = Card{Name: "9", Number: 10, Current: 26, Color: "梅花", Size: 7}
	log.Println(play.CheckType()) // 12 <nil>

	play = PlayingCards{Cards: make([]Card, 4)}
	play.Cards[0] = Card{Name: "5", Number: 5, Current: 15, Color: "黑桃", Size: 3}
	play.Cards[1] = Card{Name: "5", Number: 6, Current: 12, Color: "红桃", Size: 3}
	play.Cards[2] = Card{Name: "5", Number: 7, Current: 21, Color: "梅花", Size: 3}
	play.Cards[3] = Card{Name: "5", Number: 8, Current: 22, Color: "黑桃", Size: 3}
	log.Println(play.CheckType()) // 13 <nil>

	play = PlayingCards{Cards: make([]Card, 2)}
	play.Cards[0] = Card{Name: "小王", Number: 5, Current: 15, Color: "黑桃", Size: 14}
	play.Cards[1] = Card{Name: "大王", Number: 6, Current: 12, Color: "红桃", Size: 15}
	log.Println(play.CheckType()) // 99 <nil>

}
golang斗地主
qq_37144944的博客
04-19 795
项目地址： https://github.com/dwg255/landlord 说明：go modules管理依赖包，执行编译自动下载依赖；使用sqlite数据库，无需配置；自带无脑出牌AI；服务端经过压力测试，客户端代码来自https://github.com/mailgyc/doudizhu ，原版服务端用python tornado开发。golang开发的服务端编程简单，执行高效，有效利用...
golang制作一个斗地主游戏服务器[1]:从扑克牌开始
warrially的专栏
03-14 6222
打牌, 首先就应该从最基础的扑克牌类入手 单个牌来说 斗地主3最小, 然后依次是 ... K, A, 2, 小王, 大王 // 花色 const ( flowerNIL int = iota // 留空 flowerHEITAO // 黑桃(小王) flowerHONGTAO // 红桃(大王) flowerMEIH...
doudizhu:Go实现斗地主核心算法
05-16
Go版本实现斗地主核心算法 紧凑的数据结构高效核心算法 type AnalyseCards uint64 func (this *AnalyseCards) Set(cards []byte) { *this = 0 l := uint8(len(cards)) for i := uint8(0); i < l; i++ { card
Go测试开发(二) 多线程简单斗地主
自动化代码美学
09-12 370
多线程，通道，读写锁（单写多读），随机（洗牌），是本文涉及的主要知识点。 先看一下做出来的效果，因为是实验程序，跟真实的斗地主还是有差距，理解万岁！ [发牌员]：洗牌咯。 刷刷刷... [发牌员]：牌洗好了。 [发牌员]：开始发牌。 [发牌员]：每个人17张牌。 [发牌员]：抢地主。 [fang]：哈哈，我是地主！ fang的牌是[♣9 ♦9 ♥A ♠9 ♣6 ♣5 ♦3 ♣10 ♥5 ♣8 ♠Q ♠A ♠8 ♦4 ♥4 ♦K ♥7 ♣A ♠K ♥3]，共20张。 dong的牌是[大王 ♦8 ♠5 小王 ♠
Go编程(二) 多线程简单斗地主
自动化代码美学
09-12 449
多线程，通道，读写锁(单写多读)，随机(洗牌)，是本文涉及的主要知识点。 先看一下做出来的效果，因为是实验程序，跟真实的斗地主还是有差距，理解万岁！ [发牌员]：洗牌咯。 刷刷刷... [发牌员]：牌洗好了。 [发牌员]：开始发牌。 [发牌员]：每个人17张牌。 [发牌员]：抢地主。 [fang]：哈哈，我是地主！ fang的牌是[♣9 ♦9 ♥A ♠9 ♣6 ♣5 ♦3 ♣10 ♥5 ...
一款GO语言开发的斗地主游戏
最新发布
04-11
为了满足广大玩家的需求，我们特别推出了一款由GO语言开发的斗地主游戏。 这款游戏采用GO语言进行开发，充分利用了GO语言的高性能和并发性优势，确保游戏运行的流畅和稳定。在开发过程中，我们注重用户体验和游戏...
一款GO语言开发的斗地主游戏.zip
12-24
go语言开发项目go语言开发项目go语言开发项目go语言开发项目go语言开发项目 go语言开发项目go语言开发项目go语言开发项目go语言开发项目go语言开发项目 go语言开发项目go语言开发项目go语言开发项目go语言开发项目go...
Go-GO实现斗地主服务器并提供一个简单的用户界面
08-14
在本项目中，开发者使用 Go 语言（Golang）实现了一个斗地主游戏服务器，并提供了一个简单的用户界面。Go 语言以其高效的并发处理、内存安全和简洁的语法特性，成为了构建网络服务的理想选择，尤其适合游戏服务器的...
Go语言开发的斗地主服务器与用户界面实现
本资源描述了一个使用Go语言开发的斗地主游戏服务器项目，以及提供了一个基本的用户界面，用于与服务器进行交互。 斗地主是一款流行的扑克游戏，在中国有着广泛的玩家基础。斗地主游戏规则相对简单，但其策略性和...
golang制作一个斗地主游戏服务器
不负韶华梦为马
06-09 1572
https://blog.csdn.net/warrially/article/details/88555720
基于Golang开发的棋牌游戏服务端demo(推筒子游戏）
04-07
主要服务 Hall:大厅服务 PushBobbi:推筒子游戏服务 Robot:机器人服务 环境搭建 架构使用go mod构建环境 基础安装 将工程代码克隆在GOPATH/src目录下 确保GOPATH和GOROOT的系统环境变量已经正确配置 配置go mod的环境变量 Mac或Linux export GOPROXY=https://goproxy.io export GO111MODULE=on Windows set GOPROXY=https://goproxy.io set GO111MODULE=on 在工程目录下执行go mod tidy 运行程序 安装Go1.16 设置GOROOT和GOPATH（1.6开始不需要设置GOPATH） 设置环境变量 根据layout.json创建layout_dev.json,其中common_config与must服务不变,其他XX_server服务里面内容都放在新的all_server服务里面 因为本地测试需要将所有服务都同时启动，rancher上面根据环境变量运行服务 例如： "all_server":{ "
golang制作一个斗地主游戏服务器[3]:斗地主给其他三家玩家发牌
warrially的专栏
03-14 1027
接下来需要做一个简单的给三家发牌的逻辑 package main // TDDZ ----------------------------------------------------- // 斗地主执行 type TDDZ struct { pHandCardList1 TCards //第1家的手牌 pHandCardList2 TCards //第2家的手牌 pHandC...
golang制作一个斗地主游戏服务器[12]:再写发牌
warrially的专栏
03-27 886
前面已经写过一个发牌的逻辑了 golang制作一个斗地主游戏服务器[3]:斗地主给其他三家玩家发牌 这时要在上面稍微添加一些逻辑.主要是 1. 把实际玩家关联进去 2. 给玩家发送手牌数据 // dealcard 发牌阶段 func (self *TDDZ) dealcard() { // 需要洗一副牌, 并且发送给三个玩家 pCardHeap := NewCards...
地主算法之判断牌型
热门推荐
棋牌游戏开发
05-17 1万+
地主算法之判断牌型                   by  wojiushi3344                       QQ:513670524                  每个游戏都有属于自己的规则，当然地主也不例外，常斗地主的朋友可能知道在斗地主里面一共有13种牌型，你所出的牌必须符合13种的一种才能够出得了牌，这个就叫地主的规则。那么我们下面可以通过一个枚举结构来表
golang制作一个斗地主游戏服务器[14]:再写打牌和跟牌(上)
warrially的专栏
04-03 1072
golang制作一个斗地主游戏服务器[6]:打牌和跟牌 前面叫地主和抢地主结束了, 本篇基本上就是属于打牌的范畴了. 首先把超时的时间延长起来. 不要再超时了. 一定等着我们操作完再继续 select { case <-ch: log.Println("模拟打牌") case <-time.After(time.Second * 10000): // 临时改成10...
golang制作一个斗地主游戏服务器[13]:再写叫地主抢地主
warrially的专栏
03-29 576
golang制作一个斗地主游戏服务器[4]:叫地主和抢地主 之前的叫地主和抢地主, 都是通过golang 的协程去模拟的 我们现在已经有正牌的客户端了. 首先要把超时时间从原先的5秒钟, 暂时延长到足够长的1000秒 然后去掉协程中的模拟. 改成通过服务器收到客户端消息来判断模拟 首先先在客户端 放两个按钮 一个叫 叫地主 一个叫不叫 self.Btn3 = vcl.New...
java 斗地主出牌算法_Golang算法实战之斗地主<一>
weixin_42437984的博客
03-07 1501
逢年过节，回到老家，玩的最多的就是打麻将、斗地主。今天要说的，就是这个经典游戏——斗地主。一、斗地主牌面分析斗地主需要多少张牌？大部分人都知道需要一副完整的牌即可，也就是54张牌。2-10 黑桃、红桃、梅花、方片各4张。J、Q、K、A 黑桃、红桃、梅花、方片各4张。大小王各1张。在斗地主中，牌的花色不影响。所以，在牌面比对时，不需要单独比对花色。而单张牌面值的大小顺序为: 大王>小王&gt...
golang制作一个斗地主游戏服务器[9]:pb基础
warrially的专栏
03-25 698
根据前面文章的协议 golang制作一个斗地主游戏服务器[7]:服务器和协议的一些想法 message TDDZ { message THeader { 头部应该包含很多内容, 目前先不填 } optional THeader Header = 1; optional int32 Command =...
golang制作一个斗地主游戏服务器[5]:牌型
warrially的专栏
03-18 904
下面就该进入打牌环节了 打牌之前, 首先应该定义牌的类型有哪些. 斗地主里面分成 单牌, 对子, 三不带, 三带一 拖拉机, 顺子, 飞机 王炸 其中, 拖拉机最多10对, 顺子至少5张 最多12张 飞机内容比较多 我们先把所有可能出现的牌型列举出来 // 牌型 const ( cardTypeNIL int = iota // 留空 // 单牌 cardTy...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值