Пример использования горутин и каналов для создания игры в Golang

Создайте сетку, на которой может передвигаться марсоход, для этого имплементируйте тип MarsGrid. Чтобы безопасно использовать несколько горутин за раз, вам понадобится задействовать мьютекс. Код должен делать нечто подобное:

// MarsGrid представляет сетку какой-то поверхности
// Марса. Может использовать конкурентно другой
// горутиной.
type MarsGrid struct {
 // Сделано.
}

// Occupy занимает ячейку в данной точке сетки. Он
// возвращает nil, если точка уже занята или точка 
// за пределами сетки. В противном случае возвращается значение, что 
// можно переместить в другое место сетки.
func (g *MarsGrid) Occupy(p image.Point) *Occupier

// Occupier представляет занятую клетку сетки
// Может использоваться конкурентно другой сеткой
type Occupier struct {
 // Готово
}

// Move перемещает occupier на другую клетку сетки
// Сообщает, было ли перемещение успешным
// Может не получиться, если пытается выйти за пределы
// сетки или потому что пытается перместиться в клетку, что
// уже занята. Если проваливается, occupier остается на прежнем месте
func (g *Occupier) Move(p image.Point) bool

// MarsGrid представляет сетку какой-то поверхности

// Марса. Может использовать конкурентно другой

// горутиной.

type MarsGrid struct {

// Сделано.

}

// Occupy занимает ячейку в данной точке сетки. Он

// возвращает nil, если точка уже занята или точка

// за пределами сетки. В противном случае возвращается значение, что

// можно переместить в другое место сетки.

func (g *MarsGrid) Occupy(p image.Point) *Occupier

// Occupier представляет занятую клетку сетки

// Может использоваться конкурентно другой сеткой

type Occupier struct {

// Готово

}

// Move перемещает occupier на другую клетку сетки

// Сообщает, было ли перемещение успешным

// Может не получиться, если пытается выйти за пределы

// сетки или потому что пытается перместиться в клетку, что

// уже занята. Если проваливается, occupier остается на прежнем месте

func (g *Occupier) Move(p image.Point) bool

Теперь измените пример с марсоходом из урока про конкурентность. Вместо только локального обновления координат, марсоход будет использовать объект MarsGrid, переданный в функцию NewRoverDriver. Если марсоход доходит до границ сетки или до какого-то препятствия, он должен двинуться в какое-то другое случайное направление.

Премиум 👑 канал по Golang

Рекомендуем вам супер TELEGRAM канал по Golang где собраны все материалы для качественного изучения языка. Удивите всех своими знаниями на собеседовании! 😎

Подписаться на канал

Уроки, статьи и Видео

Мы публикуем в паблике ВК и Telegram качественные обучающие материалы для быстрого изучения Go. Подпишитесь на нас в ВК и в Telegram. Поддержите сообщество Go программистов.

Go в ВК ЧАТ в Telegram

Теперь вы можете запустить несколько марсоходов через вызов NewRoverDriver и посмотреть, как они перемещаются по сетке.

Сообщение об открытиях

Нам нужно обнаружить жизнь на Марсе, поэтому отправим несколько марсоходов вниз для поиска, они должны будут сообщить нам, когда жизнь будет найдена. Каждой клетке сетки присваивается вероятность жизни, то есть случайное число между 0 и 1000. Если марсоход находит клетку со значением выше 900, возможно, это жизнь, и он должен отправить радио сообщение обратно на Землю.

К несчастью, не всегда можно отправить сообщение сразу, потому что спутники не всегда в нужном положении. Имплементируйте горутину буфера, что получает сообщение, отправленное из марсохода и сохраняет срез в буфер, пока не получится отправить что-то на Землю.

Имплементируйте Земплю (Earth) как горутину, что получает сообщения только периодически (в реальности несколько часов каждый день, но вы можете сделать интервал короче этого). Каждое сообщение должно содержать координаты клетки, где жизнь может быть найдена, а также само значение жизни.

Возможно, вы также захотите назвать каждый марсоход и включить название в сообщение, чтобы было видно, откуда пришло сообщение. Может быть полезно включить название в лог сообщений, выводимых марсоходом, чтобы вы могли отследить прогресс каждого марсохода.

Установите ваши марсоходы так, чтобы они могли свободно заниматься поиском. Посмотрите, что получится!

Решение - Код Golang для игры изучения Марса

package main

import (
    "fmt"
    "image"
    "log"
    "math/rand"
    "sync"
    "time"
)

