go语言贪食蛇和c语言区别

发表于 | 分类于

CSDN博客链接

GO贪食蛇小Demo

利用go语言写贪食蛇游戏那么就会利用面向对象的思想来写一下，创造蛇身体对象，然后写出来，go语言写的时候我们需要调用一个c语言写的一个包，go语言可以直接调用调用c语言的函数，很方便简洁，我们先来看一下我自己写的C语言的一个包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package Clib

/*
#include <windows.h>
#include <conio.h>

// 使用了WinAPI来移动控制台的光标
void gotoxy(int x,int y)
{
    COORD c;
    c.X=x,c.Y=y;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),c);
}

// 从键盘获取一次按键，但不显示到控制台
int direct()
{
    return _getch();
}
//去掉控制台光标
void hideCursor()
{
    CONSOLE_CURSOR_INFO  cci;
    cci.bVisible = FALSE;
    cci.dwSize = sizeof(cci);
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
}
*/
import "C" // go中可以嵌入C语言的函数

//设置控制台光标位置
func GotoPostion(X int, Y int) {
    //调用C语言函数
    C.gotoxy(C.int(X), C.int(Y))
}
//无显获取键盘输入的字符
func Direction() (key int) {
    key = int(C.direct())
    return
}
//设置控制台光标隐藏
func HideCursor() {
    C.hideCursor()
}

这个包把一些需要用到c语言的函数写进来，调用c语言的函数需要用到c语言的环境，别忘记自己电脑上要装c语言的环境奥，我们来看一下这个目录结构

首先我们的代码是放在GoCode里面下面的src目录下面，Clib里面是自己写的C语言的一个包，贪食蛇和Clib是同级别目录，在这里我们用的是goland编译器，编译器这里可以自己选择，我们编译的时候就不能单个文件编译了，因为需要调用自己的包，所以要选择多文件编译如图

我自己用的goland编译的时候需要改一下改成Directory 然后目录选到所在目录的src目录，然后设置好后就可以直接编译运行啦，当然也可以直接命令行编译运行

如图，我们可以在所在目录下面直接go build ./这样就是生成可执行文件.exe的，也可以直接使用go run命令直接编译运行， 感兴趣的小伙伴可以自己去试试啦 下面来看一下go语言写的代码，（可以自己去完善一下奥，比如加入等级，加入障碍物，蛇的速度都是自己可以调节的奥）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
package main

import (
    "Clib"
    "fmt"
    "os"
    "math/rand"
    "time"
)

const wide int = 20
const high int = 20

var key int64 = 1 //关卡
var food1 food    //定义一个全局食物结构体
//var size int = 2  //定义一个全局蛇的长度
var score int = 0 //定义一个全局分数
var dx int = 0
var dy int = 0 //蛇的偏移量
var barr1 barrier //障碍物结构体
var c cake //定义一个蛋糕
var FLAG bool=true
type postion struct {
    x int
    y int //父类坐标
}
type cake struct{
      ca [5]postion
}                    //定义一个蛋糕
type snake struct {
    p    [wide * high]postion
    size int
    dir  byte
}
type barrier struct {
    barr [6]postion
} //障碍物结构体
func (c *cake)setcake(){
    x:=rand.Intn(wide-6)+3
    y:=rand.Intn(high-6)+3
    c.ca[0].x,c.ca[0].y=x,y
        c.ca[1].x,c.ca[1].y=x-1,y
    c.ca[2].x,c.ca[2].y= x-2,y
        c.ca[3].x,c.ca[3].y=x-1,y-1
    c.ca[4].x,c.ca[4].y=x-1,y+1
}
func (b *barrier)setbarrier(){   //定义一些随机障碍物
    b.barr[0].x,b.barr[0].y=rand.Intn(wide-1)+1,rand.Intn(high-3)+1
    b.barr[1].x,b.barr[1].y=rand.Intn(wide-1)+1,rand.Intn(high-3)+1
    b.barr[2].x,b.barr[2].y=rand.Intn(wide-1)+1,rand.Intn(high-3)+1
    //b.barr[3].x,b.barr[3].y=rand.Intn(wide-1)+1,rand.Intn(high-3)+1
    //b.barr[4].x,b.barr[4].y=rand.Intn(wide-1)+1,rand.Intn(high-3)+1
    //b.barr[5].x,b.barr[5].y=rand.Intn(wide-1)+1,rand.Intn(high-3)+1
}
type food struct {
    postion
} //食物
func drawui(p postion, ch byte) {
    Clib.GotoPostion(p.x*2+4, p.y+2+2)
    fmt.Fprintf(os.Stderr, "%c", ch)
}
func (s *snake) initsnake() { //蛇初始化
    s.p[0].x = wide / 2
    s.p[0].y = high / 2
    s.p[1].x = wide/2 - 1
    s.p[1].y = high / 2 //蛇头和第一个蛇结点初始化
    s.dir = 'R'
    s.size=2
    fmt.Fprintln(os.Stderr,
        `
  #-----------------------------------------#
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  |                                         |
  #-----------------------------------------#
`)
    food1 = food{postion{rand.Intn(wide), rand.Intn(high) - 2}} //食物初始化
    drawui(food1.postion, 'o')                                  //画出食物

    //go func(){
     Clib.GotoPostion(46,19)
     fmt.Printf("正在进行第%d关，小心障碍物",key)
    //}()
    go func(){
        for{
            time.Sleep(time.Second)
            num:=rand.Intn(10)
            if num==6{
                c.setcake()
                break
            }
        }
        for i:=0;i<len(c.ca);i++{
            drawui(c.ca[i],'#')
        }
    }()                  //吃蛋糕的作用
    go func(){
        for i:=0;i<len(barr1.barr);i++{
            Clib.GotoPostion(barr1.barr[i].x,barr1.barr[i].y)
            drawui(barr1.barr[i],'!')
        }
    }()             //打印出障碍物
    go func() {
        for {
            switch Clib.Direction() {
            case 72, 87, 119:
                if s.dir == 'D' {
                    break
                }
                s.dir = 'U'
            case 65, 97, 75:
                if s.dir == 'R' {
                    break
                }
                s.dir = 'L'
            case 100, 68, 77:
                if s.dir == 'L' {
                    break
                }
                s.dir = 'R'
            case 83, 115, 80:
                if s.dir == 'U' {
                    break
                }
                s.dir = 'D'
            case 32:
                s.dir = 'P'
            }
        }
    }()   //获取蛇跑的方向
}

