Annikka/evennia
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Change to MyST parser

Browse source
This commit is contained in:
Griatch 2021-10-21 21:04:14 +02:00
parent 53106e1dba
commit a51e4af609
443 changed files with 4925 additions and 3524 deletions
Download patch file Download diff file Expand all files Collapse all files

4
docs/source/Concepts/Async-Process.md
View file

@ -90,7 +90,7 @@ line quite pointless for processing any data from the function. Instead one has
- `at_err_kwargs` - an optional dictionary that will be fed as keyword arguments to the `at_err`
errback.
An example of making an asynchronous call from inside a [Command](../Components/Commands) definition:
An example of making an asynchronous call from inside a [Command](../Components/Commands.md) definition:
```python
from evennia import utils, Command
@ -139,7 +139,7 @@ sleep.
```
This will delay the execution of the callback for 10 seconds. This function is explored much more in
the [Command Duration Tutorial](../Howto/Command-Duration).
the [Command Duration Tutorial](../Howto/Command-Duration.md).
You can also try the following snippet just see how it works:

4
docs/source/Concepts/Banning.md
View file

@ -114,14 +114,14 @@ is not what you want in this case.
- **cboot mychannel = thomas** -- Boot a subscriber from a channel you control
- **clock mychannel = control:perm(Admin);listen:all();send:all()** -- Fine control of access to
your channel using [lock definitions](../Components/Locks).
your channel using [lock definitions](../Components/Locks.md).
Locking a specific command (like `page`) is accomplished like so:
1. Examine the source of the command. [The default `page` command class](
https://github.com/evennia/evennia/blob/master/evennia/commands/default/comms.py#L686) has the lock
string **"cmd:not pperm(page_banned)"**. This means that unless the player has the 'permission'
"page_banned" they can use this command. You can assign any lock string to allow finer customization
in your commands. You might look for the value of an [Attribute](../Components/Attributes) or [Tag](../Components/Tags), your
in your commands. You might look for the value of an [Attribute](../Components/Attributes.md) or [Tag](../Components/Tags.md), your
current location etc.
2. **perm/account thomas = page_banned** -- Give the account the 'permission' which causes (in this
case) the lock to fail.

4
docs/source/Concepts/Building-Permissions.md
View file

@ -2,7 +2,7 @@
*OBS: This gives only a brief introduction to the access system. Locks and permissions are fully
detailed* [here](../Components/Locks).
detailed* [here](../Components/Locks.md).
## The super user
@ -17,7 +17,7 @@ but one superuser.
Whereas permissions can be used for anything, those put in `settings.PERMISSION_HIERARCHY` will have
a ranking relative each other as well. We refer to these types of permissions as *hierarchical
permissions*. When building locks to check these permissions, the `perm()` [lock function](../Components/Locks) is
permissions*. When building locks to check these permissions, the `perm()` [lock function](../Components/Locks.md) is
used. By default Evennia creates the following hierarchy (spelled exactly like this):
1. **Developers** basically have the same access as superusers except that they do *not* sidestep

6
docs/source/Concepts/Clickable-Links.md
View file

@ -1,8 +1,8 @@
## Clickable links
# Clickable links
Evennia supports clickable links for clients that supports it. This marks certain text so it can be
clicked by a mouse and either trigger a given Evennia command, or open a URL in an external web
browser. To support clickable links, Evennia requires the webclient or an third-party telnet client
clicked by a mouse and either trigger a given Evennia command, or open a URL in an external web
browser. To support clickable links, Evennia requires the webclient or an third-party telnet client
with [MXP](http://www.zuggsoft.com/zmud/mxp.htm) support (*Note: Evennia only supports clickable links, no other MXP features*).
- `|lc` to start the link, by defining the command to execute.

32
docs/source/Concepts/Colors.md
View file

@ -1,7 +1,7 @@
# Colors
*Note that the Documentation does not display colour the way it would look on the screen.*
Color can be a very useful tool for your game. It can be used to increase readability and make your
game more appealing visually.
@ -14,13 +14,13 @@ equipment by people who are blind or have otherwise diminished eyesight.
So a good rule of thumb is to use colour to enhance your game but don't *rely* on it to display
critical information. If you are coding the game, you can add functionality to let users disable
colours as they please, as described [here](../Howto/Manually-Configuring-Color).
colours as they please, as described [here](../Howto/Manually-Configuring-Color.md).
To see which colours your client support, use the default `@color` command. This will list all
available colours for ANSI and Xterm256 along with the codes you use for them. You can find a list
of all the parsed `ANSI`-colour codes in `evennia/utils/ansi.py`.
### ANSI colours
## ANSI colours
Evennia supports the `ANSI` standard for text. This is by far the most supported MUD-color standard,
available in all but the most ancient mud clients. The ANSI colours are **r**ed, **g**reen,
@ -28,7 +28,7 @@ available in all but the most ancient mud clients. The ANSI colours are **r**ed,
first letter except for black which is abbreviated with the letter **x**. In ANSI there are "bright"
and "normal" (darker) versions of each color, adding up to a total of 16 colours to use for
foreground text. There are also 8 "background" colours. These have no bright alternative in ANSI
(but Evennia uses the [Xterm256](./TextTags#xterm256-colours) extension behind the scenes to offer
(but Evennia uses the [Xterm256](#xterm256-colours) extension behind the scenes to offer
them anyway).
To colour your text you put special tags in it. Evennia will parse these and convert them to the
@ -37,7 +37,7 @@ will see the text in the specified colour, otherwise the tags will be stripped (
This works also for non-terminal clients, such as the webclient. For the webclient, Evennia will
translate the codes to HTML RGB colors.
Here is an example of the tags in action:
Here is an example of the tags in action:
|rThis text is bright red.|n This is normal text.
|RThis is a dark red text.|n This is normal text.
@ -49,9 +49,9 @@ Here is an example of the tags in action:
"normal". So `|g` is a bright green and `|G` is "normal" (darker) green.
- `|[#` is used to add a background colour to the text. The case again specifies if it is "bright"
or "normal", so `|[c` starts a bright cyan background and `|[C` a darker cyan background.
- `|!#` is used to add foreground color without any enforced brightness/normal information.
These are normal-intensity and are thus always given as uppercase, such as
`|!R` for red. The difference between e.g. `|!R` and `|R` is that
- `|!#` is used to add foreground color without any enforced brightness/normal information.
These are normal-intensity and are thus always given as uppercase, such as
`|!R` for red. The difference between e.g. `|!R` and `|R` is that
`|!R` will "inherit" the brightness setting from previously set color tags, whereas `|R` will
always reset to the normal-intensity red. The `|#` format contains an implicit `|h`/`|H` tag in it:
disabling highlighting when switching to a normal color, and enabling it for bright ones. So `|btest
@ -67,7 +67,7 @@ set bright/normal explicitly. Technically, `|h|!G` is identical to `|g`.
> Note: The ANSI standard does not actually support bright backgrounds like `|[r` - the standard
only supports "normal" intensity backgrounds. To get around this Evennia instead implements these
as [Xterm256 colours](./TextTags#xterm256-colours) behind the scenes. If the client does not support
as [Xterm256 colours](#xterm256-colours) behind the scenes. If the client does not support
Xterm256 the ANSI colors will be used instead and there will be no visible difference between using
upper- and lower-case background tags.
@ -83,11 +83,11 @@ ansi art that uses `|` with a letter directly following it.
Use the command
@color ansi
@color ansi
to get a list of all supported ANSI colours and the tags used to produce them.
A few additional ANSI codes are supported:
A few additional ANSI codes are supported:
- `|/` A line break. You cannot put the normal Python `\n` line breaks in text entered inside the
game (Evennia will filter this for security reasons). This is what you use instead: use the `|/`
@ -100,7 +100,7 @@ space.
- `|*` This will invert the current text/background colours. Can be useful to mark things (but see
below).
##### Caveats of `|*`
### Caveats of `|*`
The `|*` tag (inverse video) is an old ANSI standard and should usually not be used for more than to
mark short snippets of text. If combined with other tags it comes with a series of potentially
@ -113,11 +113,11 @@ until you declare another tag. This is an example:
Normal text, |*reversed text|*, still reversed text.
```
that is, it will not reverse to normal at the second `|*`. You need to reset it manually:
that is, it will not reverse to normal at the second `|*`. You need to reset it manually:
```
Normal text, |*reversed text|n, normal again.
```
```
* The `|*` tag does not take "bright" colors into account:
@ -167,7 +167,7 @@ four gray tones between solid black and white (`|000`, `|111`, `|222`, `|333` an
- `|[=#` - this works in the same way but produces background gray scale tones.
If you have a client that supports Xterm256, you can use
@color xterm256
to get a table of all the 256 colours and the codes that produce them. If the table looks broken up
@ -178,6 +178,6 @@ to activate some features manually.
## More reading
There is an [Understanding Color Tags](../Howto/Understanding-Color-Tags) tutorial which expands on the
There is an [Understanding Color Tags](../Howto/Understanding-Color-Tags.md) tutorial which expands on the
use of ANSI color tags and the pitfalls of mixing ANSI and Xterms256 color tags in the same context.

28
docs/source/Concepts/Concepts-Overview.md
View file

@ -1,30 +1,30 @@
# Core Concepts
This documentation cover more over-arching concepts of Evennia, often involving many [Core Components](../Components/Components-Overview) acting together.
This documentation cover more over-arching concepts of Evennia, often involving many [Core Components](../Components/Components-Overview.md) acting together.
## General concepts
- [Asynchronous processing](./Async-Process)
- [On Soft-Code](./Soft-Code)
- [Using MUX as standard for default commands](./Using-MUX-as-a-Standard)
- [Asynchronous processing](./Async-Process.md)
- [On Soft-Code](./Soft-Code.md)
- [Using MUX as standard for default commands](./Using-MUX-as-a-Standard.md)
## Access
- [Multisession modes](./Multisession-modes)
- [Permissions](./Building-Permissions)
- [Banning](./Banning)
- [Multisession modes](./Multisession-modes.md)
- [Permissions](./Building-Permissions.md)
- [Banning](./Banning.md)
## Extending the Server
- [Custom Protocols](./Custom-Protocols)
- [Bootstrap](./Bootstrap-&-Evennia)
- [Creating new models](./New-Models)
- [Custom Protocols](./Custom-Protocols.md)
- [Bootstrap](./Bootstrap-&-Evennia.md)
- [Creating new models](./New-Models.md)
## Text processing
- [Change the language of the server](./Internationalization)
- [Server text-encoding](./Text-Encodings)
- [Text tags](./TextTags)
- [Change the language of the server](./Internationalization.md)
- [Server text-encoding](./Text-Encodings.md)
- [Text tags](./TextTags.md)
## Web features
- [Web features](./Web-Features)
- [Web features](./Web-Features.md)

10
docs/source/Concepts/Custom-Protocols.md
View file

@ -5,9 +5,9 @@
their own custom client protocol.*
A [PortalSession](../Components/Sessions#Portal-and-Server-Sessions) is the basic data object representing an
A [PortalSession](../Components/Sessions.md#portal-and-server-sessions) is the basic data object representing an
external
connection to the Evennia [Portal](../Components/Portal-And-Server) -- usually a human player running a mud client
connection to the Evennia [Portal](../Components/Portal-And-Server.md) -- usually a human player running a mud client
of some kind. The way they connect (the language the player's client and Evennia use to talk to
each other) is called the connection *Protocol*. The most common such protocol for MUD:s is the
*Telnet* protocol. All Portal Sessions are stored and managed by the Portal's *sessionhandler*.
@ -27,7 +27,7 @@ You <->
InputFunc
```
(See the [Message Path](./Messagepath) for the bigger picture of how data flows through Evennia). The
(See the [Message Path](./Messagepath.md) for the bigger picture of how data flows through Evennia). The
parts that needs to be customized to make your own custom protocol is the `Protocol + PortalSession`
(which translates between data coming in/out over the wire to/from Evennia internal representation)
as well as the `InputFunc` (which handles incoming data).
@ -219,11 +219,11 @@ in our case means sending "foo" across the network.
### Receiving data
Just because the protocol is there, does not mean Evennia knows what to do with it. An
[Inputfunc](../Components/Inputfuncs) must exist to receive it. In the case of the `text` input exemplified above,
[Inputfunc](../Components/Inputfuncs.md) must exist to receive it. In the case of the `text` input exemplified above,
Evennia alredy handles this input - it will parse it as a Command name followed by its inputs. So
handle that you need to simply add a cmdset with commands on your receiving Session (and/or the
Object/Character it is puppeting). If not you may need to add your own Inputfunc (see the
[Inputfunc](../Components/Inputfuncs) page for how to do this.
[Inputfunc](../Components/Inputfuncs.md) page for how to do this.
These might not be as clear-cut in all protocols, but the principle is there. These four basic
components - however they are accessed - links to the *Portal Session*, which is the actual common

6
docs/source/Concepts/Guest-Logins.md
View file

@ -10,16 +10,16 @@ Guest accounts are turned off by default. To activate, add this to your `game/se
GUEST_ENABLED = True
Henceforth users can use `connect guest` (in the default command set) to login with a guest account.
You may need to change your [Connection Screen](../Components/Connection-Screen) to inform them of this
You may need to change your [Connection Screen](../Components/Connection-Screen.md) to inform them of this
possibility. Guest accounts work differently from normal accounts - they are automatically *deleted*
whenever the user logs off or the server resets (but not during a reload). They are literally re-
usable throw-away accounts.
You can add a few more variables to your `settings.py` file to customize your guests:
- `BASE_GUEST_TYPECLASS` - the python-path to the default [typeclass](../Components/Typeclasses) for guests.
- `BASE_GUEST_TYPECLASS` - the python-path to the default [typeclass](../Components/Typeclasses.md) for guests.
Defaults to `"typeclasses.accounts.Guest"`.
- `PERMISSION_GUEST_DEFAULT` - [permission level](../Components/Locks) for guest accounts. Defaults to `"Guests"`,
- `PERMISSION_GUEST_DEFAULT` - [permission level](../Components/Locks.md) for guest accounts. Defaults to `"Guests"`,
which is the lowest permission level in the hierarchy.
- `GUEST_START_LOCATION` - the `#dbref` to the starting location newly logged-in guests should
appear at. Defaults to `"#2` (Limbo).

8
docs/source/Concepts/Internationalization.md
View file

@ -10,7 +10,7 @@ depending on when a given language was last updated. Below are all languages
(besides English) with some level of support. Generally, any language not
updated after May 2021 will be missing some translations.
```eval_rst
```{eval-rst}
+---------------+----------------------+--------------+
| Language Code | Language | Last updated |
@ -56,7 +56,7 @@ Here `'en'` (the default English) should be changed to the abbreviation for one
of the supported languages found in `locale/` (and in the list above). Restart
the server to activate i18n.
```important::
```{important}
Even for a 'fully translated' language you will still see English text
in many places when you start Evennia. This is because we expect you (the
@ -67,7 +67,7 @@ the server to activate i18n.
```
```sidebar:: Windows users
```{sidebar} Windows users
If you get errors concerning `gettext` or `xgettext` on Windows,
see the `Django documentation <https://docs.djangoproject.com/en/3.2/topics/i18n/translation/#gettext-on-windows>`_
@ -88,7 +88,7 @@ translation bad ... You are welcome to help improve the situation!
To start a new translation you need to first have cloned the Evennia repositry
with GIT and activated a python virtualenv as described on the
[Setup Quickstart](../Setup/Setup-Quickstart) page.
[Setup Quickstart](../Setup/Setup-Quickstart.md) page.
Go to `evennia/evennia/` - that is, not your game dir, but inside the `evennia/`
repo itself. If you see the `locale/` folder you are in the right place. Make

10
docs/source/Concepts/Messagepath.md
View file

@ -25,7 +25,7 @@ The client sends data to Evennia in two ways.
- When first connecting, the client can send data to the server about its
capabilities. This is things like "I support xterm256 but not unicode" and is
mainly used when a Telnet client connects. This is called a "handshake" and
will generally set some flags on the [Portal Session](../Components/Portal-And-Server) that
will generally set some flags on the [Portal Session](../Components/Portal-And-Server.md) that
are later synced to the Server Session. Since this is not something the player
controls, we'll not explore this further here.
- The client can send an *inputcommand* to the server. Traditionally this only
@ -34,7 +34,7 @@ The client sends data to Evennia in two ways.
the client may send commands based on a timer or some trigger.
Exactly how the inputcommand looks when it travels from the client to Evennia
depends on the [Protocol](./Custom-Protocols) used:
depends on the [Protocol](./Custom-Protocols.md) used:
- Telnet: A string. If GMCP or MSDP OOB protocols are used, this string will
be formatted in a special way, but it's still a raw string. If Telnet SSL is
active, the string will be encrypted.
@ -73,7 +73,7 @@ it belongs. This is then sent over the AMP connection.
### ServerSessionHandler (ingoing)
On the Server side, the AMP unpickles the data and associates the session id with the server-side
[Session](../Components/Sessions). Data and Session are passed to the server-side `SessionHandler.data_in`. This
[Session](../Components/Sessions.md). Data and Session are passed to the server-side `SessionHandler.data_in`. This
in turn calls `ServerSession.data_in()`
### ServerSession (ingoing)
@ -101,7 +101,7 @@ not found, an error will be raised.
### Inputfunc
The [Inputfunc](../Components/Inputfuncs) must be on the form `func(session, *args, **kwargs)`. An exception is
The [Inputfunc](../Components/Inputfuncs.md) must be on the form `func(session, *args, **kwargs)`. An exception is
the `default` inputfunc which has form `default(session, cmdname, *args, **kwargs)`, where `cmdname`
is the un-matched inputcommand string.
@ -175,7 +175,7 @@ In the *ServerSessionhandler*, the keywords from the `msg` method are collated i
This will intelligently convert different input to the same form. So `msg("Hello")` will end up as
an outputcommand `("text", ("Hello",), {})`.
This is also the point where [Inlinefuncs](./TextTags#inline-functions) are parsed, depending on the
This is also the point where the [FuncParser](../Components/FuncParser.md)) is applied, depending on the
session to receive the data. Said data is pickled together with the Session id then sent over the
AMP bridge.

6
docs/source/Concepts/New-Models.md
View file

@ -7,7 +7,7 @@ sufficient for most use cases. But if you aim to build a large stand-alone syste
your storage requirements into those may be more complex than you bargain for. Examples may be to
store guild data for guild members to be able to change, tracking the flow of money across a game-
wide economic system or implement other custom game systems that requires the storage of custom data
in a quickly accessible way. Whereas [Tags](../Components/Tags) or [Scripts](../Components/Scripts) can handle many situations,
in a quickly accessible way. Whereas [Tags](../Components/Tags.md) or [Scripts](../Components/Scripts.md) can handle many situations,
sometimes things may be easier to handle by adding your own database model.
## Overview of database tables
@ -81,7 +81,7 @@ you put `myapp` and don't forget the comma at the end of the tuple):
evennia migrate
This will add your new database table to the database. If you have put your game under version
control (if not, [you should](../Coding/Version-Control)), don't forget to `git add myapp/*` to add all items
control (if not, [you should](../Coding/Version-Control.md)), don't forget to `git add myapp/*` to add all items
to version control.
## Defining your models
@ -113,7 +113,7 @@ We create four fields: two character fields of limited length and one text field
maximum length. Finally we create a field containing the current time of us creating this object.
> The `db_date_created` field, with exactly this name, is *required* if you want to be able to store
instances of your custom model in an Evennia [Attribute](../Components/Attributes). It will automatically be set
instances of your custom model in an Evennia [Attribute](../Components/Attributes.md). It will automatically be set
upon creation and can after that not be changed. Having this field will allow you to do e.g.
`obj.db.myinstance = mydatastore`. If you know you'll never store your model instances in Attributes
the `db_date_created` field is optional.

27
docs/source/Concepts/OOB.md
View file

@ -8,7 +8,7 @@ window pane.
## Briefly on input/outputcommands
Inside Evennia, all server-client communication happens in the same way (so plain text is also an
'OOB message' as far as Evennia is concerned). The message follows the [Message Path](./Messagepath).
'OOB message' as far as Evennia is concerned). The message follows the [Message Path](./Messagepath.md).
You should read up on that if you are unfamiliar with it. As the message travels along the path it
has a standardized internal form: a tuple with a string, a tuple and a dict:
@ -16,9 +16,9 @@ has a standardized internal form: a tuple with a string, a tuple and a dict:
This is often referred to as an *inputcommand* or *outputcommand*, depending on the direction it's
traveling. The end point for an inputcommand, (the 'Evennia-end' of the message path) is a matching
[Inputfunc](../Components/Inputfuncs). This function is called as `cmdname(session, *args, **kwargs)` where
[Inputfunc](../Components/Inputfuncs.md). This function is called as `cmdname(session, *args, **kwargs)` where
`session` is the Session-source of the command. Inputfuncs can easily be added by the developer to
support/map client commands to actions inside Evennia (see the [inputfunc](../Components/Inputfuncs) page for more
support/map client commands to actions inside Evennia (see the [inputfunc](../Components/Inputfuncs.md) page for more
details).
When a message is outgoing (at the 'Client-end' of the message path) the outputcommand is handled by
@ -26,7 +26,7 @@ a matching *Outputfunc*. This is responsible for converting the internal Evennia
form suitable to send over the wire to the Client. Outputfuncs are hard-coded. Which is chosen and
how it processes the outgoing data depends on the nature of the client it's connected to. The only
time one would want to add new outputfuncs is as part of developing support for a new Evennia
[Protocol](./Custom-Protocols).
[Protocol](./Custom-Protocols.md).
## Sending and receiving an OOB message
@ -59,12 +59,12 @@ drop any other types of outputfuncs.
you turn off telnet completely and only rely on the webclient, you should never rely on non-`text`
OOB messages always reaching all targets.
[Inputfuncs](../Components/Inputfuncs) lists the default inputfuncs available to handle incoming OOB messages. To
[Inputfuncs](../Components/Inputfuncs.md) lists the default inputfuncs available to handle incoming OOB messages. To
accept more you need to add more inputfuncs (see that page for more info).
## Supported OOB protocols
Evennia supports clients using one of the following protocols:
Evennia supports clients using one of the following protocols:
### Telnet
@ -96,7 +96,7 @@ come `foo_bar`. To send a GMCP command that turns into an Evennia inputcommand w
underscore, use the `Core` package. So `Core.Cmdname` becomes just `cmdname` in Evennia and vice
versa.
On the wire, a GMCP instruction for `("cmdname", ("arg",), {})` will look like this:
On the wire, a GMCP instruction for `("cmdname", ("arg",), {})` will look like this:
IAC SB GMCP "cmdname" "arg" IAC SE
@ -105,7 +105,6 @@ where all the capitalized words are telnet character constants specified in
these in the listings below.
Input/Outputfunc | GMCP-Command
------------------
`[cmd_name, [], {}]` | Cmd.Name
`[cmd_name, [arg], {}]` | Cmd.Name arg
`[cmd_na_me, [args],{}]` | Cmd.Na.Me [args]
@ -116,15 +115,14 @@ Since Evennia already supplies default inputfuncs that don't match the names exp
common GMCP implementations we have a few hard-coded mappings for those:
GMCP command name | Input/Outputfunc name
-----------------
"Core.Hello" | "client_options"
"Core.Supports.Get" | "client_options"
"Core.Commands.Get" | "get_inputfuncs"
"Core.Hello" | "client_options"
"Core.Supports.Get" | "client_options"
"Core.Commands.Get" | "get_inputfuncs"
"Char.Value.Get" | "get_value"
"Char.Repeat.Update" | "repeat"
"Char.Monitor.Update" | "monitor"
#### Telnet + MSDP
#### Telnet + MSDP
[MSDP](http://tintin.sourceforge.net/msdp/), the *Mud Server Data Protocol*, is a competing standard
to GMCP. The MSDP protocol page specifies a range of "recommended" available MSDP command names.
@ -143,7 +141,6 @@ The various available MSDP constants like `VAR` (variable), `VAL` (value), `ARRA
and `TABLEOPEN`/`TABLECLOSE` are specified in `evennia/server/portal/telnet_oob`.
Outputfunc/Inputfunc | MSDP instruction
-------------------------
`[cmdname, [], {}]` | VAR cmdname VAL
`[cmdname, [arg], {}]` | VAR cmdname VAL arg
`[cmdname, [args],{}]` | VAR cmdname VAL ARRAYOPEN VAL arg VAL arg ... ARRAYCLOSE
@ -157,7 +154,7 @@ different `VAR ... VAL` (outside a table) will come out as a second, different c
### SSH
SSH only supports the `text` input/outputcommand.
SSH only supports the `text` input/outputcommand.
### Web client

2
docs/source/Concepts/Soft-Code.md
View file

@ -90,5 +90,5 @@ Adding advanced and flexible building commands to your game is easy and will pro
satisfy most creative builders. However, if you really, *really* want to offer online coding, there
is of course nothing stopping you from adding that to Evennia, no matter our recommendations. You
could even re-implement MUX' softcode in Python should you be very ambitious. The
[in-game-python](../Contribs/Dialogues-in-events) is an optional
[in-game-python](../Contribs/Dialogues-in-events.md) is an optional
pseudo-softcode plugin aimed at developers wanting to script their game from inside it.

15
docs/source/Concepts/TextTags.md
View file

@ -2,18 +2,19 @@
Evennia understands various extra information embedded in text:
- [Colors](./Colors) - Using `|r`, `|n` etc can be used to mark parts of text with a color. The color will
- [Colors](./Colors.md) - Using `|r`, `|n` etc can be used to mark parts of text with a color. The color will
become ANSI/XTerm256 color tags for Telnet connections and CSS information for the webclient.
- [Clickable links](./Clickable-Links) - This allows you to provide a text the user can click to execute an
- [Clickable links](./Clickable-Links.md) - This allows you to provide a text the user can click to execute an
in-game command. This is on the form `|lc command |lt text |le`.
- [FuncParser callables](../Components/FuncParser) - These are full-fledged function calls on the form `$funcname(args, kwargs)`
- [FuncParser callables](../Components/FuncParser.md) - These are full-fledged function calls on the form `$funcname(args, kwargs)`
that lead to calls to Python functions. The parser can be run with different available callables in different
circumstances. The parser is run on all outgoing messages if `settings.FUNCPARSER_PARSE_OUTGOING_MESSAGES_ENABLED=True`
(disabled by default).
```toctree::
```{toctree}
:hidden"
Colors.md
Clickable-Links.md
../Components/FuncParser.md
Colors.md
Clickable-Links.md
../Components/FuncParser.md
```

2
docs/source/Concepts/Using-MUX-as-a-Standard.md
View file

@ -13,7 +13,7 @@ sets for administration and building.
Evennia is *not* a MUX system though. It works very differently in many ways. For example, Evennia
deliberately lacks an online softcode language (a policy explained on our [softcode policy
page](Soft-Code)). Evennia also does not shy from using its own syntax when deemed appropriate: the
page](./Soft-Code.md)). Evennia also does not shy from using its own syntax when deemed appropriate: the
MUX syntax has grown organically over a long time and is, frankly, rather arcane in places. All in
all the default command syntax should at most be referred to as "MUX-like" or "MUX-inspired".

4
docs/source/Concepts/Web-Features.md
View file

@ -42,7 +42,7 @@ Example: To override or modify `evennia/web/website/template/website/index.html`
add/modify `mygame/web/template_overrides/website/index.html`.
The detailed description on how to customize the website is best described in tutorial form. See the
[Web Tutorial](../Howto/Starting/Part5/Web-Tutorial) for more information.
[Web Tutorial](../Howto/Starting/Part5/Web-Tutorial.md) for more information.
### Overloading Django views
@ -103,7 +103,7 @@ you will also log all requests in `mygame/server/logs/http_requests.log`.
Evennia comes with a MUD client accessible from a normal web browser. During
development you can try it at `http://localhost:4001/webclient`.
[See the Webclient page](../Components/Webclient) for more details.
[See the Webclient page](../Components/Webclient.md) for more details.
## The Django 'Admin' Page

4
docs/source/Concepts/Zones.md
View file

@ -23,7 +23,7 @@ Many MUD codebases hardcode zones as part of the engine and database. Evennia d
distinction due to the fact that rooms themselves are meant to be customized to any level anyway.
Below is a suggestion for how to implement zones in Evennia.
All objects in Evennia can hold any number of [Tags](../Components/Tags). Tags are short labels that you attach to
All objects in Evennia can hold any number of [Tags](../Components/Tags.md). Tags are short labels that you attach to
objects. They make it very easy to retrieve groups of objects. An object can have any number of
different tags. So let's attach the relevant tag to our forest:
@ -47,7 +47,7 @@ Henceforth you can then easily retrieve only objects with a given tag:
The tagging or aliasing systems above don't instill any sort of functional difference between a
magical forest room and a normal one - they are just arbitrary ways to mark objects for quick
retrieval later. Any functional differences must be expressed using [Typeclasses](../Components/Typeclasses).
retrieval later. Any functional differences must be expressed using [Typeclasses](../Components/Typeclasses.md).
Of course, an alternative way to implement zones themselves is to have all rooms/objects in a zone
inherit from a given typeclass parent - and then limit your searches to objects inheriting from that