在这个章节中,我们要替康威生命游戏加入播放、暂停和逐格播放这几个时间控制的功能,并且让培养皿中的格子会因玩家鼠标光标的点击事件而改变状态。

在网页上添加按钮

为了能够控制康威生命游戏的时间变化,我们需要在 HTML 网页中加入一些按钮。如下:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
    <title>Conway's Game of Life</title>
    <link href="./css/bundle.min.css" rel="stylesheet">
</head>
<body>
    <div id="controls">
        <button id="play-pause">Play</button>
        <button id="next">Next</button>
    </div>
    <canvas id="game-of-life-canvas"></canvas>
    <script src="./js/bundle.min.js"></script>
</body>
</html>

接着是改写 SCSS/CSS。如下:

body {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    display: flex;
    flex-direction: column;
    align-items: center;
    justify-content: center;
    margin: 0;
}

canvas {
    max-width: 100%;
    max-height: calc(100% - 40px);
}

#controls {
    height: 40px;
    margin: 0 -5px;
    padding: 5px 0 1px 0;
    display: flex;
    flex-direction: row;
}

#controls button {
    width: 120px;
    height: 100%;
    margin: 0 5px;
}

再来是 TypeScript 程序的部份也要修改,因为我们是用 TypeScript 程序来画 Canvas 的。如下:

...

export const init = () => {
    ...

    const getHeight = () => {
        return Math.max(
            document.body.scrollHeight,
            document.documentElement.scrollHeight,
            document.body.offsetHeight,
            document.documentElement.offsetHeight,
            document.documentElement.clientHeight
        ) - 40;
    };

    ...
};

从按钮的标签中可以看出我们是想让这个康威生命游戏在一开始是静止的,当玩家按了按钮之后才会开始动作,因此以下这段的 TypeScript 程序也要改写。

...

export const init = () => {
    ...

    const renderLoop = () => {
        universe.tick();

        drawCells();

        requestAnimationFrame(renderLoop);
    };

    drawCells();
    requestAnimationFrame(renderLoop);
};

改写如下:

...

export const init = () => {
    ...

    let pause = true;

    const renderLoop = () => {
        universe.tick();

        drawCells();

        if (!pause) {
            requestAnimationFrame(renderLoop);
        }
    };

    drawCells();

};

这边另外声明了一个 pause 变量,用来控制 renderLoop 函数是否要继续调用 requestAnimationFrame 函数来重复运行 renderLoop 函数,等等就会撰写按钮的事件程序来改变 pause 变量的值。

此时的 HTML 网页的画面看起来如下图:

加入 Play 与 Next 按钮的网页

增加按钮事件

播放与暂停

在 www/src/lib.ts 中的 init 函数的最下方,添加以下程序:

...

export const init = () => {
    ...

    const buttonPlayPause = document.getElementById("play-pause") as HTMLButtonElement;
    const buttonNext = document.getElementById("next") as HTMLButtonElement;

    buttonPlayPause.addEventListener("click", () => {
        if (pause) {
            pause = false;
            requestAnimationFrame(renderLoop);

            buttonPlayPause.innerHTML = "Pause";

            buttonNext.setAttribute("disabled", "disabled");
        } else {
            pause = true;

            buttonPlayPause.innerHTML = "Play";

            buttonNext.removeAttribute("disabled");
        }
    });
};

如此一来 Play 按钮就有作用了!以下是播放游戏时的截屏:

播放中的康威生命游戏

逐格播放

在游戏暂停时,我们希望可以按下 Next 按钮来将游戏时间推移一个阶段。在 TypeScript 程序中,Play 按钮的事件程序下方,再添加以下程序:

...

export const init = () => {
    ...

    buttonNext.addEventListener("click", () => {
        universe.tick();

        drawCells();
    });
};

这样每按一次 Next 按钮,就会进行逐格播放的动作。

用鼠标切换格子状态

由于我们的 Universe 结构体没有提供能够切换格子状态的方法,所以要先实作一个。程序如下:

#[wasm_bindgen]
impl Universe {
    pub fn toggle_block(&mut self, index: usize) {
        if self.has_cell(index) {
            self.blocks[index] = Block::NoCell;
        } else {
            self.blocks[index] = Block::HasCell;
        }
    }
}

接着在 TypeScript 程序中,Next 按钮的事件程序下方,替 Canvas 加入鼠标点击事件。如下:

...

export const init = () => {
    ...

    canvas.addEventListener("click", (event) => {
        const boundingRect = canvas.getBoundingClientRect();

        const scaleX = canvas.width / boundingRect.width;
        const scaleY = canvas.height / boundingRect.height;

        const canvasLeft = (event.clientX - boundingRect.left) * scaleX;
        const canvasTop = (event.clientY - boundingRect.top) * scaleY;

        const row = Math.floor(canvasTop / size);
        const column = Math.floor(canvasLeft / size);

        const index = universe.get_index(row, column);

        universe.toggle_block(index);

        drawCells();
    });
};