func (s *snake) playgame() {
    //barr:=barrier{postion{rand.Intn(wide-5)+5,rand.Intn(high-5)+3}
        //drawui(barr.postion,'p')
    for {
        switch key {
        case 1: time.Sleep(time.Second / 3)
        case 2:time.Sleep(time.Second / 5)
        case 3:time.Sleep(time.Second / 6)
        case 4:time.Sleep(time.Second / 7)
        case 5:time.Sleep(time.Second / 8)
        case 6:time.Sleep(time.Second / 9)    //用来每增加一关蛇的速度加快
        }


        if s.dir == 'P' {
            continue
        }
        if s.p[0].x < 0 || s.p[0].x >= wide || s.p[0].y+2 < 0 || s.p[0].y >= high-2 {
            Clib.GotoPostion(wide*3, high-3)
            FLAG=false
            return //如果蛇头碰墙就死亡
        }
        //if s.p[0].x==barr.postion.x&&s.p[0].y==barr.postion.y{
        //  Clib.GotoPostion(wide*3, high-3)
        //  return //如果蛇头碰障碍物就死亡
        //}

        for i := 1; i <s.size; i++ {
            if s.p[0].x == s.p[i].x && s.p[0].y == s.p[i].y {
                Clib.GotoPostion(wide*3, high-3)
                FLAG=false
                return
            }
        }
        for j:=0;j<len(barr1.barr);j++{
            if s.p[0].x==barr1.barr[j].x&&s.p[0].y==barr1.barr[j].y{
                Clib.GotoPostion(wide*3, high-3)
                FLAG=false
                return
            }                //碰到障碍物死亡
        }
        for m:=0;m<len(c.ca);m++{
            if s.p[0].x==c.ca[m].x&&s.p[0].y==c.ca[m].y{
                s.size++
                score++
            }
            if score >= int(6+key*2) {
                key++
                return
            }
        }
        if s.p[0].x == food1.x && s.p[0].y == food1.y {
            s.size++
            score++
            if score >= int(6+key*2) {
                key++
                return
            }
            //画蛇
            //food1 = food{postion{rand.Intn(wide), rand.Intn(high) - 2}}
            for {
                flag := true
                temp := food{postion{rand.Intn(wide), rand.Intn(high) - 2}}
                for i := 1; i < s.size; i++ {
                    if (temp.postion.x == s.p[i].x && temp.postion.y == s.p[i].y)  {
                        flag = false
                        break
                    }
                }
                for i:=0;i<len(barr1.barr);i++{
                    if temp.postion.x==barr1.barr[i].x&&temp.postion.y==barr1.barr[i].y{
                        flag=false
                        break
                    }
                }
                if flag == true {
                    food1 = temp
                    break
                }

            }
            drawui(food1.postion, 'o')
        }

        switch s.dir {
        case 'U':
            dx = 0
            dy = -1
        case 'D':
            dx = 0
            dy = 1
        case 'L':
            dx = -1
            dy = 0
        case 'R':
            dx = 1
            dy = 0
        }
        lp := s.p[s.size-1] //蛇尾位置
        for i := s.size - 1; i > 0; i-- {
            s.p[i] = s.p[i-1]
            drawui(s.p[i], '*')
        }
        drawui(lp, ' ') //蛇尾画空格

        s.p[0].x += dx
        s.p[0].y += dy      //更新蛇头
        drawui(s.p[0], 'O') //画蛇头
    }

}
func main() {
    rand.Seed(time.Now().UnixNano())
    var s snake

    for k:=1;k<=6;k++{    //用来循环6次代表6个关卡，这里可以自己设置多少关卡
        s.initsnake()        //初始化
        barr1.setbarrier()  //障碍物
        s.playgame()       //玩游戏开始
        if FLAG==false{        //这个代表蛇死亡返回的，所以这样就退出了
            Clib.GotoPostion(46,21)
            fmt.Printf("你已死亡，第%d关总分：%d分",k, score)
            break
        }
        Clib.GotoPostion(46,21)
        fmt.Printf("第%d关总分：%d分,稍等进入下一关",k, score)
        //key++
        time.Sleep(time.Second * 5)  //延时5秒
        Clib.Cls()                  //每一关清屏一下
        //size=2
        score=0                   //每一关分数置为0
    }

    time.Sleep(time.Second * 5)   //延时5秒
}
-------------本文结束感谢您的阅读-------------

本文标题:go语言贪食蛇和c语言区别

文章作者:Wuman

发布时间:2018年09月05日 - 12:09

最后更新:2018年09月05日 - 13:09

原始链接:http://yoursite.com/2018/09/05/go语言贪食蛇和c语言区别/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。