Contents

1. Introduction
2. The main loop
3. Locations
4. Objects
5. Inventory
6. Passages
7. Distance
8. North, east, south, west
9. Code generation
10. More attributes
11. Conditions
12. Open and close
13. The parser
14. Multiple nouns
15. Light and dark
16. Savegame
17. Test automation
18. Abbreviations
19. Conversations
20. Combat
21. Multi-player
22. Client-server
23. Database
24. Speech
25. JavaScript

How to program a text adventure in C

by Ruud Helderman <r.helderman@hccnet.nl>

Licensed under MIT License

21. Multi-player

It wasn’t long after the first text adventures appeared, that somebody came with the idea to make it a multi-user event. MUDs flourished on university networks, then gradually found their way to home users through BBSs. Later, widespread internet access paved the way for MMOs, but by that time, attention had already shifted from text-based gaming to 3D graphics. Sure, the whole world is texting, but even among gamers, few are aware you can use that for role-playing.

Multi-player is a rather broad term. It could stand for:

  1. Having multiple player characters in the same game.
  2. Having multiple users together playing within the same game session.

In most cases, both apply, and there will be a one-on-one relationship, i.e. every user controls one player character. But it doesn’t have to be this way: it is very well possible to make a game where a single user is controlling multiple player characters. That may not be everybody’s idea of fun, but technically, these are separate dimensions, largely independent of each other. And since there’s plenty of work to be done, it makes sense to divide it across two chapters. Below, we will introduce the concept of having more than one player character, while at the same time keeping the game a single-user experience. In the next chapter, we will make the game truly multi-user.

In its simplest form, multiple player characters means the user will be given the opportunity to switch between characters, controlling them one at a time. Imagine we have two player characters: Jack and Jill. We could introduce a command ‘play’ that allows the user to take control of either one of those characters. The following four commands would then make Jack pick up the club, and Jill pick up the dagger.

play jack get club play jill get dagger

Multiple player characters could be a nice opportunity to have puzzles in your game that can only be solved by having the characters cooperate in a certain way. For example, one character could be used to distract or lure away the guard, while the other character sneaks into the cave. Puzzles might also demand the user to carefully think about each character’s strengths and weaknesses.

It won’t be until the next chapter that we will benefit from the social aspect of multi-player: being able to really interact (remotely) with other human beings. But since we are expanding our vocabulary anyway (the verb play), we might as well take the opportunity to introduce some ‘social’ commands.

Let’s start by adding the new verbs to our vocabulary.

Sample output
Welcome to Little Cave Adventure.
You are in the waiting room.
You see:
walls all around you

--> play jack
You are Jack. Jack is a fearsome warrior.

--> look around
You are in an open field.
You see:
a silver coin
a burly guard
Jill
a cave entrance to the east
dense forest all around
a lamp
a wooden club
a dagger

--> get club
You pick up a wooden club.

--> play jill
You are Jill. Jill is a vicious valkyrie.

--> look around
You are in an open field.
You see:
a silver coin
a burly guard
Jack
a cave entrance to the east
dense forest all around
a lamp
a dagger

--> say Where am I?
You say: Where am I?

--> whisper to jack I need a weapon.
You whisper to Jack: I need a weapon.

--> get dagger
You pick up a dagger.

--> emote assume a fighting stance.
You assume a fighting stance.

--> attack guard
You hit a burly guard with a dagger.
You are hit by a burly guard with bare hands.

--> play jill
You already are Jill.

--> play jack
You are Jack. Jack is a fearsome warrior.

--> attack guard
You hit a burly guard with a wooden club.

--> quit

