* Supporting a new game, that Otter doesn't know about yet, would
usually not involve writing or modifying any computer programs.
- * If Otter already has the necessarily game elements (cards, say) all
+ * If Otter already has the necessary game elements (cards, say) all
you need to do is write a spec file saying what should be on the
table at the start of the game. For example, most Whist variants
that start with a standard pack of 52 cards are already playable.
you play. Otter works well when used together with a voice chat - we
have had success with Jitsi in voice-only mode.
-Most relatively modern desktop browsers should to work with Otter.
+Most relatively modern desktop browsers should be able to work with Otter.
(The most advanced feature needed is support for WebAssembly.)
mention above, and to improve the user experience.
I am also working to make it possible to let users define their own
-games (including thier own pieces, cards, boards, and so on) without
+games (including their own pieces, cards, boards, and so on) without
having to install them on the server.
The Otter software project is hosted on Debian's GitLab, at
Adding pieces to a game in progress
-----------------------------------
-Use the `otter library-list` and `otter library-add` commands, you can
+Using the `otter library-list` and `otter library-add` commands, you can
add pieces to a game while it is in progress.
You may want to refer to the shape library preview ("Shapelib" link in
rustup default nightly
rustup target add wasm32-unknown-unknown
- Unfortunately, it is possible that the Rust nightly you find when
+ Unfortunately, it is possible that the Rust Nightly you find when
you run this is missing some pieces. The following is known to
work (with otter from the time of writing)::
for the same purpose, called "Marionette". (In practice all this
seems to have lots of bugs and misfeatures.)
-AFAICT the usual approach for using geckodriver to have it *bind to
+AFAICT the usual approach for using geckodriver is to have it *bind to
a fixed TCP port accessible to all local programs*. My wrapper
tooling arranges to run this in an ephemeral $HOME and a private
network namespace.
After the server is updated, you can just `^C` and restart it. Games
are constantly saved (although there is an up-to-1s lag on the most
-frequently udpated game state).
+frequently updated game state).
If you want to clear out the server state, delete the files `[ag]-*`
and `accounts`. NB that you should do this with the server not
LICENCE.
If you Do Something to the output from cargo, you should `rm stamp/*`,
-since the `Makefile` won't notice, otherwise, that, the relevant cargo
+since the `Makefile` won't notice, otherwise, that the relevant cargo
rune(s) need to be re-run. Needlessly deleting all the stamp files
wastes only a handful of seconds (on my stupidly fast laptop).
-Deleting the xtamp files is not needed if you simpl edit Rust source
+Deleting the xtamp files is not needed if you simply edit Rust source
files.
* `daemon/`
The Otter server. This is a simple binary crate. Much
- functionality belonging primarily, or only, to the server, is in
+ functionality belonging primarily, or only, to the server is in
`src/`, simply because it was easier not to disentangle it.
Anything that needs Rocket (the web framework) is in `daemon/`.
Code shared by the host and the WebAssembly. Notably, the Z
coordinate handling, but also a a few other minor functions needed
- by both client and server. To avoid duplicating them are written
+ by both client and server. To avoid duplicating they are written
once in Rust and compiled twice - once for the host and once for
WebAssembly for use in the client. This crate is kept fairly small
to keeep the WebAssembly binary small (currently, ~100kby).
* `nwtemplates/`
- "Non-web templataes". Tera templates for things other than web
+ "Non-web templates". Tera templates for things other than web
pages. Currently this includes the server's outgoing emails. These
have to be in a separate directory because Tera (invoked by Rocket)
likes to load everything applicable it finds in its own `templates/`
The program `./media-scraper` (which is not run by the `Makefile`)
reads `library/*.toml` for instructions and generates `files.make`
fragments. These fragments arrange to run `./usvg-processor` which
- launders SVGs through `usvg`. `usvg-processor`.
+ launders SVGs through `usvg`.
The shape libraries have a different, more relaxed, copyright
licence.
http://localhost:8000/?ccg9kzoTh758QrVE1xMY7BQWB36dNJTx
```
-(Yes, those are a fixed game access links, hardcoded by the tests.
+(Yes, those are fixed game access links, hardcoded by the tests.
You can bookmark them.)
doc" for the type `otter::config::ServerConfigSpec`, which is probably
in `target/doc/otter/config/struct.ServerConfigSpec.html`.
-Here a copy of the config file from chiark. As you can see I am
+Here is a copy of the config file from chiark. As you can see I am
running Otter as an "application server". My usual Apache
configuration handles the TLS. (Rocket's TLS is not advertised as
being suitable for production use.)
game owner game name
```
-Tbis will print a URL. You cut and paste that URL into your browser.
-It is not usually necessary to expliitly leave a game, although
+This will print a URL. You cut and paste that URL into your browser.
+It is not usually necessary to explicitly leave a game, although
a `leave-game` subcommand is available.
You can have the same URL open in multiple browsers if you wish. The
Otter makes use of keyboard commands for many functions. The UI will
display a list of the currently-valid keyboard commands. Note that
-the set of valid command can depend on what you have selected, and
+the set of valid commands can depend on what you have selected, and
what state it is in.
The UI has a number of features intended to ease play of various
games. It can be worth experimenting with the UI in a test game, to
-see how things work. The information presented by the game interfae
+see how things work. The information presented by the game interface
itself is meant as prompts and hints rather than full documentation.
Notable features you might otherwise overlook include these:
-Pressuing "h" repeatedly cycles through various amounts of history
+Pressing "h" repeatedly cycles through various amounts of history
view (the overlaid yellow arrows showing what recently happened).
Typing numbers will get you into a multiple selection mode, which you
the game.
`demo` refers to the file `demo.game.spec`. The "game spec" says what
-shape table is and what pieces there are. This is a simple demo game.
+shape the table is and what pieces there are. This is a simple demo game.
Currently there are also `penultima` and `mao` game specs.
-After a game has finished and you wnat to play again, you can put
+After a game has finished and you want to play again, you can put
everything back to the starting state (or, even, the starting state
for a different game) with something like this:
~ianmdlvl / otter.git / commitdiff