凹语言版贪吃蛇 #

#画布对象
type Canvas struct {
    device_id: u32   //画布对象对应的网页DOM对象id
    width:     u32   //画布宽度，以像素为单位
    height:    u32   //画布高度，以像素为单位
    frame_buf: []u32 //画布帧缓存，容量为Width * Height
}

#wa:import wa_js_env newCanvas
fn newCanvas_JS(w, h: u32) => u32

#创建一个宽度为w像素、高度为h像素的画布对象
fn NewCanvas(w, h: u32) => *Canvas {
    var canvas Canvas
	canvas.device_id = newCanvas_JS(w, h)
	canvas.width = w
	canvas.height = h
	canvas.frame_buf = make([]u32, w * h)

	return &canvas
}

#获取画布对象坐标为(x, y)处的像素颜色值
fn Canvas.GetPixel(x, y: u32) => u32 {
    return this.frame_buf[y * this.width + x]
}

#设置画布对象坐标(x, y)处的颜色值为color
fn Canvas.SetPixel(x, y, color: u32) {
    this.frame_buf[y * this.width + x] = color
}

#wa:import wa_js_env updateCanvas
fn updateCanvas_JS(id: u32, buf: *u32)

fn Canvas.Flush() {
    updateCanvas_JS(this.device_id, &this.frame_buf[0])
}

#画布事件回调函数原型
type OnTouch fn (x, y: u32)
type OnKey fn(key: u32)

#画布事件
type CanvasEvents struct {
	Device_id:   u32     //画布设备ID
    OnMouseDown: OnTouch //鼠标按下时的回调处理函数
    OnMouseUp:   OnTouch //鼠标松开时的回调处理函数
	OnKeyDown:   OnKey   //键盘按下时的回调处理函数
	OnKeyUp:     OnKey   //键盘弹起时的回调处理函数
}

var canvas_events: []CanvasEvents

fn AttachCanvasEvents(e: CanvasEvents) {
	for i := range canvas_events {
		if canvas_events[i].Device_id == e.Device_id {
			canvas_events[i] = e
			return
		}
	}

	canvas_events = append(canvas_events, e)
}

/*
供外部JS调用的鼠标按下事件响应函数
id为画布DOM对象对应的Canvas对象id
(x, y)为画布像素坐标系坐标
*/
fn OnMouseDown(id: u32, x, y:u32) {
    for _, i := range canvas_events {
		if i.Device_id == id {
			i.OnMouseDown(x, y)
			return
		}
	}
}

type GameState struct {
	w, h  :i32
	scale :i32
	grid  :[]i8
	body  :[]Position
	dir   :i32

	ca :*canvas.Canvas
}

var gameState: GameState

fn GameState.Init(w, h: i32, scale: i32) {
	this.w = w
	this.h = h
	this.scale = scale
	this.grid = make([]i8, u32(w*h))
	this.ca = canvas.NewCanvas(u32(w*scale), u32(h*scale))

	var caev: canvas.CanvasEvents
	caev.Device_id = this.ca.GetDeviceID()
	caev.OnMouseDown = fn(x, y: u32) {}
	caev.OnMouseUp = fn(x, y: u32) {}
	caev.OnKeyUp = fn(key: u32) {}
	caev.OnKeyDown = this.OnKeyDown

	Dirs[DirNull] = Position{x: 0, y: 0}
	Dirs[DirLeft] = Position{x: -1, y: 0}
	Dirs[DirUp] = Position{x: 0, y: -1}
	Dirs[DirRight] = Position{x: 1, y: 0}
	Dirs[DirDown] = Position{x: 0, y: 1}

	canvas.AttachCanvasEvents(caev)
}

fn GameState.Step() {
	if this.dir == DirNull {
		return
	}

	newHead := this.body[len(this.body)-1]
	newHead.x += Dirs[this.dir].x
	newHead.y += Dirs[this.dir].y

	if newHead.x < 0 {
		newHead.x = this.w - 1
	} else if newHead.x >= this.w {
		newHead.x = 0
	}
	if newHead.y < 0 {
		newHead.y = this.h - 1
	} else if newHead.y >= this.h {
		newHead.y = 0
	}

	switch this.grid[newHead.y*this.w+newHead.x] {
	case GridBody:
		this.Start()
		return

	case GridFood:
		this.SetGridType(newHead, GridBody)
		this.body = append(this.body, newHead)
		this.GenFood()

	default:
		this.SetGridType(newHead, GridBody)
		this.SetGridType(this.body[0], GridNull)
		this.body = append(this.body, newHead)
		this.body = this.body[1:]
	}

	this.ca.Flush()
}

fn Step() {
	gameState.Step()
}

fn main() {
	gameState.Init(32, 32, 10)
	gameState.Start()
}