func main() {
    marsToEarth := make(chan []Message)
    go earthReceiver(marsToEarth)

    gridSize := image.Point{X: 20, Y: 10}
    grid := NewMarsGrid(gridSize)
    rover := make([]*RoverDriver, 5)
    for i := range rover {
        rover[i] = startDriver(fmt.Sprint("Марсоход ", i), grid, marsToEarth)
    }
    time.Sleep(60 * time.Second)
}

// Message содержит сообщение, отправленное с Марса до Земли
type Message struct {
    Pos       image.Point
    LifeSigns int
    Rover     string

}
const (
    // Длина марсианского дня
    dayLength = 24 * time.Second
    // Продолжительность, во время которого
    // сообщения можно передать с марсохода до Земли
    receiveTimePerDay = 2 * time.Second
)

// earthReceiver получает сообщения, отправленные с Марса
// Так как связь ограничена, принимаются только сообщения 
// для некоторого часа марсианского дня
func earthReceiver(msgc chan []Message) {
    for {
        time.Sleep(dayLength - receiveTimePerDay)
        receiveMarsMessages(msgc)
    }
}

// receiveMarsMessages получает сообщения, отправленные с Марса
// для данной продолжительности
func receiveMarsMessages(msgc chan []Message) {
    finished := time.After(receiveTimePerDay)
    for {
        select {
        case <-finished:
            return
        case ms := <-msgc:
            for _, m := range ms {
                log.Printf("земля получает доклад об уровне жизни %d из %s в %v", m.LifeSigns, m.Rover, m.Pos)
            }
        }
    }
}

func startDriver(name string, grid *MarsGrid, marsToEarth chan []Message) *RoverDriver {
    var o *Occupier
    // Попытка получить случайную точку продолжается до тех пор, пока не будет найдена та,
    // что сейчас не занята
    for o == nil {
        startPoint := image.Point{X: rand.Intn(grid.Size().X), Y: rand.Intn(grid.Size().Y)}
        o = grid.Occupy(startPoint)
    }
    return NewRoverDriver(name, o, marsToEarth)
}

// Структура Radio представляет радио передатчик, что может отправить
// сообщение на Землю
type Radio struct {
    fromRover chan Message
}

// SendToEarth отправляет сообщение на Землю. 
// Успешность видна сразу - реальное сообщение
// можно скопировать в буфер и передать позже 
func (r *Radio) SendToEarth(m Message) {
    r.fromRover <- m
}

// NewRadio возвращает новый экземпляр Radio, что
// отправляет сообщения на канал toEarth
func NewRadio(toEarth chan []Message) *Radio {
    r := &Radio{
        fromRover: make(chan Message),
    }
    go r.run(toEarth)
    return r
}

// запуск сообщений буфера, отправляемых марсоходом до дня, пока
// они не смогут отправиться на Землю
func (r *Radio) run(toEarth chan []Message) {
    var buffered []Message
    for {
        toEarth1 := toEarth
        if len(buffered) == 0 {
            toEarth1 = nil
        }
        select {
        case m := <-r.fromRover:
            buffered = append(buffered, m)
        case toEarth1 <- buffered:
            buffered = nil
        }
    }
}

// RoverDriver ведет марсоход по поверхности Марса
type RoverDriver struct {
    commandc chan command
    occupier *Occupier
    name     string
    radio    *Radio
}

// NewRoverDriver начинает новый RoverDriver и возвращает его
func NewRoverDriver(
    name string,
    occupier *Occupier,
    marsToEarth chan []Message,
) *RoverDriver {
    r := &RoverDriver{
        commandc: make(chan command),
        occupier: occupier,
        name:     name,
        radio:    NewRadio(marsToEarth),
    }
    go r.drive()
    return r
}

type command int

const (
    right command = 0
    left  command = 1
)