然后再把我们预设的活细胞拿掉,也就是不要在 TypeScript 程序中调用 Universe 结构实体的 default_cells 方法,甚至也可以直接把 default_cells 方法从 WebAssembly 程序中移除掉了。因为我们现在已经可以用鼠标任意地点出我们要的图形了!

用鼠标点出的图形

无边界的培养皿

目前我们的培养皿是有限大小的,因此培养皿的边界会被视为没有活细胞存在,而这通常会让我们好不容易画出来的图形撞到边界就消失了,一点都不好玩!事实上,我们只要稍微修改一下计算邻近格子有无活细胞的代码,就可以让左右边界连接起来、上下边界也连接起来。

修改方式如下:

#[wasm_bindgen]
impl Universe {
    pub fn tick(&mut self) {
        let mut next_blocks = self.blocks.clone();

        for row in 0..self.height {
            for column in 0..self.width {
                ...

                let live_neighbor_cells_count = {
                    let mut counter = 0;

                    let left = column as i64 - 1;

                    let right = column as i64 + 1;

                    let top = row as i64 - 1;

                    let bottom = row as i64 + 1;

                    for r in top..=bottom {
                        for c in left..=right {
                            let r = ((r + self.height as i64) % self.height as i64) as u32;
                            let c = ((c + self.width as i64) % self.width as i64) as u32;

                            if row == r && column == c {
                                continue;
                            }

                            let index = self.get_index(r, c);
                            if self.has_cell(index) {
                                counter += 1;
                            }
                        }
                    }

                    counter
                };

                ...
            }
        }

        ...
    }
}

清除活细胞

无边界的培养皿容易使活细胞的分布变得杂乱,我们可以在 HTML 网页上增加一个清除活细胞的按钮。

修改 HTML 网页,如下:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
    <title>Conway's Game of Life</title>
    <link href="./css/bundle.min.css" rel="stylesheet">
</head>
<body>
    <div id="controls">
        <button id="play-pause">Play</button>
        <button id="next">Next</button>
        <button id="clear">Clear</button>
    </div>
    <canvas id="game-of-life-canvas"></canvas>
    <script src="./js/bundle.min.js"></script>
</body>
</html>

在 src/lib.rs 加入以下程序:

#[wasm_bindgen]
impl Universe {
    pub fn clear(&mut self) {
        for block in self.blocks.iter_mut() {
            *block = Block::NoCell;
        }
    }
}

接着在 TypeScript 程序中,Next 按钮的事件程序下方,替清除按钮加入事件。如下:

...

export const init = () => {
    ...

    const buttonClear = document.getElementById("clear") as HTMLButtonElement;

    ...

    buttonClear.addEventListener("click", () => {
        universe.clear();

        drawCells();
    });

    ...
};

这样我们的康威生命游戏就有清除活细胞的功能了!

清除所有活细胞后的培养皿

用键盘+鼠标切换格子状态

虽然我们现在已经可以用鼠标来点击格子来画图了,但要一个一个慢慢点实在很麻烦。我们可以设计一些图形范本在 WebAssembly 程序之中,当玩家按住键盘上的 Ctrl 键时,再用鼠标左键去点击格子的话,就会随机将我们预设的图形范本插进培养皿中,这样游戏应该会比较好玩一点。

图形范本的类型可以设计如下:

type Pattern = ((u32, u32), &'static [usize]);

在这个元组(tuple)中,第一个字段又是一个元组,表示图形范本的宽和高。而第二个字段是一个数组,表示在这个宽和高的空间中,活细胞存在的索引位置。

有了 Pattern 类型之后,就可以开始内置我们的范本,如下:

#[rustfmt::skip]
const PATTERNS: [Pattern; 8] = [
    (
        (3, 3),
        &[
            1,
            5,
            6, 7, 8
        ]
    ),
    (
        (3, 4),
        &[
            1,
            3, 4, 5,
            6, 8,
            10
        ]
    ),
    (
        (5, 5),
        &[
            0, 2, 4,
            5, 9,
            10, 14,
            15, 19,
            20, 22, 24
        ]
    ),
    (
        (10, 1),
        &[
            0, 1, 2, 3, 4, 5, 6, 7, 8, 9
        ]
    ),
    (
        (5, 4),
        &[
            2, 3,
            5, 6, 8, 9,
            10, 11, 12, 13,
            16, 17
        ]
    ),
    (
        (7, 6),
        &[
            1, 2, 4, 5,
            8, 9, 11, 12,
            16, 18,
            21, 23, 25, 27,
            28, 30, 32, 34,
            35, 36, 40, 41
        ]
    ),
    (
        (7, 6),
        &[
            1, 2, 4, 5,
            8, 9, 11, 12,
            16, 18,
            21, 23, 25, 27,
            28, 30, 32, 34,
            35, 36, 40, 41
        ]
    ),
    (
        (23, 9),
        &[
            1, 2,
            23, 24, 26, 27, 40,
            47, 48, 49, 50, 54, 63,
            71, 72, 76, 78, 81, 82,
            98, 102, 103, 106, 113, 114,
            117, 118, 122, 124, 127, 128,
            139, 140, 141, 142, 146, 155,
            161, 162, 164, 165, 178,
            185, 186
        ]
    ),
];

PATTERNS 就是我们用来保存所有图形范本的数组。

不过由于图形范本有大有小,而且我们的培养皿的空间大小也是可变的,为了避免插入图形范本时去使用到比培养皿还大的图形范本,我们最好在创建 Universe 结构实体时就去筛选。因此,我们要将 Universe 结构体的定义改写如下:

#[wasm_bindgen]
#[derive(Debug)]
pub struct Universe {
    width:    u32,
    height:   u32,
    blocks:   Vec<Block>,
    patterns: Vec<&'static Pattern>,
}

然后修改 Universe 结构体的 new 关联函数。如下:

#[wasm_bindgen]
impl Universe {
    #[wasm_bindgen(constructor)]
    pub fn new(width: u32, height: u32) -> Universe {
        ...

        let mut patterns = Vec::new();

        for ps in PATTERNS.iter() {
            if (ps.0).0 <= width && (ps.0).1 <= height {
                patterns.push(ps);
            }
        }

        Universe {
            width,
            height,
            blocks,
            patterns,
        }
    }

    ...
}

接着替 Universe 结构体加入能在指定位置随机插入图形范本的方法,这边我们要使用 js-sys 套件来绑定标准的 JavaScript API,才可以使用 JavaScript 的 Math.random 来取得随机乱数。注意 js-sys 和 web-sys 是不同的套件,前者用来绑定标准的 JavaScript API,后者用来绑定网页浏览器提供的 API。

编辑 Cargo.toml,在 [dependencies] 区块下加上:

js-sys = "*"

在 src/lib.rs 文件中,加上:

#[wasm_bindgen]
impl Universe {
    pub fn insert_random_pattern(&mut self, index: usize) {
        let patterns_len = self.patterns.len();

        if patterns_len > 0 {
            let rnd = (js_sys::Math::random() * patterns_len as f64).floor() as usize;

            let pattern = self.patterns[rnd];

            let row = index as u32 / self.width;
            let column = index as u32 % self.width;

            for &i in pattern.1.iter() {
                let w = (pattern.0).0;
                let r = i as u32 / w;
                let c = i as u32 % w;

                let row = (row + r) % self.height;
                let column = (column + c) % self.width;

                let index = self.get_index(row, column);

                self.blocks[index] = Block::HasCell;
            }
        }
    }
}

最后就是修改 TypeScript 程序中的 Canvas 鼠标点击事件。如下:

...

export const init = () => {
    ...

    canvas.addEventListener("click", (event) => {
        const boundingRect = canvas.getBoundingClientRect();

        const scaleX = canvas.width / boundingRect.width;
        const scaleY = canvas.height / boundingRect.height;

        const canvasLeft = (event.clientX - boundingRect.left) * scaleX;
        const canvasTop = (event.clientY - boundingRect.top) * scaleY;

        const row = Math.floor(canvasTop / size);
        const column = Math.floor(canvasLeft / size);

        const index = universe.get_index(row, column);

        if (event.ctrlKey) {
            universe.insert_random_pattern(index);
        } else {
            universe.toggle_block(index);
        }

        drawCells();
    });
};

如此一来,当我们按住键盘 Ctrl 键并用鼠标左键点击格子时,就可以在那个地方随机插入我们写死在 WebAssembly 程序中的图形范本了!

以 Ctrl 加鼠标插入的图形范本

避免直接用 import 关键字引入 .wasm 文件

由于 js-sys 套件也有提供 Uint8Array,所以我们的 WebAssembly 程序就不必裸传 Block 数组的指针出来了,也就不需要去用 import 关键字引入 .wasm 文件来用它的 memory 常数。

将程序改写如下:

#[wasm_bindgen]
impl Universe {
    pub fn width(&self) -> u32 {
        self.width
    }

    pub fn height(&self) -> u32 {
        self.height
    }

    #[wasm_bindgen]
    pub fn blocks(&mut self) -> js_sys::Uint8Array {
        unsafe {
            js_sys::Uint8Array::view_mut_raw(self.blocks.as_mut_ptr() as *mut u8, self.blocks.len())
        }
    }
}
// import { memory } from "../../pkg/wasm_game_of_life_bg.wasm"; // remove this line

...

export const init = () => {
    ...

    const drawCells = () => {
        const blocks = universe.blocks() as unknown as Block[];
    
        ctx.beginPath();

        ...
    };

    ...
};

总结

我们终于把康威生命游戏与玩家的交互功能实作出来了!在这个章节中,我们还用了 js-sys 套件绑定 JavaScript 的标准 API。

在下一个章节中,要来介绍如何侦测、优化 HTML 网页画面的 FPS (Frames Per Second),以及控制康威生命游戏的播放速度。

下一章:康威生命游戏的性能。