product iamge

Game Development with Rust and WebAssembly: Learn how to run Rust on the web while building a game

This document was uploaded by one of our users. The uploader already confirmed that they had the permission to publish it. If you are author/publisher or own the copyright of this documents, please report to us by using this DMCA report form.

Download
Search on Amazon

Simply click on the Download Book button.

Yes, Book downloads on Ebookily are 100% Free.

Sometimes the book is free on Amazon As well, so go ahead and hit "Search on Amazon"

Write an endless runner game for the web in Rust and test, deploy, and debug your 2D game using the WebAssembly toolchain

Key Features

  • Build and deploy an endless runner game for the web from scratch through this helpful guide with key images printed in color
  • Learn how to use Rust for web development with WebAssembly
  • Explore modern game development and programming techniques to build 2D games using Rust

Book Description

The Rust programming language has held the most-loved technology ranking on Stack Overflow for 6 years running, while JavaScript has been the most-used programming language for 9 years straight as it runs on every web browser. Now, thanks to WebAssembly (or Wasm), you can use the language you love on the platform that's everywhere.

This book is an easy-to-follow reference to help you develop your own games, teaching you all about game development and how to create an endless runner from scratch. You'll begin by drawing simple graphics in the browser window, and then learn how to move the main character across the screen. You'll also create a game loop, a renderer, and more, all written entirely in Rust. After getting simple shapes onto the screen, you'll scale the challenge by adding sprites, sounds, and user input. As you advance, you'll discover how to implement a procedurally generated world. Finally, you'll learn how to keep your Rust code clean and organized so you can continue to implement new features and deploy your app on the web.

By the end of this Rust programming book, you'll build a 2D game in Rust, deploy it to the web, and be confident enough to start building your own games.

What you will learn

  • Build and deploy a Rust application to the web using WebAssembly
  • Use wasm-bindgen and the Canvas API to draw real-time graphics
  • Write a game loop and take keyboard input for dynamic action
  • Explore collision detection and create a dynamic character that can jump on and off platforms and fall down holes
  • Manage animations using state machines
  • Generate levels procedurally for an endless runner
  • Load and display sprites and sprite sheets for animations
  • Test, refactor, and keep your code clean and maintainable

Who this book is for

This game development book is for developers interested in Rust who want to create and deploy 2D games to the web. Game developers looking to build a game on the web platform using WebAssembly without C++ programming or web developers who want to explore WebAssembly along with JavaScript web will also find this book useful. The book will also help Rust developers who want to move from the server side to the client side by familiarizing them with the WebAssembly toolchain. Basic knowledge of Rust programming is assumed.

Table of Contents

  1. Hello WebAssembly
  2. Drawing Sprites
  3. Creating a Game Loop
  4. Managing Animations with State Machines
  5. Collision Detection
  6. Creating an Endless Runner
  7. Sound Effects and Music
  8. Adding a UI
  9. Testing, Debugging, and Performance
  10. Continuous Deployment
  11. Further Resources and What's Next?

Author(s): Eric Smith
Edition: 1
Publisher: Packt Publishing
Year: 2022

Language: English
Pages: 476
Tags: Game Development; Rust; WebAssembly

Cover
Title Page
Copyright and Credits
Dedication
Contributors
Table of Contents
Preface
Part 1: Getting Started with Rust, WebAssembly, and Game Development
Chapter 1: Hello WebAssembly
Technical requirements
What is WebAssembly?
A Rust project skeleton
Drawing to the canvas
The current code
Drawing a triangle
A Sierpińksi triangle
Summary
Chapter 2: Drawing Sprites
Technical requirements
A quick game design session
Rendering a sprite
Loading images
Canvas coordinates
Drawing images
JavaScript callbacks
Async Rust
Sprite sheets
Loading JSON
Parsing JSON
Drawing with our "cookie cutter"
Adding animation
Summary
Part 2: Writing Your Endless Runner
Chapter 3: Creating a Game Loop
Technical requirements
Minimal architecture
Good? Bad? I'm the guy with code
Layered architecture
Creating the browser module
Loading an image
Creating a game loop
RequestAnimationFrame
A game trait
Fixing our time step
Loading assets
Cleaner drawing
Integrating the game loop
Adding keyboard input
Moving Red Hat Boy
Summary
Chapter 4: Managing Animations with State Machines
Technical requirements
Introducing state machines
Defining a state machine
Implementing with types
Managing animation
Transitioning between states
Managing the state machine
Using Into for clean code
Integrating the state machine
Drawing RedHatBoy
Updating RHB
Adding the Running state
Transitioning to sliding
Transitioning to sliding and back again
Every little thing I think I see
Transitioning to jumping
Summary
Chapter 5: Collision Detection
Technical requirements
Creating a real scene
Adding the background
Adding an obstacle
Axis-aligned bounding boxes
Collision
Trimming the sprite sheet
Adding the trimmed sheet
Colliding with an obstacle
A bounding box for a stone
A bounding box for RedHatBoy
Crashing on the collision
Jumping onto a platform
Adding a platform
Collision from below
Transparency in bounding boxes
Summary
Chapter 6: Creating an Endless Runner
Technical requirements
Scrolling the background
Fixing RHB in x
An infinite background
Refactoring for endless running
f32 versus i16
A more useful Rect
Obstacle traits
Removing obstacles as they go off screen
Sharing a sprite sheet
Many different platforms
Creating a dynamic level
Creating one segment
Adding a timeline
Creating segments
Summary
Chapter 7: Sound Effects and Music
Technical requirements
Adding the Web Audio API to the engine
Playing a sound in Rust
Loading the sound
Adding audio to the engine
Playing sound effects
Refactoring RedHatBoyContext and RedHatBoy
Adding a sound effect
Playing long music
Summary
Chapter 8: Adding a UI
Technical requirements
Design a new game button
Preparing a UI
Showing the button with Rust
Show the button on game over
A state machine review
Redesigning to a state machine
Start a new Game
Pre-loading
Summary
Part 3: Testing and Advanced Tricks
Chapter 9: Testing, Debugging, and Performance
Technical requirements
Creating automated tests
Test-driven development
Getting started
Pure functions
Hiding the Browser module
Browser tests
Async tests
Debugging the game
Log versus error versus panic
Linting and Clippy
Measuring performance with a browser
Frame rate counter
Browser debugger
Checking memory
Summary
Chapter 10: Continuous Deployment
Technical requirements
Creating a CI/CD pipeline
GitHub Actions
Node.js and webpack
Deploying test and production builds
Summary
Chapter 11: Further Resources and What's Next?
Technical requirements
A challenging review
What happened to the dog?
Further resources
Using JavaScript libraries
Summary
Index
About Packt
Other Books You May Enjoy