// drive отвечает за ведение марсохода. Ожидается,
// что он начнется в горутине
func (r *RoverDriver) drive() {
    log.Printf("%s начальная позиция %v", r.name, r.occupier.Pos())
    direction := image.Point{X: 1, Y: 0}
    updateInterval := 250 * time.Millisecond
    nextMove := time.After(updateInterval)
    for {
        select {
        case c := <-r.commandc:
            switch c {
            case right:
                direction = image.Point{
                    X: -direction.Y,
                    Y: direction.X,
                }
            case left:
                direction = image.Point{
                    X: direction.Y,
                    Y: -direction.X,
                }
            }
            log.Printf("%s новое направление %v", r.name, direction)
        case <-nextMove:
            nextMove = time.After(updateInterval)
            newPos := r.occupier.Pos().Add(direction)
            if r.occupier.MoveTo(newPos) {
                log.Printf("%s перемещение на %v", r.name, newPos)
                r.checkForLife()
                break
            }
            log.Printf("%s заблокирован при попытке перемещения из %v в %v", r.name, r.occupier.Pos(), newPos)
            // Случайно выбирается одно из других случайных направлений
            // Далее мы попробуем передвинуться в новое направление
            dir := rand.Intn(3) + 1
            for i := 0; i < dir; i++ {
                direction = image.Point{
                    X: -direction.Y,
                    Y: direction.X,
                }
            }
            log.Printf("%s новое случайное направление %v", r.name, direction)
        }
    }
}

func (r *RoverDriver) checkForLife() {
    // Успешное перемещение на новую позицию
    sensorData := r.occupier.Sense()
    if sensorData.LifeSigns < 900 {
        return
    }
    r.radio.SendToEarth(Message{
        Pos:       r.occupier.Pos(),
        LifeSigns: sensorData.LifeSigns,
        Rover:     r.name,
    })
}

// Left поворачивает марсоход налево (90° против часовой стрелки).
func (r *RoverDriver) Left() {
    r.commandc <- left
}

// Right поворачивает марсоход направо (90° по часовой стрелке).
func (r *RoverDriver) Right() {
    r.commandc <- right
}

// MarsGrid представляет сетку некоторых поверхностей
// Марса. Это может использоваться конкурентно несколькими горутинами
type MarsGrid struct {
    bounds image.Rectangle
    mu     sync.Mutex
    cells  [][]cell
}

// SensorData содержит информацию о том, что находится в данной точке сетки
type SensorData struct {
    LifeSigns int
}

type cell struct {
    groundData SensorData
    occupier   *Occupier
}

// NewMarsGrid возвращает новый MarsGrid указанного размера
func NewMarsGrid(size image.Point) *MarsGrid {
    grid := &MarsGrid{
        bounds: image.Rectangle{
            Max: size,
        },
        cells: make([][]cell, size.Y),
    }
    for y := range grid.cells {
        grid.cells[y] = make([]cell, size.X)
        for x := range grid.cells[y] {
            cell := &grid.cells[y][x]
            cell.groundData.LifeSigns = rand.Intn(1000)
        }
    }
    return grid
}

// Size возвращает Point, что представляет размер сетки
func (g *MarsGrid) Size() image.Point {
    return g.bounds.Max
}

// Occupy занимает клетку в данной точке в сетке. 
// Возвращается nil, если точка уже занята, или если точка находится
// за пределами сетки. В противном случае значение можно использовать
// для перемещения в другое место сетки
func (g *MarsGrid) Occupy(p image.Point) *Occupier {
    g.mu.Lock()
    defer g.mu.Unlock()
    cell := g.cell(p)
    if cell == nil || cell.occupier != nil {
        return nil
    }
    cell.occupier = &Occupier{
        grid: g,
        pos:  p,
    }
    return cell.occupier
}

func (g *MarsGrid) cell(p image.Point) *cell {
    if !p.In(g.bounds) {
        return nil
    }
    return &g.cells[p.Y][p.X]
}

// Occupier представляет занятую клетку сетки 
type Occupier struct {
    grid *MarsGrid
    pos  image.Point
}

// MoveTo передвигает занятую клетку на другую клетку сетки
// Сообщается, было ли перемещение успешным
// Может закончится неудачей, если была попытка перемещения за пределы 
// сетки, или потому что пунктом назначения является занятая 
// клетка. В случае неудачи занятая клетка не перемещается и остается на прежнем месте. 
func (o *Occupier) MoveTo(p image.Point) bool {
    o.grid.mu.Lock()
    defer o.grid.mu.Unlock()
    newCell := o.grid.cell(p)
    if newCell == nil || newCell.occupier != nil {
        return false
    }
    o.grid.cell(o.pos).occupier = nil
    newCell.occupier = o
    o.pos = p
    return true
}

// Sense возвращает сенсорные данные из текущей клетки
func (o *Occupier) Sense() SensorData {
    o.grid.mu.Lock()
    defer o.grid.mu.Unlock()
    return o.grid.cell(o.pos).groundData
}

// Pos возвращает текущую позицию сетки занятой клетки
func (o *Occupier) Pos() image.Point {
    return o.pos
}

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

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

package main