Bye!
parsexec.c
  1. #include <ctype.h>
  2. #include <stdbool.h>
  3. #include <stdio.h>
  4. #include "object.h"
  5. #include "misc.h"
  6. #include "match.h"
  7. #include "location.h"
  8. #include "inventory.h"
  9. #include "inventory2.h"
  10. #include "openclose.h"
  11. #include "onoff.h"
  12. #include "talk.h"
  13. #include "attack.h"
  14. #include "social.h"
  16. typedef struct
  17. {
  18. const char *pattern;
  19. int (*function)(void);
  20. } COMMAND;
  22. static int executeQuit(void)
  23. {
  24. return -1;
  25. }
  27. static int executeNoMatch(void)
  28. {
  29. const char *src = *params;
  30. int len;
  31. for (len = 0; src[len] != '\0' && !isspace(src[len]); len++);
  32. if (len > 0) printf("I don't know how to '%.*s'.\n", len, src);
  33. return 0;
  34. }
  36. static int executeWait(void)
  37. {
  38. printf("Some time passes...\n");
  39. return 1;
  40. }
  42. int parseAndExecute(const char *input)
  43. {
  44. static const COMMAND commands[] =
  45. {
  46. { "quit" , executeQuit },
  47. { "look" , executeLookAround },
  48. { "look around" , executeLookAround },
  49. { "look at A" , executeLook },
  50. { "look A" , executeLook },
  51. { "examine A" , executeLook },
  52. { "go to A" , executeGo },
  53. { "go A" , executeGo },
  54. { "get A from B" , executeGetFrom },
  55. { "get A" , executeGet },
  56. { "put A in B" , executePutIn },
  57. { "drop A in B" , executePutIn },
  58. { "drop A" , executeDrop },
  59. { "ask A from B" , executeAskFrom },
  60. { "ask A" , executeAsk },
  61. { "give A to B" , executeGiveTo },
  62. { "give A" , executeGive },
  63. { "inventory" , executeInventory },
  64. { "open A" , executeOpen },
  65. { "close A" , executeClose },
  66. { "lock A" , executeLock },
  67. { "unlock A" , executeUnlock },
  68. { "turn on A" , executeTurnOn },
  69. { "turn off A" , executeTurnOff },
  70. { "turn A on" , executeTurnOn },
  71. { "turn A off" , executeTurnOff },
  72. { "talk with B about A" , executeTalkTo },
  73. { "talk about A with B" , executeTalkTo },
  74. { "talk about A" , executeTalk },
  75. { "talk A" , executeTalk },
  76. { "attack with B" , executeAttack },
  77. { "attack A with B" , executeAttack },
  78. { "attack A" , executeAttack },
  79. { "wait" , executeWait },
  80. { "play A" , executePlay },
  81. { "emote A" , executeEmote },
  82. { "say A" , executeSay },
  83. { "whisper to B A" , executeWhisper },
  84. { "A" , executeNoMatch }
  85. };
  86. const COMMAND *cmd;
  87. for (cmd = commands; !matchCommand(input, cmd->pattern); cmd++);
  88. return (*cmd->function)();
  89. }

The implementation of the new commands is extremely straightforward. Of course, the ‘social’ commands are not very useful yet. Being the only user, you are basically talking to yourself. But it does give us the foundation to actually socialize in the next chapter.

social.h
  1. extern int executePlay(void);
  2. extern int executeEmote(void);
  3. extern int executeSay(void);
  4. extern int executeWhisper(void);
social.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "match.h"
  5. #include "noun.h"
  6. #include "reach.h"
  7. #include "location.h"
  9. int executePlay(void)
  10. {
  11. OBJECT *obj = getTopic(params[0]);
  12. if (obj == NULL)
  13. {
  14. printf("I don't understand what character you want to play.\n");
  15. }
  16. else if (obj == player)
  17. {
  18. printf("You already are %s.\n", player->description);
  19. }
  20. else if (obj == jack || obj == jill)
  21. {
  22. player = obj;
  23. printf("You are %s. %s\n", player->description, player->details);
  24. }
  25. else
  26. {
  27. printf("That is not a character you can play.\n");
  28. }
  29. return 0;
  30. }
  32. int executeEmote(void)
  33. {
  34. const char *phrase = params[0];
  35. if (*phrase == '\0')
  36. {
  37. printf("I don't understand what you want to emote.\n");
  38. }
  39. else
  40. {
  41. printf("You %s\n", phrase);
  42. }
  43. return 0;
  44. }
  46. int executeSay(void)
  47. {
  48. const char *phrase = params[0];
  49. if (*phrase == '\0')
  50. {
  51. printf("I don't understand what you want to say.\n");
  52. }
  53. else
  54. {
  55. printf("You say: %s\n", phrase);
  56. }
  57. return 0;
  58. }
  60. int executeWhisper(void)
  61. {
  62. OBJECT *to = reachableObject("who to whisper to", params[1]);
  63. if (to != NULL)
  64. {
  65. const char *phrase = params[0];
  66. if (*phrase == '\0')
  67. {
  68. printf("I don't understand what you want to whisper.\n");
  69. }
  70. else
  71. {
  72. printf("You whisper to %s: %s\n", to->description, phrase);
  73. }
  74. }
  75. return 0;
  76. }

