pxt-calliope/docs/projects/infection.md
Chase Mortensen 24c42cc3e8
Fixes for infection game ()
* Fixes for infection game

* Updated infection game to use message class

* fixed whitespace

* Changes to Message class
2019-04-12 17:13:20 -07:00

519 lines
17 KiB
Markdown

# Infection
## ~avatar avatar
There is a disease outbreak! Will you find patient zero?!?
## ~
**Infection** is a distributed game which simulates
the spread of an illness. **The goal is to stop the outbreak before every player dies!**
* **Number of players:** 1 Master and 4, or more, additional players. The Master and all other players need a @boardname@ with battery pack.
In this game, a Master @boardname@ infects a single, initial player ("patient zero")
with the illness. The infected player is contagious immediately but won't show any signs sickness
during the incubation time. The sickness gets transmitted when two @boardname@s get close enough to each other to "contract the disease".
After the incubation period, a sad face appears on the screen. After the sickness period, the player will eventually die and a skull displays on the screen. Dead players are out of the game.
If at least one player survives the outbreak, the game is won. Otherwise, try again!
## ~ hint
**Infection** is an engaging game that will get your students running around.
We recommend playing it outside, or in a large open area, to give more space for the activity.
## ~
## How to play
Press `A+B` to enter Master mode (there's only one Master in a game).
Wait for players to be paired. The number of paired players will display on the screen.
When paired, a letter appears on the player's screen, this letter is the player's identity.
Once all of your players are registered, press `A+B` to start the infection game.
The game randomly picks a player as **patient zero**.
A player will transmit the disease to another player if close enough (detecting a sufficient `RSSI`), and if a certain probability (`TRANSMISSIONPROB`) of disease transfer is reached.
During the incubation phase (`INCUBATION`), the player does not show any sign of illness (happy face).
After that phase, the player gets sick and shows a sad face on the screen. After the sick (sad) face, the player dies and a skull shows up.
Once the game is over, the @boardname@ will show the player's id (`A`, `B`, `C`...), health, and
the id of the player who infected them. The Master @boardname@ will show the identity of patient zero.
Icons used in the game:
* Pairing: `IconNames.Ghost`
* Paired: `IconNames.Happy`
* Dead: `IconNames.Skull`
* Sick: `IconNames.Sad`
* Incubating: `IconNames.Confused`
* Healthy: `IconNames.Happy`
## ~ hint
Take a look at this video to see how the @boardname@ uses radio to spread "disease"
in this game:
https://www.youtube.com/watch?v=Re3H2ISfQE8
## ~
## Project share
### ~ hint
This code uses language features, such as ``switch`` or ``enum``, that are not supported in blocks.
As a result, it will not convert back to blocks.
### ~
## JavaScript code
```typescript
/**
* Infection game
*
* Flash all micro:bit will this script
*
* Press A+B to enter master mode (1 per game)
*
* Wait for players to be paired. The number of paired player will display on screen.
* An icon will appear on player's screen.
*
* Press A+B to start the infection game. The master will pick a random
* player as patient zero.
*
* A player will transmit the disease if close enough (RSSI)
* and with a certain probability (TRANSMISSIONPROB).
* During the incudation phase (INCUBATION), the player does not show any sign
* of illness. After that phase, the sad face shows up.
*
* The game will automatically stop once all players are dead or healthy. The master can
* also press A+B again to stop the game.
*
* Once the game is over, the micro:bit will show the player id (A,B,C...), health and
* who infected him.
*
* Icons used in the game:
*
* Pairing: IconNames.Ghost
* Paired: IconNames.Happy
* Dead: IconNames.Skull
* Sick: IconNames.Sad
* Incubating: IconNames.Confused
* Healthy: IconNames.Happy
*
*/
const INCUBATION = 20000; // time before showing symptoms
const DEATH = 40000; // time before dying off the disease
const RSSI = -45; // db
const TRANSMISSIONPROB = 40; // % probability to transfer disease
enum GameState {
Stopped,
Pairing,
Infecting,
Running,
Over
}
enum HealthState {
Healthy,
Incubating,
Sick,
Dead
}
enum MessageKind {
PairRequest,
PairConfirmation,
HealthSet,
HealthValue,
InitialInfect,
TransmitVirus,
GameState
}
const GameIcons = {
Pairing: IconNames.Ghost,
Paired: IconNames.Happy,
Dead: IconNames.Skull,
Sick: IconNames.Sad,
Incubating: IconNames.Confused,
Healthy: IconNames.Happy
}
class Message {
private _data: Buffer;
constructor(input?: Buffer) {
this._data = input || control.createBuffer(13);
}
get kind(): number {
return this._data.getNumber(NumberFormat.Int8LE, 0);
}
set kind(x: number) {
this._data.setNumber(NumberFormat.Int8LE, 0, x);
}
get fromSerialNumber(): number {
return this._data.getNumber(NumberFormat.Int32LE, 1);
}
set fromSerialNumber(x: number) {
this._data.setNumber(NumberFormat.Int32LE, 1, x);
}
get value(): number {
return this._data.getNumber(NumberFormat.Int32LE, 5);
}
set value(x: number) {
this._data.setNumber(NumberFormat.Int32LE, 5, x);
}
get toSerialNumber(): number {
return this._data.getNumber(NumberFormat.Int32LE, 9);
}
set toSerialNumber(x: number) {
this._data.setNumber(NumberFormat.Int32LE, 9, x);
}
send() {
radio.sendBuffer(this._data);
basic.pause(250);
}
}
const playerIcons = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
class Player {
id: number;
icon: number;
health: HealthState;
show() {
basic.showString(playerIcons[this.icon]);
}
}
// common state
let state = GameState.Stopped;
// master state
let master = false;
let patientZero: Player;
const players: Player[] = [];
// player state
let paired = false;
let infectedBy = -1; // who infected (playerIcon)
let infectedTime = 0; // local time when infection happened
let playerIcon = -1; // player icon and identity
let health = HealthState.Healthy;
// get a player instance (creates one as needed)
function player(id: number): Player {
for (const p of players)
if (p.id == id) return p;
// add player to game
let p = new Player();
p.id = id;
p.icon = (players.length + 1) % playerIcons.length;
p.health = HealthState.Healthy;
players.push(p);
serial.writeLine(`player ==> ${p.id}`)
return p;
}
function allDead(): boolean {
for (const p of players)
if (p.health != HealthState.Dead) return false;
return true;
}
function gameOver() {
state = GameState.Over;
if (patientZero)
patientZero.show();
}
function gameFace() {
switch (state) {
case GameState.Stopped:
basic.showIcon(GameIcons.Pairing);
break;
case GameState.Pairing:
if (playerIcon > -1)
basic.showString(playerIcons[playerIcon]);
else
basic.showIcon(paired ? GameIcons.Paired : GameIcons.Pairing, 1);
break;
case GameState.Infecting:
case GameState.Running:
switch (health) {
case HealthState.Dead:
basic.showIcon(GameIcons.Dead, 1);
break;
case HealthState.Sick:
basic.showIcon(GameIcons.Sick, 1);
break;
default:
basic.showIcon(GameIcons.Healthy, 1);
break;
}
break;
case GameState.Over:
// show id
basic.showString(playerIcons[playerIcon]);
basic.pause(2000);
// show health
switch (health) {
case HealthState.Dead:
basic.showIcon(GameIcons.Dead, 2000);
break;
case HealthState.Sick:
basic.showIcon(GameIcons.Sick, 2000);
break;
case HealthState.Incubating:
basic.showIcon(GameIcons.Incubating, 2000);
break;
default:
basic.showIcon(GameIcons.Healthy, 2000);
break;
}
// show how infected
if (infectedBy > -1) {
basic.showString(" INFECTED BY");
basic.showString(playerIcons[infectedBy]);
basic.pause(2000);
} else {
basic.showString(" PATIENT ZERO");
basic.pause(2000);
}
// show score
game.showScore();
basic.pause(1000);
break;
}
}
// master button controller
input.onButtonPressed(Button.AB, () => {
// register as master
if (state == GameState.Stopped && !master) {
master = true;
paired = true;
state = GameState.Pairing;
serial.writeLine("registered as master");
radio.setTransmitPower(7); // beef up master signal
basic.showString("0");
return;
}
if (!master) return; // master only beyond this
// launch game
if (state == GameState.Pairing) {
// pick 1 player and infect him
patientZero = players[Math.randomRange(0, players.length - 1)];
// infecting message needs to be confirmed by
// the player
state = GameState.Infecting;
serial.writeLine(`game started ${players.length} players`);
} // end game
else if (state == GameState.Running) {
gameOver();
}
})
radio.setGroup(42);
radio.onReceivedBuffer(function (receivedBuffer: Buffer) {
const incomingMessage = new Message(receivedBuffer);
const signal = radio.receivedPacket(RadioPacketProperty.SignalStrength);
if (master) {
switch (incomingMessage.kind) {
case MessageKind.PairRequest:
// register player
let n = players.length;
player(incomingMessage.fromSerialNumber);
// show player number if changed
if (n != players.length) {
basic.showNumber(players.length);
}
break;
case MessageKind.HealthValue:
let p = player(incomingMessage.fromSerialNumber);
p.health = incomingMessage.value;
// check if all infected
if (allDead())
gameOver();
break;
}
} else {
switch (incomingMessage.kind) {
case MessageKind.GameState:
// update game state
state = incomingMessage.value as GameState;
break;
case MessageKind.InitialInfect:
if (infectedBy < 0 &&
incomingMessage.toSerialNumber == control.deviceSerialNumber()) {
// infected by master
infectedBy = 0; // infected my master
infectedTime = input.runningTime();
health = HealthState.Incubating;
serial.writeLine(`infected ${control.deviceSerialNumber()}`);
}
break;
case MessageKind.HealthSet:
if (incomingMessage.toSerialNumber == control.deviceSerialNumber()) {
const newHealth = incomingMessage.value;
if (health < newHealth) {
health = newHealth;
}
}
break;
case MessageKind.PairConfirmation:
if (!paired && state == GameState.Pairing &&
incomingMessage.toSerialNumber == control.deviceSerialNumber()) {
// paired!
serial.writeLine(`player paired ==> ${control.deviceSerialNumber()}`)
playerIcon = incomingMessage.value;
paired = true;
}
break;
case MessageKind.TransmitVirus:
if (state == GameState.Running) {
if (health == HealthState.Healthy) {
serial.writeLine(`signal: ${signal}`);
if (signal > RSSI &&
Math.randomRange(0, 100) > TRANSMISSIONPROB) {
infectedBy = incomingMessage.value;
infectedTime = input.runningTime();
health = HealthState.Incubating;
}
}
}
break;
case MessageKind.HealthValue:
if (health != HealthState.Dead && signal > RSSI) {
game.addScore(1);
}
break;
}
}
})
// main game loop
basic.forever(() => {
let message: Message;
if (master) {
switch (state) {
case GameState.Pairing:
// tell each player they are registered
for (const p of players) {
message = new Message();
message.kind = MessageKind.PairConfirmation;
message.value = p.icon;
message.toSerialNumber = p.id;
message.send();
}
serial.writeLine(`pairing ${players.length} players`);
basic.pause(500);
break;
case GameState.Infecting:
if (patientZero.health == HealthState.Healthy) {
message = new Message();
message.kind = MessageKind.InitialInfect;
message.toSerialNumber = patientZero.id;
message.send();
basic.pause(100);
} else {
serial.writeLine(`patient ${patientZero.id} infected`);
// show startup
basic.showIcon(GameIcons.Dead);
state = GameState.Running;
}
break;
case GameState.Running:
for (const p of players) {
message = new Message();
message.kind = MessageKind.HealthSet;
message.value = p.health;
message.toSerialNumber = p.id;
message.send();
}
break;
case GameState.Over:
if (patientZero)
patientZero.show();
break;
}
message = new Message()
message.kind = MessageKind.GameState;
message.value = state;
message.send();
} else { // player loop
switch (state) {
case GameState.Pairing:
// broadcast player id
if (playerIcon < 0) {
message = new Message();
message.kind = MessageKind.PairRequest;
message.fromSerialNumber = control.deviceSerialNumber();
message.send();
} else if (infectedBy > -1) {
message = new Message();
message.kind = MessageKind.HealthValue;
message.fromSerialNumber = control.deviceSerialNumber();
message.value = health;
message.send();
}
break;
case GameState.Infecting:
message = new Message();
message.kind = MessageKind.HealthValue;
message.fromSerialNumber = control.deviceSerialNumber();
message.value = health;
message.send();
break;
case GameState.Running:
// update health status
if (health != HealthState.Healthy && input.runningTime() - infectedTime > DEATH)
health = HealthState.Dead;
else if (health != HealthState.Healthy && input.runningTime() - infectedTime > INCUBATION)
health = HealthState.Sick;
// transmit disease
if (health == HealthState.Incubating || health == HealthState.Sick) {
message = new Message();
message.kind = MessageKind.TransmitVirus;
message.fromSerialNumber = control.deviceSerialNumber();
message.value = playerIcon;
message.send();
}
message = new Message();
message.kind = MessageKind.HealthValue;
message.fromSerialNumber = control.deviceSerialNumber();
message.value = health;
message.send();
break;
}
// show current animation
gameFace();
}
})
basic.showIcon(GameIcons.Pairing)
```
```package
radio
```