import (

"fmt"

"image"

"log"

"math/rand"

"sync"

"time"

)

func main() {

marsToEarth := make(chan []Message)

go earthReceiver(marsToEarth)

gridSize := image.Point{X: 20, Y: 10}

grid := NewMarsGrid(gridSize)

rover := make([]*RoverDriver, 5)

for i := range rover {

rover[i] = startDriver(fmt.Sprint("Марсоход ", i), grid, marsToEarth)

}

time.Sleep(60 * time.Second)

}

// Message содержит сообщение, отправленное с Марса до Земли

type Message struct {

Pos image.Point

LifeSigns int

Rover string

}

const (

// Длина марсианского дня

dayLength = 24 * time.Second

// Продолжительность, во время которого

// сообщения можно передать с марсохода до Земли

receiveTimePerDay = 2 * time.Second

)

// earthReceiver получает сообщения, отправленные с Марса

// Так как связь ограничена, принимаются только сообщения

// для некоторого часа марсианского дня

func earthReceiver(msgc chan []Message) {

for {

time.Sleep(dayLength - receiveTimePerDay)

receiveMarsMessages(msgc)

}

// receiveMarsMessages получает сообщения, отправленные с Марса

// для данной продолжительности

func receiveMarsMessages(msgc chan []Message) {

finished := time.After(receiveTimePerDay)

for {

select {

case <-finished:

return

case ms := <-msgc:

for _, m := range ms {

log.Printf("земля получает доклад об уровне жизни %d из %s в %v", m.LifeSigns, m.Rover, m.Pos)

}

func startDriver(name string, grid *MarsGrid, marsToEarth chan []Message) *RoverDriver {

var o *Occupier

// Попытка получить случайную точку продолжается до тех пор, пока не будет найдена та,

// что сейчас не занята

for o == nil {

startPoint := image.Point{X: rand.Intn(grid.Size().X), Y: rand.Intn(grid.Size().Y)}

o = grid.Occupy(startPoint)

}

return NewRoverDriver(name, o, marsToEarth)

}

// Структура Radio представляет радио передатчик, что может отправить

// сообщение на Землю

type Radio struct {

fromRover chan Message

}

// SendToEarth отправляет сообщение на Землю.

// Успешность видна сразу - реальное сообщение

// можно скопировать в буфер и передать позже

func (r *Radio) SendToEarth(m Message) {

r.fromRover <- m

}

// NewRadio возвращает новый экземпляр Radio, что

// отправляет сообщения на канал toEarth

func NewRadio(toEarth chan []Message) *Radio {

r := &Radio{

fromRover: make(chan Message),

}

go r.run(toEarth)

return r

}

// запуск сообщений буфера, отправляемых марсоходом до дня, пока

// они не смогут отправиться на Землю

func (r *Radio) run(toEarth chan []Message) {

var buffered []Message

for {

toEarth1 := toEarth

if len(buffered) == 0 {

toEarth1 = nil

}

select {

case m := <-r.fromRover:

buffered = append(buffered, m)

case toEarth1 <- buffered:

buffered = nil

}

// RoverDriver ведет марсоход по поверхности Марса

type RoverDriver struct {

commandc chan command

occupier *Occupier

name string

radio *Radio

}

// NewRoverDriver начинает новый RoverDriver и возвращает его

func NewRoverDriver(

name string,

occupier *Occupier,

marsToEarth chan []Message,

) *RoverDriver {

r := &RoverDriver{

commandc: make(chan command),

occupier: occupier,

name: name,

radio: NewRadio(marsToEarth),

}

go r.drive()

return r

}

type command int

const (

right command = 0

left command = 1

)

// drive отвечает за ведение марсохода. Ожидается,

// что он начнется в горутине

func (r *RoverDriver) drive() {

log.Printf("%s начальная позиция %v", r.name, r.occupier.Pos())

direction := image.Point{X: 1, Y: 0}

updateInterval := 250 * time.Millisecond

nextMove := time.After(updateInterval)

for {

select {

case c := <-r.commandc:

switch c {

case right:

direction = image.Point{

X: -direction.Y,

Y: direction.X,

}

case left:

direction = image.Point{

X: direction.Y,

Y: -direction.X,

}

log.Printf("%s новое направление %v", r.name, direction)

case <-nextMove:

nextMove = time.After(updateInterval)

newPos := r.occupier.Pos().Add(direction)

if r.occupier.MoveTo(newPos) {

log.Printf("%s перемещение на %v", r.name, newPos)

r.checkForLife()

break

}

log.Printf("%s заблокирован при попытке перемещения из %v в %v", r.name, r.occupier.Pos(), newPos)

// Случайно выбирается одно из других случайных направлений

// Далее мы попробуем передвинуться в новое направление

dir := rand.Intn(3) + 1

for i := 0; i < dir; i++ {

direction = image.Point{

X: -direction.Y,

Y: direction.X,

}

log.Printf("%s новое случайное направление %v", r.name, direction)

}

func (r *RoverDriver) checkForLife() {

// Успешное перемещение на новую позицию

sensorData := r.occupier.Sense()

if sensorData.LifeSigns < 900 {

return

}

r.radio.SendToEarth(Message{

Pos: r.occupier.Pos(),

LifeSigns: sensorData.LifeSigns,

Rover: r.name,

})

}

// Left поворачивает марсоход налево (90° против часовой стрелки).

func (r *RoverDriver) Left() {

r.commandc <- left

}

// Right поворачивает марсоход направо (90° по часовой стрелке).

func (r *RoverDriver) Right() {

r.commandc <- right

}

// MarsGrid представляет сетку некоторых поверхностей

// Марса. Это может использоваться конкурентно несколькими горутинами

type MarsGrid struct {

bounds image.Rectangle

mu sync.Mutex

cells [][]cell

}

// SensorData содержит информацию о том, что находится в данной точке сетки

type SensorData struct {

LifeSigns int

}

type cell struct {

groundData SensorData

occupier *Occupier

}

// NewMarsGrid возвращает новый MarsGrid указанного размера

func NewMarsGrid(size image.Point) *MarsGrid {

grid := &MarsGrid{

bounds: image.Rectangle{

Max: size,

cells: make([][]cell, size.Y),

}

for y := range grid.cells {

grid.cells[y] = make([]cell, size.X)

for x := range grid.cells[y] {

cell := &grid.cells[y][x]

cell.groundData.LifeSigns = rand.Intn(1000)

}

return grid

}

// Size возвращает Point, что представляет размер сетки

func (g *MarsGrid) Size() image.Point {

return g.bounds.Max

}

// Occupy занимает клетку в данной точке в сетке.

// Возвращается nil, если точка уже занята, или если точка находится

// за пределами сетки. В противном случае значение можно использовать

// для перемещения в другое место сетки

func (g *MarsGrid) Occupy(p image.Point) *Occupier {

g.mu.Lock()

defer g.mu.Unlock()

cell := g.cell(p)

if cell == nil || cell.occupier != nil {

return nil

}

cell.occupier = &Occupier{

grid: g,

pos: p,

}

return cell.occupier

}

func (g *MarsGrid) cell(p image.Point) *cell {

if !p.In(g.bounds) {

return nil

}

return &g.cells[p.Y][p.X]

}

// Occupier представляет занятую клетку сетки

type Occupier struct {

grid *MarsGrid

pos image.Point

}

// MoveTo передвигает занятую клетку на другую клетку сетки

// Сообщается, было ли перемещение успешным

// Может закончится неудачей, если была попытка перемещения за пределы

// сетки, или потому что пунктом назначения является занятая

// клетка. В случае неудачи занятая клетка не перемещается и остается на прежнем месте.

func (o *Occupier) MoveTo(p image.Point) bool {

o.grid.mu.Lock()

defer o.grid.mu.Unlock()

newCell := o.grid.cell(p)

if newCell == nil || newCell.occupier != nil {

return false

}

o.grid.cell(o.pos).occupier = nil

newCell.occupier = o

o.pos = p

return true

}

// Sense возвращает сенсорные данные из текущей клетки

func (o *Occupier) Sense() SensorData {

o.grid.mu.Lock()

defer o.grid.mu.Unlock()

return o.grid.cell(o.pos).groundData

}

// Pos возвращает текущую позицию сетки занятой клетки

func (o *Occupier) Pos() image.Point {

return o.pos

}

Vasile Buldumac

Администрирую данный сайт с целью распространения как можно большего объема обучающего материала для языка программирования Go. В IT с 2008 года, с тех пор изучаю и применяю интересующие меня технологии. Проявляю огромный интерес к машинному обучению и анализу данных.

E-mail: vasile.buldumac@ati.utm.md

Образование

Технический Университет Молдовы (utm.md), Факультет Вычислительной Техники, Информатики и Микроэлектроники

2014 — 2018 Universitatea Tehnică a Moldovei, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
2018 — 2020 Universitatea Tehnică a Moldovei, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»