Explanation:

However, we cannot just assign a new value to player (see line 22 above) without turning it into a variable.

object.awk
  1. BEGIN {
  2. count = 0;
  3. obj = "";
  4. if (pass == "c2") {
  5. print "\nstatic bool alwaysTrue(void) { return true; }";
  6. print "\nOBJECT objs[] = {";
  7. }
  8. }
  10. /^- / {
  11. outputRecord(",");
  12. obj = $2;
  13. prop["condition"] = "alwaysTrue";
  14. prop["description"] = "NULL";
  15. prop["tags"] = "";
  16. prop["location"] = "NULL";
  17. prop["destination"] = "NULL";
  18. prop["prospect"] = "";
  19. prop["details"] = "\"You see nothing special.\"";
  20. prop["contents"] = "\"You see\"";
  21. prop["textGo"] = "\"You can't get much closer than this.\"";
  22. prop["gossip"] = "\"I know nothing about that.\"";
  23. prop["weight"] = "99";
  24. prop["capacity"] = "0";
  25. prop["health"] = "0";
  26. prop["light"] = "0";
  27. prop["impact"] = "0";
  28. prop["trust"] = "0";
  29. prop["open"] = "cannotBeOpened";
  30. prop["close"] = "cannotBeClosed";
  31. prop["lock"] = "cannotBeLocked";
  32. prop["unlock"] = "cannotBeUnlocked";
  33. }
  35. obj && /^[ \t]+[a-z]/ {
  36. name = $1;
  37. $1 = "";
  38. if (name in prop) {
  39. prop[name] = $0;
  40. if (/^[ \t]*\{/) {
  41. prop[name] = name count;
  42. if (pass == "c1") print "static bool " prop[name] "(void) " $0;
  43. }
  44. }
  45. else if (pass == "c2") {
  46. print "#error \"" FILENAME " line " NR ": unknown attribute '" name "'\"";
  47. }
  48. }
  50. !obj && pass == (/^#include/ ? "c1" : "h") {
  51. print;
  52. }
  54. END {
  55. outputRecord("\n}, *player = nobody;");
  56. if (pass == "h") {
  57. print "\n#define endOfObjs\t(objs + " count ")";
  58. print "\n#define validObject(obj)\t" \
  59. "((obj) != NULL && (*(obj)->condition)())";
  60. }
  61. }
  63. function outputRecord(separator)
  64. {
  65. if (obj) {
  66. if (pass == "h") {
  67. print "#define " obj "\t(objs + " count ")";
  68. }
  69. else if (pass == "c1") {
  70. print "static const char *tags" count "[] = {" prop["tags"] ", NULL};";
  71. }
  72. else if (pass == "c2") {
  73. print "\t{\t/* " count " = " obj " */";
  74. print "\t\t" prop["condition"] ",";
  75. print "\t\t" prop["description"] ",";
  76. print "\t\ttags" count ",";
  77. print "\t\t" prop["location"] ",";
  78. print "\t\t" prop["destination"] ",";
  79. print "\t\t" prop[prop["prospect"] ? "prospect" : "destination"] ",";
  80. print "\t\t" prop["details"] ",";
  81. print "\t\t" prop["contents"] ",";
  82. print "\t\t" prop["textGo"] ",";
  83. print "\t\t" prop["gossip"] ",";
  84. print "\t\t" prop["weight"] ",";
  85. print "\t\t" prop["capacity"] ",";
  86. print "\t\t" prop["health"] ",";
  87. print "\t\t" prop["light"] ",";
  88. print "\t\t" prop["impact"] ",";
  89. print "\t\t" prop["trust"] ",";
  90. print "\t\t" prop["open"] ",";
  91. print "\t\t" prop["close"] ",";
  92. print "\t\t" prop["lock"] ",";
  93. print "\t\t" prop["unlock"];
  94. print "\t}" separator;
  95. delete prop;
  96. }
  97. count++;
  98. }
  99. }

Explanation:

Up until now, player has been a fixed object. We will get rid of that object, and instead introduce ‘named’ character objects jack and jill.

object.txt
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "toggle.h"
  6. typedef struct object {
  7. bool (*condition)(void);
  8. const char *description;
  9. const char **tags;
  10. struct object *location;
  11. struct object *destination;
  12. struct object *prospect;
  13. const char *details;
  14. const char *contents;
  15. const char *textGo;
  16. const char *gossip;
  17. int weight;
  18. int capacity;
  19. int health;
  20. int light;
  21. int impact;
  22. int trust;
  23. void (*open)(void);
  24. void (*close)(void);
  25. void (*lock)(void);
  26. void (*unlock)(void);
  27. } OBJECT;
  29. extern OBJECT *player, objs[];
  31. - heaven
  32. description "little heaven"
  33. tags "heaven", "little heaven"
  34. details "Everything looks so peaceful here."
  35. gossip "It's where all the good adventurers go."
  36. capacity 9999
  37. light 100
  39. - respawn
  40. description "a respawn portal"
  41. tags "portal", "respawn portal"
  42. location heaven
  43. destination field
  44. details "Looks like a gateway into the unknown."
  45. textGo "A bright flash of light, and you are back in the field."
  46. open isAlreadyOpen
  48. - heavenEWNS
  49. description "nothing but peace and quiet"
  50. tags "east", "west", "north", "south"
  51. location heaven
  52. textGo "In this dimension, there are no directions."
  53. gossip "It's just a compass direction."
  55. - waitingRoom
  56. description "the waiting room"
  57. tags "room", "waiting room"
  58. details "This is where everybody starts. Please enter: play YourName."
  59. gossip "It's where all the bad adventurers have to stay."
  60. capacity 9999
  61. light 100
  63. - waitingRoomWall
  64. description "walls all around you"
  65. tags "wall", "east", "west", "north", "south"
  66. location waitingRoom
  67. details "Written on the wall, it says: play Jack or play Jill."
  68. textGo "You cannot go anywhere."
  70. - nobody
  71. description "nobody"
  72. tags "nobody"
  73. location waitingRoom
  74. details "You are nobody. Please enter: play xxx"
  75. contents "You have"
  76. health 100
  77. capacity 1
  79. - field
  80. description "an open field"
  81. tags "field"
  82. details "The field is a nice and quiet place under a clear blue sky."
  83. gossip "A lot of tourists go there."
  84. capacity 9999
  85. light 100
  87. - cave
  88. description "a little cave"
  89. tags "cave"
  90. details "The cave is just a cold, damp, rocky chamber."
  91. gossip "It's dark in there; bring a lamp!"
  92. capacity 9999
  94. - silver
  95. description "a silver coin"
  96. tags "silver", "coin", "silver coin"
  97. location field
  98. details "The coin has an eagle on the obverse."
  99. gossip "Money makes the world go round..."
  100. weight 1
  102. - gold
  103. description "a gold coin"
  104. tags "gold", "coin", "gold coin"
  105. location openBox
  106. details "The shiny coin seems to be a rare and priceless artefact."
  107. gossip "Money makes the world go round..."
  108. weight 1
  110. - guard
  111. description "a burly guard"
  112. tags "guard", "burly guard"
  113. location field
  114. details "The guard is a really big fellow."
  115. gossip "Easy to bribe..."
  116. contents "He has"
  117. health 100
  118. impact -1
  119. capacity 20
  121. - jack
  122. description "Jack"
  123. tags "jack", "warrior", "man"
  124. location field
  125. details "Jack is a fearsome warrior."
  126. gossip "Jack is a fearsome warrior."
  127. contents "Jack has"
  128. health 100
  129. impact -1
  130. capacity 20
  132. - jill
  133. description "Jill"
  134. tags "jill", "valkyrie", "woman"
  135. location field
  136. details "Jill is a vicious valkyrie."
  137. gossip "Jill is a vicious valkyrie."
  138. contents "Jill has"
  139. health 100
  140. impact -1
  141. capacity 20
  143. - intoCave
  144. condition { return guard->health == 0 || silver->location == guard; }
  145. description "a cave entrance to the east"
  146. tags "east", "entrance"
  147. location field
  148. destination cave
  149. details "The entrance is just a narrow opening in a small outcrop."
  150. textGo "You walk into the cave."
  151. open isAlreadyOpen
  153. - intoCaveBlocked
  154. condition { return guard->health > 0 && silver->location != guard; }
  155. description "a cave entrance to the east"
  156. tags "east", "entrance"
  157. location field
  158. prospect cave
  159. details "The entrance is just a narrow opening in a small outcrop."
  160. textGo "The guard stops you from walking into the cave."
  161. open isAlreadyOpen
  163. - exitCave
  164. description "an exit to the west"
  165. tags "west", "exit"
  166. location cave
  167. destination field
  168. details "Sunlight pours in through an opening in the cave's wall."
  169. textGo "You walk out of the cave."
  170. open isAlreadyOpen
  172. - wallField
  173. description "dense forest all around"
  174. tags "west", "north", "south", "forest"
  175. location field
  176. details "The field is surrounded by trees and undergrowth."
  177. textGo "Dense forest is blocking the way."
  178. gossip "You cannot go there, it is impenetrable."
  180. - wallCave
  181. description "solid rock all around"
  182. tags "east", "north", "rock"
  183. location cave
  184. details "Carved in stone is a secret password 'abccb'."
  185. textGo "Solid rock is blocking the way."
  187. - backroom
  188. description "a backroom"
  189. tags "backroom"
  190. details "The room is dusty and messy."
  191. gossip "There is something of value to be found there."
  192. capacity 9999
  194. - wallBackroom
  195. description "solid rock all around"
  196. tags "east", "west", "south", "rock"
  197. location backroom
  198. details "Trendy wallpaper covers the rock walls."
  199. textGo "Solid rock is blocking the way."
  201. - openDoorToBackroom
  202. description "an open door to the south"
  203. tags "south", "door", "doorway"
  204. destination backroom
  205. details "The door is open."
  206. textGo "You walk through the door into a backroom."
  207. open isAlreadyOpen
  208. close toggleDoorToBackroom
  210. - closedDoorToBackroom
  211. description "a closed door to the south"
  212. tags "south", "door", "doorway"
  213. location cave
  214. prospect backroom
  215. details "The door is closed."
  216. textGo "The door is closed."
  217. open toggleDoorToBackroom
  218. close isAlreadyClosed
  220. - openDoorToCave
  221. description "an open door to the north"
  222. tags "north", "door", "doorway"
  223. destination cave
  224. details "The door is open."
  225. textGo "You walk through the door into the cave."
  226. open isAlreadyOpen
  227. close toggleDoorToCave
  229. - closedDoorToCave
  230. description "a closed door to the north"
  231. tags "north", "door", "doorway"
  232. location backroom
  233. prospect cave
  234. details "The door is closed."
  235. textGo "The door is closed."
  236. open toggleDoorToCave
  237. close isAlreadyClosed
  239. - openBox
  240. description "a wooden box"
  241. tags "box", "wooden box"
  242. details "The box is open."
  243. gossip "You need a key to open it."
  244. weight 5
  245. capacity 10
  246. open isAlreadyOpen
  247. close toggleBox
  248. lock isStillOpen
  249. unlock isAlreadyOpen
  251. - closedBox
  252. description "a wooden box"
  253. tags "box", "wooden box"
  254. details "The box is closed."
  255. weight 5
  256. open toggleBox
  257. close isAlreadyClosed
  258. lock toggleBoxLock
  259. unlock isAlreadyUnlocked
  261. - lockedBox
  262. description "a wooden box"
  263. tags "box", "wooden box"
  264. location backroom
  265. details "The box is closed."
  266. weight 5
  267. open isStillLocked
  268. close isAlreadyClosed
  269. lock isAlreadyLocked
  270. unlock toggleBoxLock
  272. - keyForBox
  273. description "a tiny key"
  274. tags "key", "tiny key"
  275. location cave
  276. details "The key is really small and shiny."
  277. gossip "A small key opens a small lock."
  278. weight 1
  280. - lampOff
  281. description "a lamp"
  282. tags "lamp"
  283. location field
  284. details "The lamp is off."
  285. gossip "Essential in dark areas."
  286. weight 5
  288. - lampOn
  289. description "a lamp"
  290. tags "lamp"
  291. details "The lamp is on."
  292. weight 5
  293. light 100
  295. - club
  296. description "a wooden club"
  297. tags "club", "wooden club"
  298. location field
  299. details "Two feet of solid wood."
  300. weight 5
  301. impact -2
  303. - dagger
  304. description "a dagger"
  305. tags "dagger"
  306. location field
  307. details "The dagger is very sharp."
  308. weight 7
  309. impact -5

Explanation:

Traditionally, descriptive text about the player is always in second person, e.g. “You are in an open field.” But with multiple player characters, that is no longer the case. Second person is still appropriate for the player character that is currently under the user’s control, but any other player characters you meet, should be referenced in third person.

This is already giving trouble in command inventory. The game’s response has always started with “You have”, as specified by attribute contents of the player object. But for Jack and Jill, things are not so straightforward; contents is used not only to inspect yourself (inventory), but also to inspect someone else (e.g. Jill enters: examine Jack).

We will just keep it simple for now: if the object being inspected is currently under the user’s control, then we will output a hardcoded “You have” rather than attribute contents.

misc.c
  1. #include <stdbool.h>
  2. #include <stdio.h>
  3. #include "object.h"
  4. #include "misc.h"
  6. bool isHolding(OBJECT *container, OBJECT *obj)
  7. {
  8. return validObject(obj) && obj->location == container;
  9. }
  11. bool isLit(OBJECT *target)
  12. {
  13. OBJECT *obj;
  14. if (validObject(target))
  15. {
  16. if (target->light > 0)
  17. {
  18. return true;
  19. }
  20. for (obj = objs; obj < endOfObjs; obj++)
  21. {
  22. if (validObject(obj) && obj->light > 0 &&
  23. (isHolding(target, obj) || isHolding(target, obj->location)))
  24. {
  25. return true;
  26. }
  27. }
  28. }
  29. return false;
  30. }
  32. static bool isNoticeable(OBJECT *obj)
  33. {
  34. return obj->location == player ||
  35. isLit(obj) || isLit(obj->prospect) || isLit(player->location);
  36. }
  38. OBJECT *getPassage(OBJECT *from, OBJECT *to)
  39. {
  40. if (from != NULL && to != NULL)
  41. {
  42. OBJECT *obj;
  43. for (obj = objs; obj < endOfObjs; obj++)
  44. {
  45. if (isHolding(from, obj) && obj->prospect == to)
  46. {
  47. return obj;
  48. }
  49. }
  50. }
  51. return NULL;
  52. }
  54. DISTANCE getDistance(OBJECT *from, OBJECT *to)
  55. {
  56. return to == NULL ? distUnknownObject :
  57. !validObject(to) ? distNotHere :
  58. to == from ? distSelf :
  59. isHolding(from, to) ? distHeld :
  60. !isNoticeable(to) ? distNotHere :
  61. isHolding(to, from) ? distLocation :
  62. isHolding(from->location, to) ? distHere :
  63. isHolding(from, to->location) ? distHeldContained :
  64. isHolding(from->location, to->location) ? distHereContained :
  65. getPassage(from->location, to) != NULL ? distOverthere :
  66. distNotHere;
  67. }
  69. OBJECT *actorHere(void)
  70. {
  71. OBJECT *obj;
  72. for (obj = objs; obj < endOfObjs; obj++)
  73. {
  74. if (isHolding(player->location, obj) && obj != player &&
  75. isNoticeable(obj) && obj->health > 0)
  76. {
  77. return obj;
  78. }
  79. }
  80. return NULL;
  81. }
  83. int listObjectsAtLocation(OBJECT *location)
  84. {
  85. int count = 0;
  86. OBJECT *obj;
  87. for (obj = objs; obj < endOfObjs; obj++)
  88. {
  89. if (obj != player && isHolding(location, obj) && isNoticeable(obj))
  90. {
  91. if (count++ == 0)
  92. {
  93. printf("%s:\n", location == player ? "You have"
  94. : location->contents);
  95. }
  96. printf("%s\n", obj->description);
  97. }
  98. }
  99. return count;
  100. }

This was all fairly simple; it did not require a whole lot of source changes. In the next chapter, we will be writing a lot more code, as we are diving into the wonderful world of socket programming.

⭳   Download source code 🌀   Run on Repl.it

Next chapter: 22. Client-server