466 lines
14 KiB
Markdown
466 lines
14 KiB
Markdown
# 基于 Go 语言的 21 点游戏 RPC 交互系统
|
||
|
||
南京大学 计算机科学与技术学院 马一鸣 502024330038
|
||
|
||
## 项目概述
|
||
|
||
本项目旨在使用 Go 语言设计并实现一款基于远程过程调用（RPC）机制进行通信的 Blackjack（即 21 点）游戏系统。系统由用户端和服务器端组成，用户可以通过用户端与服务器端的 AI 发牌员进行对战。整个系统的设计目标是提供流畅且公平的游戏体验，并通过可靠的通信机制保证用户与服务器之间的有效互动。
|
||
|
||
## 需求分析
|
||
|
||
本项目的需求分析如下：
|
||
|
||
1. **通信机制：** 使用 RPC 作为用户和服务器之间的数据交互机制，以实现低延迟和高可靠性的远程通信。
|
||
2. **游戏规则：** 游戏采用 Blackjack 的基本规则，玩家与发牌员对战，以接近 21 点为目标。为了提高游戏性和互动性。
|
||
3. **策略设计：** 发牌员的策略可灵活设计，但必须遵循公平原则，保证游戏的可玩性。策略的制定应考虑不同场景下的最优选择，以增强游戏的挑战性。
|
||
4. **用户体验：** 系统应具备良好的用户交互设计，保证玩家在操作过程中的易用性和流畅性。
|
||
|
||
## 概要设计
|
||
|
||
本项目基于 Go 语言实现 Blackjack 游戏系统，主要分为用户端和服务器端两部分。
|
||
|
||
- **用户端：** 用户端提供玩家操作界面，通过 RPC 机制向服务器端发送请求，进行拿牌、停牌等操作，并接收游戏结果。
|
||
- **服务器端：** 服务器端负责处理所有的游戏逻辑，包括初始化牌组、为玩家和发牌员发牌、计算点数、判断胜负等。服务器端通过 RPC 服务对外提供功能。
|
||
- **通信机制：** 使用 Go 的 `net/rpc` 库实现用户端与服务器端的通信，保证数据传输的安全性与实时性。
|
||
|
||
## 详细设计
|
||
|
||
本项目的代码结构如下：
|
||
|
||
``` shell
|
||
❯ tree .
|
||
.
|
||
├── client
|
||
│ └── client.go
|
||
├── controller
|
||
│ ├── response.go
|
||
│ └── simulator.go
|
||
├── core
|
||
│ └── game.go
|
||
├── doc.md
|
||
├── go.mod
|
||
├── main.go
|
||
├── model
|
||
│ ├── card.go
|
||
│ └── deck.go
|
||
├── rpc
|
||
│ ├── request.go
|
||
│ └── response.go
|
||
├── server
|
||
│ └── server.go
|
||
├── util
|
||
│ ├── dict.go
|
||
│ └── status.go
|
||
└── view
|
||
└── viewer.go
|
||
|
||
9 directories, 15 files
|
||
```
|
||
|
||
其中 21 点游戏的模拟部分遵循 `MVC` 设计模式。
|
||
|
||
* `model` 包负责对 21 点游戏中出现的各类对象（如卡牌 Card，卡组 Deck）等进行抽象。
|
||
* `view` 包负责将游戏的交互逻辑进行呈现。
|
||
* `controller` 包负责对于游戏的控制逻辑进行抽象，如发牌，要牌，判定胜负等交互逻辑。
|
||
* `game` 包负责将游戏整体进行封装，并实现了基于命令模式等指令解析模块。
|
||
|
||
对于 RPC 通信实现了如下包：
|
||
|
||
* `rpc` 包封装了 RPC 通信所需要的结构体。
|
||
* `server` 包实现了 RPC 通信的服务端构建。
|
||
* `client` 包实现了 RPC 通信的客户端构建。
|
||
|
||
此外 `util` 包实现了各类轻量化工具代码。
|
||
|
||
### 21 点游戏的模拟设计
|
||
|
||
#### 牌组设计
|
||
|
||
系统中的牌组包含 52 张牌，由四种花色（红桃、方块、梅花和黑桃）组成，每种花色有 13 张牌（2 到 10、J、Q、K、A）。每张牌的点数如下：
|
||
|
||
- **数字牌 (2-10)：** 牌的点数等于其面值。
|
||
- **人头牌 (J、Q、K)：** 每张牌的点数为 10。
|
||
- **A 牌：** 可以视为 1 分或 11 分，具体取决于对玩家更有利的值。
|
||
|
||
在 `model/card.go` 中实现了对于 `Card` 结构体的封装：
|
||
|
||
```go
|
||
type Card struct {
|
||
Color string
|
||
Value []int
|
||
Name string
|
||
Visible bool
|
||
}
|
||
```
|
||
|
||
在 `model/deck.go` 中实现了对于 `Deck` 结构体的封装：
|
||
|
||
```go
|
||
type Deck struct {
|
||
cards []*Card
|
||
}
|
||
```
|
||
|
||
一副卡组（Deck）由若干卡牌（Card）组成。与此同时，在 `Deck` 中封装了若干 API，最为重要的是抽牌 `Deck.Draw()` 与洗牌 `Deck.Shuffle()` API：
|
||
|
||
```go
|
||
func (deck *Deck) Shuffle() *Deck {
|
||
for i := range deck.cards {
|
||
j := i + rand.Intn(len(deck.cards) - i)
|
||
deck.cards[i], deck.cards[j] = deck.cards[j], deck.cards[i]
|
||
}
|
||
return deck
|
||
}
|
||
|
||
func (deck *Deck) Draw() *Card {
|
||
if len(deck.cards) == 0 {
|
||
return nil
|
||
}
|
||
card := deck.cards[0]
|
||
deck.cards = deck.cards[1:]
|
||
return card
|
||
}
|
||
```
|
||
|
||
#### 游戏流程设计
|
||
|
||
在 `controller/simulator.go` 中封装了游戏的交互逻辑：
|
||
|
||
```go
|
||
type BackJackSimulator struct {
|
||
deck *model.Deck
|
||
dealerCards *model.Deck
|
||
playerCards *model.Deck
|
||
dealerScore int
|
||
playerScore int
|
||
status util.Status
|
||
}
|
||
```
|
||
|
||
通过维护 `deck`，`dealerCards` 与 `playerCards` 三副卡组用来模拟 21 点的游戏流程。
|
||
|
||
设计实现游戏状态的初始化逻辑：
|
||
|
||
```go
|
||
func (simulator *BackJackSimulator) Init() *BackJackSimulator {
|
||
simulator.deck = model.NewDeck()
|
||
simulator.dealerCards = model.NewDeck()
|
||
simulator.playerCards = model.NewDeck()
|
||
|
||
simulator.deck = initDeck(simulator.deck)
|
||
simulator.dealerCards = initDealerCards(simulator.dealerCards, simulator.deck)
|
||
simulator.playerCards = initPlayerCards(simulator.playerCards, simulator.deck)
|
||
|
||
simulator.dealerScore, simulator.playerScore = 0, 0
|
||
simulator.status = util.INITIALIZED
|
||
|
||
return simulator
|
||
}
|
||
```
|
||
|
||
值得注意的是，在 `BackJackSimulator` 中基于状态机模型对游戏的状态进行管理。
|
||
|
||
在游戏中共包含了四个不同的状态，分别是初始化（INITIALIZED），闲家胜利（WINNED），庄家胜利（FAILED）以及平局（DRAW），相关状态封装在 `util/status.go` 中：
|
||
|
||
```go
|
||
type Status int
|
||
|
||
const (
|
||
INITIALIZED Status = iota
|
||
WINNED Status = iota
|
||
FAILED Status = iota
|
||
DRAW Status = iota
|
||
)
|
||
```
|
||
|
||
游戏的流程如下：
|
||
|
||
- **发牌阶段：** 游戏开始时，玩家和发牌员各自得到两张牌。玩家的两张牌均为明牌，发牌员有一张明牌和一张暗牌（底牌），例如发牌员的发牌逻辑如下：
|
||
|
||
```go
|
||
if firstCard := deck.Draw(); deck != nil {
|
||
dealerCards.Add(firstCard.Flip())
|
||
}
|
||
if secondCard := deck.Draw(); deck != nil {
|
||
dealerCards.Add(secondCard)
|
||
}
|
||
```
|
||
|
||
- **要牌阶段：** 玩家可以选择“要牌”（Hit，即再抽一张牌）或“停牌”（Stand，保持当前手牌）。玩家可以多次选择“要牌”，直到总点数超过 21 点（称为“爆牌”）或选择“停牌”。
|
||
|
||
对于要牌逻辑与爆牌判定逻辑实现如下：
|
||
|
||
```go
|
||
if card := simulator.deck.Draw(); card != nil {
|
||
simulator.playerCards.Add(card)
|
||
simulator.playerScore = 0
|
||
|
||
for _, card := range simulator.playerCards.Cards() {
|
||
simulator.playerScore += card.Value[0]
|
||
}
|
||
|
||
if simulator.playerScore > 21 {
|
||
simulator.status = util.FAILED
|
||
return NewBlackJackResponse(400, "[🐧] Your total score exceeds 21 ! You lose !\n")
|
||
}
|
||
}
|
||
```
|
||
|
||
值得注意的是在 `simulator` 中封装了 `BlackJackResponse` 结构体以返回游戏的状态反馈信息：
|
||
|
||
```go
|
||
type BackJackResponse struct {
|
||
Code int
|
||
Description string
|
||
}
|
||
```
|
||
|
||
当玩家停止要牌之后即进入停牌阶段。
|
||
|
||
- **停牌阶段：** 发牌员揭开底牌后，必须继续“要牌”，直到手牌点数达到或超过 17 点：
|
||
|
||
```go
|
||
for maxDealerScore < 17 {
|
||
if card := simulator.deck.Draw(); card != nil {
|
||
simulator.dealerCards.Add(card)
|
||
if card.Name == "A" {
|
||
maxDealerScore += card.Value[1]
|
||
minDealerScore += card.Value[0]
|
||
} else {
|
||
maxDealerScore += card.Value[0]
|
||
minDealerScore += card.Value[0]
|
||
}
|
||
}
|
||
|
||
if minDealerScore > 21 {
|
||
simulator.status = util.WINNED
|
||
return NewBlackJackResponse(200, "[🐧] The dealer burst and you have won the game !\n")
|
||
}
|
||
}
|
||
```
|
||
|
||
- **胜负判定：** 游戏结束后，根据玩家和发牌员的点数判断胜负。若玩家爆牌则输掉游戏；若发牌员爆牌，则玩家获胜；若双方均未爆牌，则点数接近 21 的一方获胜：
|
||
|
||
```go
|
||
if maxDealerScore > maxPlayerScore {
|
||
simulator.status = util.FAILED
|
||
return NewBlackJackResponse(200, "[🐧] The dealer wins the game !\n")
|
||
} else if maxDealerScore < maxPlayerScore {
|
||
simulator.status = util.WINNED
|
||
return NewBlackJackResponse(200, "[🐧] You have won the game !\n")
|
||
} else if maxDealerScore == maxPlayerScore {
|
||
simulator.status = util.DRAW
|
||
return NewBlackJackResponse(200, "[🐧] It is a draw !\n")
|
||
}
|
||
```
|
||
|
||
#### 游戏界面设计
|
||
|
||
基于命令行对于游戏的界面进行设计。
|
||
|
||
在 `view/viewer.go` 中实现界面结构体：
|
||
|
||
```go
|
||
type LiteralViewer struct {
|
||
response string
|
||
simulator *controller.BackJackSimulator
|
||
}
|
||
```
|
||
|
||
该结构体通过 `GetResponse` 结构输出游戏的状态信息。
|
||
|
||
将上述基于 MVC 架构的代码封装在 `BackJackGame` 结构体中：
|
||
|
||
```go
|
||
type BackJackGame struct {
|
||
simulator *controller.BackJackSimulator
|
||
viewer *view.LiteralViewer
|
||
}
|
||
```
|
||
|
||
该结构通过命令模式对游戏逻辑进行控制：
|
||
|
||
```go
|
||
func (game *BackJackGame) AddCommand(command string) string {
|
||
command = strings.Split(command, " ")[0]
|
||
response := ""
|
||
|
||
switch command {
|
||
case "start": {}
|
||
case "hit": {}
|
||
case "stand": {}
|
||
case "help": {}
|
||
default: {}
|
||
}
|
||
|
||
return response
|
||
}
|
||
```
|
||
|
||
### RPC 通信的客户端与服务器端设计
|
||
|
||
#### 服务端设计
|
||
|
||
服务器端的核心任务是处理游戏逻辑，并通过 RPC 服务向用户端提供接口。
|
||
|
||
服务端的核心代码如下：
|
||
|
||
```go
|
||
commandService := new(CommandService)
|
||
rpc.Register(commandService)
|
||
|
||
listener, err := net.Listen("tcp", ":1234")
|
||
if err != nil {
|
||
fmt.Println("[🐧] Listening Failed:", err)
|
||
return
|
||
}
|
||
defer listener.Close()
|
||
fmt.Println("...")
|
||
|
||
for {
|
||
conn, err := listener.Accept()
|
||
if err != nil {
|
||
fmt.Println("[🐧] Connecting Failed:", err)
|
||
continue
|
||
}
|
||
go rpc.ServeConn(conn)
|
||
}
|
||
```
|
||
|
||
上述代码实现了一个简单的 RPC 服务器，使用了 `Go` 语言中的 `net` 和 `rpc` 包。
|
||
|
||
在 `main` 函数中创建一个 `CommandService` 实例并将 `commandService` 实例注册到 RPC 服务器，使其公开方法可以被远程调用。
|
||
|
||
服务器开始监听 TCP 连接，端口号为 1234。`net.Listen()` 函数返回一个 listener（监听器）对象和一个错误（err）。
|
||
|
||
使用 `defer` 关键字确保在函数退出时关闭监听器，释放资源。
|
||
|
||
服务器等待客户端连接。当有客户端连接时，`listener.Accept()` 会返回一个表示该连接的 `conn` 对象。
|
||
|
||
通过 `go` 关键字保证每个连接都通过一个新的 `goroutine` 来处理，`rpc.ServeConn()` 用于处理该连接上的 RPC 请求。
|
||
|
||
对于 `CommandService` 结构体封装了调用方法如下：
|
||
|
||
```go
|
||
func (cs *CommandService) ExecuteCommand(req brpc.Request, res *brpc.Response) error {
|
||
command := req.Command
|
||
response := backJackGame.AddCommand(command)
|
||
res.Result = fmt.Sprint(response)
|
||
return nil
|
||
}
|
||
```
|
||
|
||
#### 客户端设计
|
||
|
||
客户端负责与玩家交互，并通过 RPC 向服务器发送请求。
|
||
|
||
客户端的核心代码如下：
|
||
|
||
```go
|
||
client, err := rpc.Dial("tcp", "localhost:1234")
|
||
if err != nil {
|
||
fmt.Println("[🐳] Connecting Failed:", err)
|
||
return
|
||
}
|
||
defer client.Close()
|
||
|
||
reader := bufio.NewReader(os.Stdin)
|
||
for {
|
||
command, _ := reader.ReadString('\n')
|
||
command = command[:len(command)-1]
|
||
|
||
if command == "exit" {
|
||
break
|
||
}
|
||
|
||
req := brpc.Request{Command: command}
|
||
var res brpc.Response
|
||
|
||
err = client.Call("CommandService.ExecuteCommand", req, &res)
|
||
if err != nil {
|
||
fmt.Println("[🐳] RPC Failed:", err)
|
||
continue
|
||
}
|
||
}
|
||
```
|
||
|
||
上述代码使用 `rpc.Dial()` 函数创建一个 RPC 客户端，并通过 TCP 连接到 localhost 上的端口 1234。
|
||
|
||
使用 `defer` 关键字确保在函数结束时关闭 RPC 客户端，释放资源。
|
||
|
||
创建一个从标准输入读取用户输入的 `bufio.Reader`，用于从命令行接收用户输入。
|
||
|
||
通过 `client.Call()` 调用服务器端的 `CommandService.ExecuteCommand` 方法。
|
||
|
||
## 测试与验证
|
||
|
||
欲运行服务端和客户端程序需要分别编译运行客户端与服务端代码：
|
||
|
||
```shell
|
||
$ go run server.go
|
||
```
|
||
|
||
```shell
|
||
$ go run client.go
|
||
```
|
||
|
||
其中客户端的交互页面如下：
|
||
|
||
```shell
|
||
go run client.go
|
||
[🐳] Input your Command (Input <exit> to quit):
|
||
start
|
||
```
|
||
|
||
在输入 `start` 命令后即可开启一局 21 点游戏：
|
||
|
||
```shell
|
||
[🐳] Input your Command (Input <exit> to quit):
|
||
start
|
||
[🃏] Dealer: 🂠 ♥️10
|
||
[🎴] Player: ♦3 ♦7
|
||
[🐧] You have started a new Blackjack game.
|
||
```
|
||
|
||
输入 `hit` 命令进行要牌操作：
|
||
|
||
```shell
|
||
[🐳] Input your Command (Input <exit> to quit):
|
||
hit
|
||
[🃏] Dealer: 🂠 ♥️10
|
||
[🎴] Player: ♦3 ♦7 ♠A
|
||
[🐧] You have drawn a card !
|
||
```
|
||
|
||
输入 `stand` 命令进行停牌操作：
|
||
|
||
```shell
|
||
[🐳] Input your Command (Input <exit> to quit):
|
||
stand
|
||
[🃏] Dealer: ♠K ♥️10
|
||
[🎴] Player: ♦3 ♦7 ♠A
|
||
[🐧] You decide to stand !
|
||
[🐧] You have won the game !
|
||
```
|
||
|
||
此时服务端也会输出对应的信息：
|
||
|
||
```shell
|
||
...
|
||
[🐧] Command Received: start
|
||
[🐧] Command Received: hit
|
||
[🐧] Command Received: stand
|
||
```
|
||
|
||
通过多轮测试与验证，本系统满足了 21 点游戏的交互逻辑的正确性。
|
||
|
||
# 结论
|
||
|
||
本项目通过使用 Go 语言和 RPC 通信机制，本项目实现了一款完整且可扩展的 21 点游戏系统。系统通过用户端与服务器端的分离，实现了逻辑处理和用户交互的独立性，从而提高了系统的扩展性和可维护性。项目通过详细的需求分析、概要设计和详细设计，确保了系统的功能完整性和用户体验。同时，通过系统测试，验证了系统的可靠性和稳定性。
|
||
|
||
未来可以考虑在以下方面进行改进：
|
||
- 增加复杂的游戏规则，例如双倍下注、投降等，以提高游戏的策略性和娱乐性。
|
||
- 优化发牌员的策略，使其更具挑战性。
|
||
- 增加图形化用户界面，以提供更直观的游戏体验。
|
||
- 使用更加安全和高效的通信机制，以提高数据传输的安全性和系统性能。
|