Doc refactor/renaming

docs/source/Coding/Coding-Introduction.md

@@ -39,7 +39,7 @@ available at the top level of Evennia's  "flat API". See the [flat API](../Evenn
 info on how to explore it efficiently.
 
 You can complement your exploration by peeking at the sections of the much more detailed 
-[Evennia Component overview](../Component/Component-Overview). The [Tutorials](../Howto/Howto-Overview) section also contains a growing collection
+[Evennia Component overview](../Components/Components-Overview). The [Tutorials](../Howto/Howto-Overview) section also contains a growing collection
 of system- or implementation-specific help.
 
 ### Use a python syntax checker

docs/source/Coding/Quirks.md

@@ -64,7 +64,7 @@ update the database you'd need to explicitly re-assign the updated data to the `
 
 ### Commands are matched by name *or* alias
 
-When merging [command sets](../Component/Commands) it's important to remember that command objects are identified
+When merging [command sets](../Components/Commands) it's important to remember that command objects are identified
 *both* by key *or* alias. So if you have a command with a key `look` and an alias `ls`, introducing
 another command with a key `ls` will be assumed by the system to be *identical* to the first one.
 This usually means merging cmdsets will overload one of them depending on priority. Whereas this is

docs/source/Coding/Unit-Testing.md

@@ -153,7 +153,7 @@ class in the same module to get access to the command-specific utilities mention
 ### Unit testing contribs with custom models
 
 A special case is if you were to create a contribution to go to the `evennia/contrib` folder that
-uses its [own database models](../Concept/New-Models). The problem with this is that Evennia (and Django) will
+uses its [own database models](../Concepts/New-Models). The problem with this is that Evennia (and Django) will
 only recognize models in `settings.INSTALLED_APPS`. If a user wants to use your contrib, they will
 be required to add your models to their settings file. But since contribs are optional you cannot
 add the model to Evennia's central `settings_default.py` file - this would always create your

docs/source/Components/Batch-Processors.md

@@ -73,7 +73,7 @@ need to add the editor's encoding to Evennia's `ENCODINGS` list. If you are unsu
 file with lots of non-ASCII letters in the editor of your choice, then import to make sure it works
 as it should.
 
-More help with encodings can be found in the entry [Text Encodings](../Concept/Text-Encodings) and also in the
+More help with encodings can be found in the entry [Text Encodings](../Concepts/Text-Encodings) and also in the
 Wikipedia article [here](http://en.wikipedia.org/wiki/Text_encodings).
 
 **A footnote for the batch-code processor**: Just because *Evennia* can parse your file and your

docs/source/Components/Bootstrap-Components-and-Utilities.md

@@ -2,7 +2,7 @@
 
 Bootstrap provides many utilities and components you can use when customizing Evennia's web
 presence. We'll go over a few examples here that you might find useful.
-> Please take a look at either [the basic web tutorial](../Howto/Starting/Add-a-simple-new-web-page) or 
+> Please take a look at either [the basic web tutorial](../Howto/Starting/Part5/Add-a-simple-new-web-page) or 
 >[the web character view tutorial](../Howto/Web-Character-View-Tutorial)
 > to get a feel for how to add pages to Evennia's website to test these examples.
 

docs/source/Components/Coding-Utils.md

@@ -274,7 +274,7 @@ need to send byte-data over the wire, `to_str` is the only one you'll need.
 The difference from Python's in-built `str()` and `bytes()` operators are that
 the Evennia ones makes use of the `ENCODINGS` setting and will try very hard to
 never raise a traceback but instead echo errors through logging. See
-[here](../Concept/Text-Encodings) for more info.
+[here](../Concepts/Text-Encodings) for more info.
 
 ### Ansi Coloring Tools
 - [evennia.ansi](api:evennia.utils.ansi)

docs/source/Components/Components-Overview.md

@@ -8,30 +8,29 @@ than, the doc-strings of each component in the [API](../Evennia-API).
 - [Typeclasses](./Typeclasses)
   - [Sessions](./Sessions)
   - [Acccounts](./Accounts)
-    - [Guests](../Concept/Guest-Logins)
+    - [Guests](../Concepts/Guest-Logins)
   - [Objects](./Objects)
   - [Scripts](./Scripts)
   - [Channels and Messages](./Communications)
-  - [Attributes](./Attributes)
-  - [Nicks](./Nicks)
-  - [Tags](./Tags)
-  - [Help system](./Help-System)
-  - [Spawner and prototypes](./Spawner-and-Prototypes)
+- [Attributes](./Attributes)
+- [Nicks](./Nicks)
+- [Tags](./Tags)
+- [Spawner and prototypes](./Spawner-and-Prototypes)
+- [Help entries](./Help-System)
 
 ## Commands 
 
-- [Command-System](Command system)
-  - [Command-Sets](./Command-Sets)
-  - [Commands](./Commands)
-  - [The Connection Screen](./Connection-Screen)
-  - [Available default Commands](./Default-Command-Help)
+- [Commands](./Commands)
+- [Command-Sets](./Command-Sets)
+- [The Connection Screen](./Connection-Screen)
+- [Available default Commands](./Default-Command-Help)
 - [Batch-Processors](./Batch-Processors)
   - [Batch-Code-Processor](./Batch-Code-Processor)
   - [Batch-Command-Processor](./Batch-Command-Processor)
 
-## Utils
+## Utils and tools
 
-- [Coding-Utils](./Coding-Utils)
+- [Misc Utils](./Coding-Utils)
 - [EvEditor](./EvEditor)
 - [EvMenu](./EvMenu)
 - [EvMore](./EvMore)
@@ -41,13 +40,13 @@ than, the doc-strings of each component in the [API](../Evennia-API).
 
 ## Server and network
 
-- [Signals](./Signals)
 - [Portal](./Portal-And-Server)
   - [Inputfuncs](./Inputfuncs)
   - [Outputfuncs](./Outputfuncs)
-  - [Protocols](../Concept/Custom-Protocols)
+  - [Protocols](../Concepts/Custom-Protocols)
 - [Server](./Server)
   - [Server conf object](./Server-Conf)
 - [Webserver](./Webserver)
   - [Webclient](./Webclient)
   - [Bootstrap](./Bootstrap-Components-and-Utilities)
+- [Signals](./Signals)

docs/source/Components/Default-Command-Help.md

@@ -5,7 +5,7 @@
 [issue tracker](https://github.com/evennia/evennia/issues).*
 
 The full set of default Evennia commands currently contains 92 commands in 9 source
-files.  Our policy for adding default commands is outlined [here](../Concept/Using-MUX-as-a-Standard). More
+files.  Our policy for adding default commands is outlined [here](../Concepts/Using-MUX-as-a-Standard). More
 information about how commands work can be found in the documentation for [Commands](./Commands).
 
 

docs/source/Components/Inputfuncs.md

@@ -1,7 +1,7 @@
 # Inputfuncs
 
 
-An *inputfunc* is an Evennia function that handles a particular input (an [inputcommand](../Concept/OOB)) from
+An *inputfunc* is an Evennia function that handles a particular input (an [inputcommand](../Concepts/OOB)) from
 the client. The inputfunc is the last destination for the inputcommand along the [ingoing message
 path](Messagepath#the-ingoing-message-path). The inputcommand always has the form `(commandname,
 (args), {kwargs})` and Evennia will use this to try to find and call an inputfunc on the form

docs/source/Components/Locks.md

@@ -261,7 +261,7 @@ control and delete the object.
 # Permissions
 
 > This section covers the underlying code use of permissions. If you just want to learn how to
-practically assign permissions in-game, refer to the [Building Permissions](../Concept/Building-Permissions)
+practically assign permissions in-game, refer to the [Building Permissions](../Concepts/Building-Permissions)
 page, which details how you use the `perm` command.
 
 A *permission* is simply a list of text strings stored  in the handler `permissions` on `Objects`

docs/source/Components/Outputfuncs.md

@@ -1,3 +1,3 @@
 # Outputfuncs
 
-TODO. For now info about outputfuncs are found in [OOB](../Concept/OOB).
+TODO. For now info about outputfuncs are found in [OOB](../Concepts/OOB).

docs/source/Components/Server-Conf.md

@@ -66,7 +66,7 @@ other things that must run in your game but which has no database persistence.
 - `connection_screens.py` - all global string variables in this module are interpreted by Evennia as
 a greeting screen to show when an Account first connects. If more than one string variable is
 present in the module a random one will be picked.
-- `inlinefuncs.py` - this is where you can define custom [Inline functions](../Concept/TextTags#inlinefuncs).
+- `inlinefuncs.py` - this is where you can define custom [Inline functions](../Concepts/TextTags#inlinefuncs).
 - `inputfuncs.py` - this is where you define custom [Input functions](./Inputfuncs) to handle data
 from the client.
 - `lockfuncs.py` - this is one of many possible modules to hold your own "safe" *lock functions* to
@@ -74,7 +74,7 @@ make available to Evennia's [Locks](./Locks).
 - `mssp.py` - this holds meta information about your game. It is used by MUD search engines (which
 you often have to register with) in order to display what kind of game you are running along with
     statistics such as number of online accounts and online status.
-- `oobfuncs.py` - in here you can define custom [OOB functions](../Concept/OOB).
+- `oobfuncs.py` - in here you can define custom [OOB functions](../Concepts/OOB).
 - `portal_services_plugin.py` - this allows for adding your own custom services/protocols to the
 Portal. It must define one particular function that will be called by Evennia at startup. There can
 be any number of service plugin modules, all will be imported and used if defined. More info can be

docs/source/Components/Sessions.md

@@ -172,7 +172,7 @@ server reboot (assuming the Portal is not stopped at the same time, obviously).
 Both the Portal and Server each have a *sessionhandler* to manage the connections. These handlers
 are global entities contain all methods for relaying data across the AMP bridge. All types of
 Sessions hold a reference to their respective Sessionhandler (the property is called
-`sessionhandler`) so they can relay data. See [protocols](../Concept/Custom-Protocols) for more info
+`sessionhandler`) so they can relay data. See [protocols](../Concepts/Custom-Protocols) for more info
 on building new protocols.
 
 To get all Sessions in the game (i.e. all currently connected clients), you access the server-side

docs/source/Components/Spawner-and-Prototypes.md

@@ -161,7 +161,7 @@ that you embed in strings and that has a `$` in front, like
 ```
 At execution time, the place of the protfunc will be replaced with the result of that protfunc being
 called (this is always a string). A protfunc works in much the same way as an
-[InlineFunc](../Concept/TextTags#inline-functions) - they are actually
+[InlineFunc](../Concepts/TextTags#inline-functions) - they are actually
 parsed using the same parser - except protfuncs are run every time the prototype is used to spawn a
 new object (whereas an inlinefunc is called when a text is returned to the user).
 

docs/source/Components/Tags.md

@@ -166,4 +166,4 @@ That said, tag categories can be useful if you build some game system that uses
 use tag categories to make sure to separate tags created with this system from any other tags
 created elsewhere. You can then supply custom search methods that *only* find objects tagged with
 tags of that category. An example of this
-is found in the [Zone tutorial](../Concept/Zones). 
+is found in the [Zone tutorial](../Concepts/Zones). 

docs/source/Concept/Command-System.md

@@ -1,9 +0,0 @@
-# Command System
-
-- [Commands](../Component/Commands) 
-- [Command Sets](../Component/Command-Sets)
-- [Command Auto-help](../Component/Help-System#command-auto-help-system)
-
-See also:
-- [Default Command Help](../Component/Default-Command-Help)
-- [Adding Command Tutorial](../Howto/Starting/Part1/Adding-Commands)

docs/source/Concepts/Async-Process.md

@@ -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](../Component/Commands) definition:
+An example of making an asynchronous call from inside a [Command](../Components/Commands) definition:
 
 ```python
     from evennia import utils, Command

docs/source/Concepts/Banning.md

@@ -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](../Component/Locks).
+your channel using [lock definitions](../Components/Locks).
 
 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](../Component/Attributes) or [Tag](../Component/Tags), your
+in your commands. You might look for the value of an [Attribute](../Components/Attributes) or [Tag](../Components/Tags), your
 current location etc.
 2. **perm/account thomas = page_banned** -- Give the account the 'permission' which causes (in this
 case) the lock to fail.

docs/source/Concepts/Building-Permissions.md

@@ -2,7 +2,7 @@
 
 
 *OBS: This gives only a brief introduction to the access system. Locks and permissions are fully
-detailed* [here](../Component/Locks).
+detailed* [here](../Components/Locks).
 
 ## 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](../Component/Locks) is
+permissions*. When building locks to check these permissions, the `perm()` [lock function](../Components/Locks) 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

docs/source/Concepts/Command-System.md

@@ -0,0 +1,9 @@
+# Command System
+
+- [Commands](../Components/Commands) 
+- [Command Sets](../Components/Command-Sets)
+- [Command Auto-help](../Components/Help-System#command-auto-help-system)
+
+See also:
+- [Default Command Help](../Components/Default-Command-Help)
+- [Adding Command Tutorial](../Howto/Starting/Part1/Adding-Commands)

docs/source/Concepts/Concepts-Overview.md

@@ -1,6 +1,6 @@
 # Core Concepts 
 
-This documentation cover more over-arching concepts of Evennia, often involving many [Core Components](../Component/Component-Overview) acting together.
+This documentation cover more over-arching concepts of Evennia, often involving many [Core Components](../Components/Components-Overview) acting together.
 
 ## General concepts
 

docs/source/Concepts/Custom-Protocols.md

@@ -5,9 +5,9 @@
 their own custom client protocol.*
 
 
-A [PortalSession](../Component/Sessions#Portal-and-Server-Sessions) is the basic data object representing an
+A [PortalSession](../Components/Sessions#Portal-and-Server-Sessions) is the basic data object representing an
 external
-connection to the Evennia [Portal](../Component/Portal-And-Server) -- usually a human player running a mud client
+connection to the Evennia [Portal](../Components/Portal-And-Server) -- 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*.
@@ -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](../Component/Inputfuncs) must exist to receive it. In the case of the `text` input exemplified above,
+[Inputfunc](../Components/Inputfuncs) 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](../Component/Inputfuncs) page for how to do this.
+[Inputfunc](../Components/Inputfuncs) 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

docs/source/Concepts/Guest-Logins.md

@@ -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](../Component/Connection-Screen) to inform them of this
+You may need to change your [Connection Screen](../Components/Connection-Screen) 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](../Component/Typeclasses) for guests.
+- `BASE_GUEST_TYPECLASS` - the python-path to the default [typeclass](../Components/Typeclasses) for guests.
 Defaults to `"typeclasses.accounts.Guest"`.
-- `PERMISSION_GUEST_DEFAULT` - [permission level](../Component/Locks) for guest accounts. Defaults to `"Guests"`,
+- `PERMISSION_GUEST_DEFAULT` - [permission level](../Components/Locks) 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).

docs/source/Concepts/Messagepath.md

@@ -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](../Component/Portal-And-Server) that
+ will generally set some flags on the [Portal Session](../Components/Portal-And-Server) 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
@@ -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](../Component/Sessions). Data and Session are passed to the server-side `SessionHandler.data_in`. This
+[Session](../Components/Sessions). 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](../Component/Inputfuncs) must be on the form `func(session, *args, **kwargs)`. An exception is
+The [Inputfunc](../Components/Inputfuncs) 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.
 

docs/source/Concepts/New-Models.md

@@ -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](../Component/Tags) or [Scripts](../Component/Scripts) can handle many situations,
+in a quickly accessible way. Whereas [Tags](../Components/Tags) or [Scripts](../Components/Scripts) can handle many situations,
 sometimes things may be easier to handle by adding your own database model.
 
 ## Overview of database tables
@@ -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](../Component/Attributes). It will automatically be set
+instances of your custom model in an Evennia [Attribute](../Components/Attributes). 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.

docs/source/Concepts/OOB.md

@@ -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](../Component/Inputfuncs). This function is called as `cmdname(session, *args, **kwargs)` where
+[Inputfunc](../Components/Inputfuncs). 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](../Component/Inputfuncs) page for more
+support/map client commands to actions inside Evennia (see the [inputfunc](../Components/Inputfuncs) page for more
 details).
 
 When a message is outgoing (at the 'Client-end' of the message path) the outputcommand is handled by
@@ -59,7 +59,7 @@ 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](../Component/Inputfuncs) lists the default inputfuncs available to handle incoming OOB messages. To
+[Inputfuncs](../Components/Inputfuncs) 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

docs/source/Concepts/TextTags.md

@@ -269,7 +269,7 @@ errors if desired).
 Note that whereas the function should accept `**kwargs`, keyword inputs are *not* usable in the call
 to the inlinefunction. The `kwargs` part is instead intended for Evennia to be able to supply extra
 information. Currently Evennia sends a single keyword to every inline function and that is
-`session`, which holds the [serversession](../Component/Sessions) this text is targeted at. Through the session
+`session`, which holds the [serversession](../Components/Sessions) this text is targeted at. Through the session
 object, a lot of dynamic possibilities are opened up for your inline functions.
 
 The `settings.INLINEFUNC_MODULES` configuration option is a list that decides which modules should

docs/source/Concepts/Web-Features.md

@@ -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/Web-Tutorial) for more information.
+[Web Tutorial](../Howto/Starting/Part5/Web-Tutorial) 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](../Component/Webclient) for more details.
+[See the Webclient page](../Components/Webclient) for more details.
 
 
 ## The Django 'Admin' Page

docs/source/Concepts/Zones.md

@@ -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](../Component/Tags). Tags are short labels that you attach to
+All objects in Evennia can hold any number of [Tags](../Components/Tags). 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](../Component/Typeclasses).
+retrieval later. Any functional differences must be expressed using [Typeclasses](../Components/Typeclasses).
 
 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

docs/source/Contrib/Dynamic-In-Game-Map.md

@@ -20,7 +20,7 @@ world to be 'logically' impossible with rooms looping to themselves or exits lea
 side of the map. Exits can also be named anything, from "jumping out the window" to "into the fifth
 dimension". This tutorial assumes you can only move in the cardinal directions (N, E, S and W).
 2. Rooms must be connected and linked together for the map to be generated correctly. Vanilla
-Evennia comes with a admin command [@tunnel](../Component/Default-Command-Help#tunnel-cmdtunnel) that allows a
+Evennia comes with a admin command [@tunnel](../Components/Default-Command-Help#tunnel-cmdtunnel) that allows a
 user to create rooms in the cardinal directions, but additional work is needed to assure that rooms
 are connected. For example, if you `@tunnel east` and then immediately do `@tunnel west` you'll find
 that you have created two completely stand-alone rooms. So care is needed if you want to create a
@@ -361,7 +361,7 @@ looping rooms that will show on your in-game map.
 
 The above example will display the map above the room description. You could also use an
 [EvTable](github:evennia.utils.evtable) to place description and map next to each other. Some other
-things you can do is to have a [Command](../Component/Commands) that displays with a larger radius, maybe with a
+things you can do is to have a [Command](../Components/Commands) that displays with a larger radius, maybe with a
 legend and other features.
 
 Below is the whole `map.py` for your reference. You need to update your `Room` typeclass (see above)

docs/source/Contrib/Static-In-Game-Map.md

@@ -4,7 +4,7 @@
 ## Introduction
 
 This tutorial describes the creation of an in-game map display based on a pre-drawn map. It also
-details how to use the [Batch code processor](../Component/Batch-Code-Processor) for advanced building. There is
+details how to use the [Batch code processor](../Components/Batch-Code-Processor) for advanced building. There is
 also the [Dynamic in-game map tutorial](./Dynamic-In-Game-Map) that works in the opposite direction,
 by generating a map from an existing grid of rooms.
 
@@ -41,7 +41,7 @@ map we designed before.
     ```
 
 We will henceforth assume your game folder is name named `mygame` and that you haven't modified the
-default commands. We will also not be using [Colors](../Concept/TextTags#colored-text) for our map since they
+default commands. We will also not be using [Colors](../Concepts/TextTags#colored-text) for our map since they
 don't show in the documentation wiki.
 
 ## Planning the Map
@@ -83,23 +83,23 @@ planning at this stage can solve many problems before they happen.
 In this section we will try to create an actual "map" object that an account can pick up and look
 at.
 
-Evennia offers a range of [default commands](../Component/Default-Command-Help) for 
+Evennia offers a range of [default commands](../Components/Default-Command-Help) for 
 [creating objects and rooms in-game](../Howto/Starting/Part1/Building-Quickstart). While readily accessible, these commands are made to do very
 specific, restricted things and will thus not offer as much flexibility to experiment (for an
-advanced exception see [in-line functions](../Concept/TextTags#new-inlinefuncs)). Additionally, entering long
+advanced exception see [in-line functions](../Concepts/TextTags#new-inlinefuncs)). Additionally, entering long
 descriptions and properties over and over in the game client can become tedious; especially when
 testing and you may want to delete and recreate things over and over.
 
-To overcome this, Evennia offers [batch processors](../Component/Batch-Processors) that work as input-files
+To overcome this, Evennia offers [batch processors](../Components/Batch-Processors) that work as input-files
 created out-of-game. In this tutorial we'll be using the more powerful of the two available batch
-processors, the [Batch Code Processor ](../Component/Batch-Code-Processor), called with the `@batchcode` command.
+processors, the [Batch Code Processor ](../Components/Batch-Code-Processor), called with the `@batchcode` command.
 This is a very powerful tool. It allows you to craft Python files to act as blueprints of your
 entire game world. These files have access to use Evennia's Python API directly. Batchcode allows
 for easy editing and creation in whatever text editor you prefer, avoiding having to manually build
 the world line-by-line inside the game.
 
 > Important warning: `@batchcode`'s power is only rivaled by the `@py` command. Batchcode is so
-powerful it should be reserved only for the [superuser](../Concept/Building-Permissions). Think carefully
+powerful it should be reserved only for the [superuser](../Concepts/Building-Permissions). Think carefully
 before you let others (such as `Developer`- level staff) run `@batchcode` on their own - make sure
 you are okay with them running *arbitrary Python code* on your server.
 
@@ -413,4 +413,4 @@ easily new game defining features can be added to Evennia.
 You can easily build from this tutorial by expanding the map and creating more rooms to explore. Why
 not add more features to your game by trying other tutorials: [Add weather to your world](Weather-
 Tutorial), [fill your world with NPC's](../Howto/Tutorial-Aggressive-NPCs) or 
-[implement a combat system](../Howto/Starting/Turn-based-Combat-System).
+[implement a combat system](../Howto/Starting/Part3/Turn-based-Combat-System).

docs/source/Evennia-API.md

@@ -1,8 +1,8 @@
-# API
+# API Summary 
 
-- [evennia](api:evennia) - root of API
-- [evennia.accounts](api:evennia.accounts) - the out-of-character entity representing players
-- [evennia.commands](api:evennia.commands) - all inputs. Also includes default commands
+[evennia](api:evennia) - library root
+- [evennia.accounts](api:evennia.accounts) - the out-of-character entities representing players
+- [evennia.commands](api:evennia.commands) - handle all inputs. Also includes default commands
 - [evennia.comms](api:evennia.comms) - in-game channels and messaging
 - [evennia.contrib](api:evennia.contrib) - game-specific tools and code contributed by the community
 - [evennia.help](api:evennia.help) - in-game help system
@@ -16,7 +16,6 @@
 - [evennia.web](api:evennia.web) - webclient, website and other web resources
 
 
-
 ## Shortcuts
 
 Evennia's 'flat API' has shortcuts to common tools, available by only importing `evennia`.
@@ -48,19 +47,19 @@ The flat API is defined in `__init__.py` [viewable here](github:evennia/__init__
 
 ### Typeclasses
 
-- [evennia.Defaultaccount](api:evennia.accounts.accounts#evennia.accounts.accounts.DefaultAccount) - player account class ([docs](Component/Accounts))
+- [evennia.Defaultaccount](api:evennia.accounts.accounts#evennia.accounts.accounts.DefaultAccount) - player account class ([docs](Components/Accounts))
 - [evennia.DefaultGuest](api:evennia.accounts.accounts#evennia.accounts.accounts.DefaultGuest) - base guest account class
-- [evennia.DefaultObject](api:evennia.objects.objects#evennia.objects.objects.DefaultObject) - base class for all objects ([docs](Component/Objects))
-- [evennia.DefaultCharacter](api:evennia.objects.objects#evennia.objects.objects.DefaultCharacter) - base class for in-game characters ([docs](Component/Objects#Character))
-- [evennia.DefaultRoom](api:evennia.objects.objects#evennia.objects.objects.DefaultRoom) - base class for rooms ([docs](Component/Objects#Room))
-- [evennia.DefaultExit](api:evennia.objects.objects#evennia.objects.objects.DefaultExit) - base class for exits ([docs](Component/Objects#Exit))
-- [evennia.DefaultScript](api:evennia.scripts.scripts#evennia.scripts.scripts.DefaultScript) - base class for OOC-objects ([docs](Component/Scripts))
-- [evennia.DefaultChannel](api:evennia.comms.comms#evennia.comms.comms.DefaultChannel) - base class for in-game channels ([docs](Component/Channels))
+- [evennia.DefaultObject](api:evennia.objects.objects#evennia.objects.objects.DefaultObject) - base class for all objects ([docs](Components/Objects))
+- [evennia.DefaultCharacter](api:evennia.objects.objects#evennia.objects.objects.DefaultCharacter) - base class for in-game characters ([docs](Components/Objects#Character))
+- [evennia.DefaultRoom](api:evennia.objects.objects#evennia.objects.objects.DefaultRoom) - base class for rooms ([docs](Components/Objects#Room))
+- [evennia.DefaultExit](api:evennia.objects.objects#evennia.objects.objects.DefaultExit) - base class for exits ([docs](Components/Objects#Exit))
+- [evennia.DefaultScript](api:evennia.scripts.scripts#evennia.scripts.scripts.DefaultScript) - base class for OOC-objects ([docs](Components/Scripts))
+- [evennia.DefaultChannel](api:evennia.comms.comms#evennia.comms.comms.DefaultChannel) - base class for in-game channels ([docs](Components/Channels))
 
 ### Commands
 
-- [evennia.Command](api:evennia.commands.command#evennia.commands.command.Command) - base [Command](Component/Commands) class. See also `evennia.default_cmds.MuxCommand`
-- [evennia.CmdSet](api:evennia.commands.cmdset#evennia.commands.cmdset.CmdSet) - base [Cmdset](Component/Command-Sets) class
+- [evennia.Command](api:evennia.commands.command#evennia.commands.command.Command) - base [Command](Components/Commands) class. See also `evennia.default_cmds.MuxCommand`
+- [evennia.CmdSet](api:evennia.commands.cmdset#evennia.commands.cmdset.CmdSet) - base [Cmdset](Components/Command-Sets) class
 - [evennia.default_cmds](api:Default-Command-Help) - access all default command classes as properties
 
 - [evennia.syscmdkeys](api:Commands#System-Commands) - access system command keys as properties
@@ -68,20 +67,20 @@ The flat API is defined in `__init__.py` [viewable here](github:evennia/__init__
 ### Utilities
 
 - [evennia.utils.utils](api:evennia.utils.utils) - mixed useful utilities
-- [evennia.gametime](api:evennia.utils.gametime) - server run- and game time ([docs](Component/Coding-Utils#gametime))
+- [evennia.gametime](api:evennia.utils.gametime) - server run- and game time ([docs](Components/Coding-Utils#gametime))
 - [evennia.logger](api:evennia.utils.logger) - logging tools
 - [evennia.ansi](api:evennia.utils.ansi) - ansi coloring tools
-- [evennia.spawn](api:evennia.prototypes.spawner#evennia.prototypes.spawner.Spawn) - spawn/prototype system ([docs](Component/Spawner-and-Prototypes))
-- [evennia.lockfuncs](api:evennia.locks.lockfuncs) - default lock functions for access control ([docs](Component/Locks))
-- [evennia.EvMenu](api:evennia.utils.evmenu#evennia.utils.evmenu.EvMenu) - menu system ([docs](Component/EvMenu))
+- [evennia.spawn](api:evennia.prototypes.spawner#evennia.prototypes.spawner.Spawn) - spawn/prototype system ([docs](Components/Spawner-and-Prototypes))
+- [evennia.lockfuncs](api:evennia.locks.lockfuncs) - default lock functions for access control ([docs](Components/Locks))
+- [evennia.EvMenu](api:evennia.utils.evmenu#evennia.utils.evmenu.EvMenu) - menu system ([docs](Components/EvMenu))
 - [evennia.EvTable](api:evennia.utils.evtable#evennia.utils.evtable.EvTable) - text table creater
 - [evennia.EvForm](api:evennia.utils.evform#evennia.utils.evform.EvForm) - text form creator
-- [evennia.EvEditor](api:evennia.utils.eveditor#evennia.utils.eveditor.EvEditor) - in game text line editor ([docs](Component/EvEditor))
+- [evennia.EvEditor](api:evennia.utils.eveditor#evennia.utils.eveditor.EvEditor) - in game text line editor ([docs](Components/EvEditor))
 
 ### Global singleton handlers
 
-- [evennia.TICKER_HANDLER](api:evennia.scripts.tickerhandler) - allow objects subscribe to tickers ([docs](Component/TickerHandler))
-- [evennia.MONITOR_HANDLER](api:evennia.scripts.monitorhandler) - monitor changes ([docs](Component/MonitorHandler))
+- [evennia.TICKER_HANDLER](api:evennia.scripts.tickerhandler) - allow objects subscribe to tickers ([docs](Components/TickerHandler))
+- [evennia.MONITOR_HANDLER](api:evennia.scripts.monitorhandler) - monitor changes ([docs](Components/MonitorHandler))
 - [evennia.CHANNEL_HANDLER](api:evennia.comms.channelhandler) - maintains channels
 - [evennia.SESSION_HANDLER](api:evennia.server.serverhandler) - manages all sessionsmain session handler
 

docs/source/Evennia-Introduction.md

@@ -35,7 +35,7 @@ implementations indeed.
 
 The server ships with a default set of player commands that are similar to the MUX command set. We
 *do not* aim specifically to be a MUX server, but we had to pick some default to go with (see
-[this](Concept/Soft-Code) for more about our original motivations).  It's easy to remove or add commands, or
+[this](Concepts/Soft-Code) for more about our original motivations).  It's easy to remove or add commands, or
 to have the command syntax mimic other systems, like Diku, LP, MOO and so on. Or why not create a
 new and better command system of your own design.
 
@@ -99,7 +99,7 @@ generation and more
 - RSS feeds can be echoed to in-game channels (things like Twitter can easily be added)
 - Several different databases supported (SQLite3, MySQL, PostgreSQL, ...)
 
-For more extensive feature information, see the [Evennia Component overview](Component/Component-Overview).
+For more extensive feature information, see the [Evennia Component overview](Components/Components-Overview).
 
 ## What you need to know to work with Evennia
 
@@ -141,8 +141,8 @@ programming](http://www.tutorialspoint.com/python/python_classes_objects.htm), u
 [Classes](http://docs.python.org/tutorial/classes.html), their methods and properties
 
 Obviously, the more things you feel comfortable with, the easier time you'll have to find your way.
-With just basic knowledge you should be able to define your own [Commands](Component/Commands), create custom
-[Objects](Component/Objects) as well as make your world come alive with basic [Scripts](Component/Scripts). You can
+With just basic knowledge you should be able to define your own [Commands](Components/Commands), create custom
+[Objects](Components/Objects) as well as make your world come alive with basic [Scripts](Components/Scripts). You can
 definitely build a whole advanced and customized game from extending Evennia's examples only.
 
 ### I know my Python stuff and I am willing to use it!
@@ -177,6 +177,6 @@ be searched from the same place for discussion topics you are interested in.
 2. Read the [Game Planning](Howto/Starting/Part2/Game-Planning) wiki page. It gives some ideas for your work flow and the
 state of mind you should aim for - including cutting down the scope of your game for its first
 release.
-3. Do the [Tutorial for basic MUSH-like game](Howto/Starting/Tutorial-for-basic-MUSH-like-game) carefully from
+3. Do the [Tutorial for basic MUSH-like game](Howto/Starting/Part3/Tutorial-for-basic-MUSH-like-game) carefully from
 beginning to end and try to understand what does what. Even if you are not interested in a MUSH for
 your own game, you will end up with a small (very small) game that you can build or learn from.

docs/source/Glossary.md

@@ -49,7 +49,7 @@ representation in the game world. Through their Account they can instead choose
 [puppet](./Glossary#puppet) one (or more, depending on game mode) [Characters](./Glossary#character) in
 the game.
 
-In the default [multisession mode](Component/Sessions#multisession-mode) of Evennia, you immediately start
+In the default [multisession mode](Components/Sessions#multisession-mode) of Evennia, you immediately start
 puppeting a Character with the same name as your Account when you log in - mimicking how older
 servers used to work.
 
@@ -66,7 +66,7 @@ The term _Attribute_ should not be confused with ([properties](./Glossary#proper
 [fields](./Glossary#field). The `Attribute` represents arbitrary pieces of data that can be attached
 to any [typeclassed](./Glossary#typeclass) entity in Evennia. Attributes allows storing new persistent
 data on typeclasses without changing their underlying database schemas. 
-[Read more about Attributes here](Component/Attributes).
+[Read more about Attributes here](Components/Attributes).
 
 ### _channel_
 
@@ -82,7 +82,7 @@ comm system here](Communications#channels).
 The _Character_ is the term we use for the default avatar being [puppeted](./Glossary#puppet) by the
 [account](./Glossary#account) in the game world. It is represented by the `Character` typeclass (which
 is a child of [Object](./Glossary#object)). Many developers use children of this class to represent
-monsters and other NPCs. You can [read more about it here](Component/Objects#subclasses-of-object).
+monsters and other NPCs. You can [read more about it here](Components/Objects#subclasses-of-object).
 
 ### _django_
 
@@ -133,7 +133,7 @@ A _field_ or _database field_ in Evennia refers to a [property](./Glossary#prope
 properties per typeclass are database fields but they are often tied to the core functionality of
 that base typeclass (for example [Objects](./Glossary#object) store its location as a field). In all
 other cases, [attributes](./Glossary#attribute) are used to add new persistent data to the typeclass.
-[Read more about typeclass properties here](Component/Typeclasses#about-typeclass-properties).
+[Read more about typeclass properties here](Components/Typeclasses#about-typeclass-properties).
 
 ### _git_
 
@@ -211,7 +211,7 @@ try to use `object` to refer to the general term and capitalized `Object` when w
 typeclass.
 
 The `Object` is a typeclass that represents all *in-game* entities, including
-[Characters](./Glossary#character), rooms, trees, weapons etc. [Read more about Objects here](Component/Objects).
+[Characters](./Glossary#character), rooms, trees, weapons etc. [Read more about Objects here](Components/Objects).
 
 ### _pip_
 
@@ -264,16 +264,16 @@ well.
 
 ### _script_
 
-When we refer to _Scripts_, we generally refer to the `Script` [typeclass](Component/Typeclasses). Scripts are
+When we refer to _Scripts_, we generally refer to the `Script` [typeclass](Components/Typeclasses). Scripts are
 the mavericks of Evennia - they are like [Objects](./Glossary#object) but without any in-game
 existence. They are useful as custom places to store data but also as building blocks in persistent
 game systems. Since the can be initialized with timing capabilities they can also be used for long-
 time persistent time keeping (for fast updates other types of timers may be better though). 
-[Read more about Scripts here](Component/Scripts)
+[Read more about Scripts here](Components/Scripts)
 
 ### _session_
 
-A [Session](Component/Sessions) is a Python object representing a single client connection to the server. A
+A [Session](Components/Sessions) is a Python object representing a single client connection to the server. A
 given human player could connect to the game from different clients and each would get a Session
 (even if you did not allow them to actually log in and get access to an
 [account](./Glossary#account)).
@@ -284,7 +284,7 @@ can be useful for certain game states.
 
 ### _ticker_
 
-The [Ticker handler](Component/TickerHandler) runs Evennia's optional 'ticker' system. In other engines, such
+The [Ticker handler](Components/TickerHandler) runs Evennia's optional 'ticker' system. In other engines, such
 as [DIKU](https://en.wikipedia.org/wiki/DikuMUD), all game events are processed only at specific
 intervals called 'ticks'. Evennia has no such technical limitation (events are processed whenever
 needed) but using a fixed tick can still be useful for certain types of game systems, like combat.
@@ -293,7 +293,7 @@ to be called when those ticks come around.
 
 ### _typeclass_
 
-The [typeclass](Component/Typeclasses) is an Evennia-specific term. A typeclass allows developers to work with
+The [typeclass](Components/Typeclasses) is an Evennia-specific term. A typeclass allows developers to work with
 database-persistent objects as if they were normal Python objects. It makes use of specific
 [Django](./Glossary#django) features to link a Python class to a database table. Sometimes we refer to
 such code entities as _being typeclassed_.

docs/source/How-To-Get-And-Give-Help.md

@@ -53,15 +53,14 @@ appreciate the work done with the server! You can also encourage the community t
 issues by putting up a monetary [bounty][bountysource] on it. 
 
 
-[form](https://docs.google.com/spreadsheet/viewform?hl=en_US&formkey=dGN0VlJXMWpCT3VHaHpscDEzY1RoZGc6MQ#gid=0)
-[group](http://groups.google.com/group/evennia/)
-[issues](https://github.com/evennia/evennia/issues)
-[issues-master](https://github.com/evennia/evennia/issues?utf8=%E2%9C%93&q=is%3Aissue%20is%3Aopen%20label%3Abug%20label%3Amaster-branch)
-[chat](http://webchat.freenode.net/?channels=evennia)
-[paypal](https://www.paypal.com/se/cgi-bin/webscr?cmd=_flow&SESSION=Z-VlOvfGjYq2qvCDOUGpb6C8Due7skT0qOklQEy5EbaD1f0eyEQaYlmCc8O&dispatch=5885d80a13c0db1f8e263663d3faee8d64ad11bbf4d2a5a1a0d303a50933f9b2)
-[donate-img](http://images-focus-opensocial.googleusercontent.com/gadgets/proxy?url=https://www.paypalobjects.com/en%255fUS/SE/i/btn/btn%255fdonateCC%255fLG.gif&container=focus&gadget=a&rewriteMime=image/*)
-[patreon](https://www.patreon.com/griatch)
-[patreon-img](http://www.evennia.com/_/rsrc/1424724909023/home/evennia_patreon_100x100.png)
-[issues-bounties](https://github.com/evennia/evennia/labels/bounty)
-[bountysource](https://www.bountysource.com/teams/evennia)
-
+[form]: https://docs.google.com/spreadsheet/viewform?hl=en_US&formkey=dGN0VlJXMWpCT3VHaHpscDEzY1RoZGc6MQ#gid=0
+[group]:http://groups.google.com/group/evennia/
+[issues]:https://github.com/evennia/evennia/issues
+[issues-master]:https://github.com/evennia/evennia/issues?utf8=%E2%9C%93&q=is%3Aissue%20is%3Aopen%20label%3Abug%20label%3Amaster-branch
+[chat]: http://webchat.freenode.net/?channels=evennia
+[paypal]: https://www.paypal.com/se/cgi-bin/webscr?cmd=_flow&SESSION=Z-VlOvfGjYq2qvCDOUGpb6C8Due7skT0qOklQEy5EbaD1f0eyEQaYlmCc8O&dispatch=5885d80a13c0db1f8e263663d3faee8d64ad11bbf4d2a5a1a0d303a50933f9b2
+[donate-img]: http://images-focus-opensocial.googleusercontent.com/gadgets/proxy?url=https://www.paypalobjects.com/en%255fUS/SE/i/btn/btn%255fdonateCC%255fLG.gif&container=focus&gadget=a&rewriteMime=image/*
+[patreon]: https://www.patreon.com/griatch
+[patreon-img]: http://www.evennia.com/_/rsrc/1424724909023/home/evennia_patreon_100x100.png
+[issues-bounties]:https://github.com/evennia/evennia/labels/bounty
+[bountysource]: https://www.bountysource.com/teams/evennia

docs/source/Howto/Add-a-wiki-on-your-website.md

@@ -2,7 +2,7 @@
 
 
 **Before doing this tutorial you will probably want to read the intro in 
-[Basic Web tutorial](Starting/Web-Tutorial).**  Reading the three first parts of the 
+[Basic Web tutorial](Starting/Part5/Web-Tutorial).**  Reading the three first parts of the 
 [Django tutorial](https://docs.djangoproject.com/en/1.9/intro/tutorial01/) might help as well.
 
 This tutorial will provide a step-by-step process to installing a wiki on your website.

docs/source/Howto/Building-a-mech-tutorial.md

@@ -28,9 +28,9 @@ Before we continue, let’s make a brief detour. Evennia is very flexible about
 more flexible about using and adding commands to those objects. Here are some ground rules well
 worth remembering for the remainder of this article:
 
-- The [Account](../Component/Accounts) represents the real person logging in and has no game-world existence.
-- Any [Object](../Component/Objects) can be puppeted by an Account (with proper permissions).
-- [Characters](../Component/Objects#characters), [Rooms](../Component/Objects#rooms), and [Exits](../Component/Objects#exits) are just
+- The [Account](../Components/Accounts) represents the real person logging in and has no game-world existence.
+- Any [Object](../Components/Objects) can be puppeted by an Account (with proper permissions).
+- [Characters](../Components/Objects#characters), [Rooms](../Components/Objects#rooms), and [Exits](../Components/Objects#exits) are just
 children of normal Objects.
 - Any Object can be inside another (except if it creates a loop).
 - Any Object can store custom sets of commands on it. Those commands can:
@@ -120,7 +120,7 @@ about the missiles being fired and has different `key` and `aliases`. We leave
 that up to you to create as an exercise. You could have it print "WOOSH! The
 mech launches missiles against <target>!", for example.
 
-Now we shove our commands into a command set. A [Command Set](../Component/Command-Sets) (CmdSet) is a container
+Now we shove our commands into a command set. A [Command Set](../Components/Command-Sets) (CmdSet) is a container
 holding any number of commands. The command set is what we will store on the mech.
 
 ```python
@@ -173,7 +173,7 @@ This is great for testing. The way we added it, the MechCmdSet will even go away
 server. Now we want to make the mech an actual object “type” so we can create mechs without those
 extra steps. For this we need to create a new Typeclass.
 
-A [Typeclass](../Component/Typeclasses) is a near-normal Python class that stores its existence to the database
+A [Typeclass](../Components/Typeclasses) is a near-normal Python class that stores its existence to the database
 behind the scenes. A Typeclass is created in a normal Python source file:
 
 ```python

docs/source/Howto/Coding-FAQ.md

@@ -23,8 +23,8 @@ reloading)
 - [Use wide characters with EvTable](./Coding-FAQ#non-latin-characters-in-evtable)
 
 ## Removing default commands
-**Q:** How does one *remove* (not replace) e.g. the default `get` [Command](../Component/Commands) from the
-Character [Command Set](../Component/Command-Sets)?
+**Q:** How does one *remove* (not replace) e.g. the default `get` [Command](../Components/Commands) from the
+Character [Command Set](../Components/Command-Sets)?
 
 **A:** Go to `mygame/commands/default_cmdsets.py`. Find the `CharacterCmdSet` class. It has one
 method named `at_cmdset_creation`. At the end of that method, add the following line:
@@ -36,7 +36,7 @@ for more info.
 combat, immobilized, etc.)
 
 **A:** The `at_before_move` hook is called by Evennia just before performing any move. If it returns
-`False`, the move is aborted. Let's say we want to check for an [Attribute](../Component/Attributes) `cantmove`.
+`False`, the move is aborted. Let's say we want to check for an [Attribute](../Components/Attributes) `cantmove`.
 Add the following code to the `Character` class:
 
 ```python
@@ -52,7 +52,7 @@ def at_before_move(self, destination):
 **Q:** An object has a Command on it starts up an EvMenu instance. How do I capture a reference to
 that object for use in the menu?
 
-**A:** When an [EvMenu](../Component/EvMenu) is started, the menu object is stored as `caller.ndb._menutree`.
+**A:** When an [EvMenu](../Components/EvMenu) is started, the menu object is stored as `caller.ndb._menutree`.
 This is a good place to store menu-specific things since it will clean itself up when the menu
 closes. When initiating the menu, any additional keywords you give will be available for you as
 properties on this menu object:
@@ -101,7 +101,7 @@ CHANNEL_COLORS`.
 **Q:** I want certain commands to turn off in a given room. They should still work normally for
 staff.
 
-**A:** This is done using a custom cmdset on a room [locked with the 'call' lock type](../Component/Locks). Only
+**A:** This is done using a custom cmdset on a room [locked with the 'call' lock type](../Components/Locks). Only
 if this lock is passed will the commands on the room be made available to an object inside it. Here
 is an example of a room where certain commands are disabled for non-staff:
 
@@ -142,7 +142,7 @@ superusers).
 command to only be available on a full moon, from midnight to three in-game time.
 
 **A:** This is easiest accomplished by putting the "werewolf" command on the Character as normal,
-but to [lock](../Component/Locks) it with the "cmd" type lock. Only if the "cmd" lock type is passed will the
+but to [lock](../Components/Locks) it with the "cmd" type lock. Only if the "cmd" lock type is passed will the
 command be available.
 
 ```python

docs/source/Howto/Command-Cooldown.md

@@ -88,7 +88,7 @@ database, you need to use the caster for the storage.
     self.caller.db.firestorm_lastcast = now
 ```
 
-Since we are storing as an [Attribute](../Component/Attributes), we need to identify the
+Since we are storing as an [Attribute](../Components/Attributes), we need to identify the
 variable as `firestorm_lastcast` so we are sure we get the right one (we'll
     likely have other skills with cooldowns after all). But this method of
 using cooldowns also has the advantage of working *between* commands - you can

docs/source/Howto/Command-Duration.md

@@ -2,7 +2,7 @@
 
 
 Before reading this tutorial, if you haven't done so already, you might want to
-read [the documentation on commands](../Component/Commands) to get a basic understanding of
+read [the documentation on commands](../Components/Commands) to get a basic understanding of
 how commands work in Evennia.
 
 In some types of games a command should not start and finish immediately.
@@ -40,7 +40,7 @@ class CmdTest(Command):
 > Important: The `yield` functionality will *only* work in the `func` method of
 > Commands. It only works because Evennia has especially
 > catered for it in Commands. If you want the same functionality elsewhere you
-> must use the [interactive decorator](../Concept/Async-Process#The-@interactive-decorator).
+> must use the [interactive decorator](../Concepts/Async-Process#The-@interactive-decorator).
 
 The important line is the `yield 10`.  It tells Evennia to "pause" the command
 and to wait for 10 seconds to execute the rest.  If you add this command and

docs/source/Howto/Command-Prompt.md

@@ -21,7 +21,7 @@ You can combine the sending of normal text with the sending (updating of the pro
     self.msg("This is a text", prompt="This is a prompt")
 ```
 
-You can update the prompt on demand, this is normally done using [OOB](../Concept/OOB)-tracking of the relevant
+You can update the prompt on demand, this is normally done using [OOB](../Concepts/OOB)-tracking of the relevant
 Attributes (like the character's health). You could also make sure that attacking commands update
 the prompt when they cause a change in health, for example.
 

docs/source/Howto/Coordinates.md

@@ -23,7 +23,7 @@ instance.
 ## Coordinates as tags
 
 The first concept might be the most surprising at first glance: we will create coordinates as
-[tags](../../Component/Tags).
+[tags](../Components/Tags).
 
 > Why not attributes, wouldn't that be easier?
 

docs/source/Howto/Customize-channels.md

@@ -106,7 +106,7 @@ Evennia is smart enough to understand that when we type `+something`, `+` is the
 `something` is the command argument.  This will, of course, fail if you have a command beginning by
 `+` conflicting with the `CmdConnect` key.
 4. We have altered some class attributes, like `auto_help`.  If you want to know what they do and
-why they have changed here, you can check the [documentation on commands](../Component/Commands).
+why they have changed here, you can check the [documentation on commands](../Components/Commands).
 5. In the command body, we begin by extracting the channel name.  Remember that this name should be
 in the command arguments (that is, in `self.args`).  Following the same example, if a player enters
 `+something`, `self.args` should contain `"something"`.  We use `search_channel` to see if this

docs/source/Howto/Default-Exit-Errors.md

@@ -2,8 +2,8 @@
 
 
 Evennia allows for exits to have any name. The command "kitchen" is a valid exit name as well as
-"jump out the window" or "north". An exit actually consists of two parts: an [Exit Object](../Component/Objects)
-and an [Exit Command](../Component/Commands) stored on said exit object. The command has the same key and aliases
+"jump out the window" or "north". An exit actually consists of two parts: an [Exit Object](../Components/Objects)
+and an [Exit Command](../Components/Commands) stored on said exit object. The command has the same key and aliases
 as the object, which is why you can see the exit in the room and just write its name to traverse it.
 
 If you try to enter the name of a non-existing exit, it is thus the same as trying a non-exising
@@ -90,7 +90,7 @@ commands:
      You cannot move east.
 
 Further expansions by the exit system (including manipulating the way the Exit command itself is
-created) can be done by modifying the [Exit typeclass](../Component/Typeclasses) directly.
+created) can be done by modifying the [Exit typeclass](../Components/Typeclasses) directly.
 
 ## Additional Comments
 
@@ -109,7 +109,7 @@ So why didn't we create a single error command above? Something like this:
 The anwer is that this would *not* work and understanding why is important in order to not be
 confused when working with commands and command sets.
 
-The reason it doesn't work is because Evennia's [command system](../Component/Commands) compares commands *both*
+The reason it doesn't work is because Evennia's [command system](../Components/Commands) compares commands *both*
 by `key` and by `aliases`.  If *either* of those match, the two commands are considered *identical*
 as far as cmdset merging system is concerned.
 

docs/source/Howto/Evennia-for-MUSH-Users.md

@@ -38,7 +38,7 @@ to use. So the *Player* usually operates by making use of the tools prepared for
 
 For a *Player*, collaborating on a game need not be too different between MUSH and Evennia. The
 building and description of the game world can still happen mostly in-game using build commands,
-using text tags and [inline functions](../Concept/TextTags#inline-functions) to prettify and customize the
+using text tags and [inline functions](../Concepts/TextTags#inline-functions) to prettify and customize the
 experience. Evennia offers external ways to build a world but those are optional. There is also
 nothing *in principle* stopping a Developer from offering a softcode-like language to Players if
 that is deemed necessary.
@@ -203,7 +203,7 @@ developer changing the underlying Python code.
 ## Next steps
 
 If you are a *Developer* and are interested in making a more MUSH-like Evennia game, a good start is
-to look into the Evennia [Tutorial for a first MUSH-like game](Starting/Tutorial-for-basic-MUSH-like-game).
+to look into the Evennia [Tutorial for a first MUSH-like game](Starting/Part3/Tutorial-for-basic-MUSH-like-game).
 That steps through building a simple little game from scratch and helps to acquaint you with the
 various corners of Evennia. There is also the [Tutorial for running roleplaying sessions](Evennia-
 for-roleplaying-sessions) that can be of interest.

docs/source/Howto/Evennia-for-roleplaying-sessions.md

@@ -44,7 +44,7 @@ to show your renewed GM status to the other accounts.
 
 ### The permission hierarchy
 
-Evennia has the following [permission hierarchy](../Concept/Building-Permissions#assigning-permissions) out of
+Evennia has the following [permission hierarchy](../Concepts/Building-Permissions#assigning-permissions) out of
 the box: *Players, Helpers, Builders, Admins* and finally *Developers*. We could change these but
 then we'd need to update our Default commands to use the changes. We want to keep this simple, so
 instead we map our different roles on top of this permission ladder.
@@ -60,7 +60,7 @@ everyone.
 5. `Developers`-level permission are the server administrators, the ones with the ability to
 restart/shutdown the server as well as changing the permission levels.
 
-> The [superuser](../Concept/Building-Permissions#the-super-user) is not part of the hierarchy and actually
+> The [superuser](../Concepts/Building-Permissions#the-super-user) is not part of the hierarchy and actually
 completely bypasses it. We'll assume server admin(s) will "just" be Developers.
 
 ### How to grant permissions
@@ -102,7 +102,7 @@ its name will have the string`(GM)` added to the end.
 #### Character modification
 
 Let's first start by customizing the Character. We recommend you browse the beginning of the
-[Account](../Component/Accounts) page to make sure you know how Evennia differentiates between the OOC "Account
+[Account](../Components/Accounts) page to make sure you know how Evennia differentiates between the OOC "Account
 objects" (not to be confused with the `Accounts` permission, which is just a string specifying your
 access) and the IC "Character objects".
 
@@ -142,7 +142,7 @@ Above, we change how the Character's name is displayed: If the account controlli
 a GM, we attach the string `(GM)` to the Character's name so everyone can tell who's the boss. If we
 ourselves are Developers or GM's we will see database ids attached to Characters names, which can
 help if doing database searches against Characters of exactly the same name. We base the "gm-
-ingness" on having an flag (an [Attribute](../Component/Attributes)) named `is_gm`. We'll make sure new GM's
+ingness" on having an flag (an [Attribute](../Components/Attributes)) named `is_gm`. We'll make sure new GM's
 actually get this flag below.
 
 > **Extra exercise:** This will only show the `(GM)` text on *Characters* puppeted by a GM account,
@@ -152,7 +152,7 @@ that is, it will show only to those in the same location. If we wanted it to als
 
 #### New @gm/@ungm command
 
-We will describe in some detail how to create and add an Evennia [command](../Component/Commands) here with the
+We will describe in some detail how to create and add an Evennia [command](../Components/Commands) here with the
 hope that we don't need to be as detailed when adding commands in the future. We will build on
 Evennia's default "mux-like" commands here.
 
@@ -267,7 +267,7 @@ We will here show two examples using the *EvTable* and *EvForm* utilities.Later
 Commands to edit and display the output from those utilities.
 
 > Note that due to the limitations of the wiki, no color is used in any of the examples. See 
-> [the text tag documentation](../Concept/TextTags) for how to add color to the tables and forms.
+> [the text tag documentation](../Concepts/TextTags) for how to add color to the tables and forms.
 
 #### Making a sheet with EvTable
 
@@ -704,7 +704,7 @@ access after the fact.
 
 ## Channels
 
-Evennia comes with [Channels](../Component/Communications#Channels) in-built and they are described fully in the
+Evennia comes with [Channels](../Components/Communications#Channels) in-built and they are described fully in the
 documentation. For brevity, here are the relevant commands for normal use:
 
 * `@ccreate new_channel;alias;alias = short description` - Creates a new channel.

docs/source/Howto/Gametime-Tutorial.md

@@ -98,7 +98,7 @@ time, and assuming a standard calendar (see below for the same feature with a cu
 instance, it can be used to have a specific message every (in-game) day at 6:00 AM showing how the
 sun rises.
 
-The function `schedule()` should be used here.  It will create a [script](../Component/Scripts) with some
+The function `schedule()` should be used here.  It will create a [script](../Components/Scripts) with some
 additional features to make sure the script is always executed when the game time matches the given
 parameters.
 

docs/source/Howto/Howto-Overview.md

@@ -3,7 +3,7 @@
 The documents in this section aims to teach how to use Evennia in a tutorial or
 a step-by-step way. They often give hints on about solving a problem or implementing
 a particular feature or concept. They will often refer to the
-[components](../Component/Component-Overview) or [concepts](../Concept/Concept-Overview)
+[components](../Components/Components-Overview) or [concepts](../Concepts/Concepts-Overview)
 docs for those that want to dive deeper.
 
 ## The Starting Tutorial
@@ -34,11 +34,15 @@ in mind for your own game, this will give you a good start.
 1. [On planning a game](Starting/Part2/Game-Planning)
 1. [Multisession modes](../Unimplemented)
 1. [Layout of our tutorial game](../Unimplemented)
-1. [Making use of contribs](Starting/Starting-Part3)
-1. [Making a custom Character](Starting/Implementing-a-game-rule-system)
+1. [Some useful Contribs](Starting/Part2/Some-Useful-Contribs)
+
+### Part3: How we get there
+
+1. [Introduction & Overview](Starting/Starting-Part3)
+1. [Making a custom Character](Starting/Part3/Implementing-a-game-rule-system)
 1. [Character generation](../Unimplemented)
 1. [Resolving skills and challenges](../Unimplemented)
-1. [NPCs and mobiles](Starting/Coordinates)
+1. [NPCs and mobiles](./Coordinates)
 1. [Quests and Zones](../Unimplemented)
 1. [A Combat system](../Unimplemented)
 
@@ -51,8 +55,8 @@ in mind for your own game, this will give you a good start.
 ### Part 5: Showing the world
 
 1. [Introduction & Overview](Starting/Starting-Part5)
-1. [Add a web page](Starting/Add-a-simple-new-web-page)
-1. [More on adding web features](Starting/Web-Tutorial)
+1. [Add a web page](Starting/Part5/Add-a-simple-new-web-page)
+1. [More on adding web features](Starting/Part5/Web-Tutorial)
 1. [Taking your game online](../Unimplemented)
 1. [Next steps](../Unimplemented)
 

docs/source/Howto/Manually-Configuring-Color.md

@@ -5,7 +5,7 @@ This is a small tutorial for customizing your character objects, using the examp
 turn on and off ANSI color parsing as an example.  `@options NOCOLOR=True` will now do what this
 tutorial shows, but the tutorial subject can be applied to other toggles you may want, as well.
 
-In the Building guide's [Colors](../Concept/TextTags#coloured-text) page you can learn how to add color to your
+In the Building guide's [Colors](../Concepts/TextTags#coloured-text) page you can learn how to add color to your
 game by using special markup. Colors enhance the gaming experience, but not all users want color.
 Examples would be users working from clients that don't support color, or people with various seeing
 disabilities that rely on screen readers to play your game. Also, whereas Evennia normally
@@ -26,7 +26,7 @@ configuration system for your characters. This is the basic sequence:
 Create a new module in `mygame/typeclasses` named, for example, `mycharacter.py`. Alternatively you
 can simply add a new class to 'mygamegame/typeclasses/characters.py'.
 
-In your new module(or characters.py), create a new [Typeclass](../Component/Typeclasses) inheriting from
+In your new module(or characters.py), create a new [Typeclass](../Components/Typeclasses) inheriting from
 `evennia.DefaultCharacter`. We will also import `evennia.utils.ansi`, which we will use later.
 
 ```python
@@ -39,7 +39,7 @@ In your new module(or characters.py), create a new [Typeclass](../Component/Type
             self.db.config_color = True
 ```
 
-Above we set a simple config value as an [Attribute](../Component/Attributes).
+Above we set a simple config value as an [Attribute](../Components/Attributes).
 
 Let's make sure that new characters are created of this type. Edit your
 `mygame/server/conf/settings.py` file and add/change `BASE_CHARACTER_TYPECLASS` to point to your new
@@ -158,7 +158,7 @@ class CharacterCmdSet(default_cmds.CharacterCmdSet):
 
 ## More colors
 
-Apart from ANSI colors, Evennia also supports **Xterm256** colors (See [Colors](../Concept/TextTags#colored-
+Apart from ANSI colors, Evennia also supports **Xterm256** colors (See [Colors](../Concepts/TextTags#colored-
 text)). The `msg()` method supports the `xterm256` keyword for manually activating/deactiving
 xterm256. It should be easy to expand the above example to allow players to customize xterm256
 regardless of if Evennia thinks their client supports it or not.

docs/source/Howto/NPC-shop-Tutorial.md

@@ -1,6 +1,6 @@
 # NPC shop Tutorial
 
-This tutorial will describe how to make an NPC-run shop. We will make use of the [EvMenu](../Component/EvMenu)
+This tutorial will describe how to make an NPC-run shop. We will make use of the [EvMenu](../Components/EvMenu)
 system to present shoppers with a menu where they can buy things from the store's stock.
 
 Our shop extends over two rooms - a "front" room open to the shop's customers and a locked "store
@@ -23,7 +23,7 @@ deducted and the goods transferred from the store room to the inventory of the c
 
 We want to show a menu to the customer where they can list, examine and buy items in the store. This
 menu should change depending on what is currently for sale. Evennia's *EvMenu* utility will manage
-the menu for us. It's a good idea to [read up on EvMenu](../Component/EvMenu) if you are not familiar with it.
+the menu for us. It's a good idea to [read up on EvMenu](../Components/EvMenu) if you are not familiar with it.
 
 #### Designing the menu
 
@@ -167,7 +167,7 @@ of the customer.
 #### The command to start the menu
 
 We could *in principle* launch the shopping menu the moment a customer steps into our shop room, but
-this would probably be considered pretty annoying. It's better to create a [Command](../Component/Commands) for
+this would probably be considered pretty annoying. It's better to create a [Command](../Components/Commands) for
 customers to explicitly wanting to shop around.
 
 ```python
@@ -200,7 +200,7 @@ class CmdBuy(Command):
 This will launch the menu. The `EvMenu` instance is initialized with the path to this very module -
 since the only global functions available in this module are our menu nodes, this will work fine
 (you could also have put those in a separate module). We now just need to put this command in a
-[CmdSet](../Component/Command-Sets) so we can add it correctly to the game:
+[CmdSet](../Components/Command-Sets) so we can add it correctly to the game:
 
 ```python
 from evennia import CmdSet
@@ -219,7 +219,7 @@ There are really only two things that separate our shop from any other Room:
 the shop.
 
 For testing we could easily add these features manually to a room using `@py` or other admin
-commands. Just to show how it can be done we'll instead make a custom [Typeclass](../Component/Typeclasses) for
+commands. Just to show how it can be done we'll instead make a custom [Typeclass](../Components/Typeclasses) for
 the shop room and make a small command that builders can use to build both the shop and the
 storeroom at once.
 
@@ -300,7 +300,7 @@ default-cmdset) before you can use it. Once having created the shop you can now
 `@open` a new exit to it. You could also easily expand the above command to automatically create
 exits to and from the new shop from your current location.
 
-To avoid customers walking in and stealing everything, we create a [Lock](../Component/Locks) on the storage
+To avoid customers walking in and stealing everything, we create a [Lock](../Components/Locks) on the storage
 door. It's a simple lock that requires the one entering to carry an object named
 `<shopname>-storekey`. We even create such a key object and drop it in the shop for the new shop
 keeper to pick up.
@@ -328,7 +328,7 @@ would then be gone and the counter be wrong - the shop would pass us the next it
 
 Fixing these issues are left as an exercise.
 
-If you want to keep the shop fully NPC-run you could add a [Script](../Component/Scripts) to restock the shop's
+If you want to keep the shop fully NPC-run you could add a [Script](../Components/Scripts) to restock the shop's
 store room regularly. This shop example could also easily be owned by a human Player (run for them
 by a hired NPC) - the shop owner would get the key to the store room and be responsible for keeping
 it well stocked.

docs/source/Howto/Parsing-command-arguments,-theory-and-best-practices.md

@@ -2,7 +2,7 @@
 
 
 This tutorial will elaborate on the many ways one can parse command arguments.  The first step after
-[adding a command](Part1/Adding-Commands) usually is to parse its arguments.  There are lots of
+[adding a command](Starting/Part1/Adding-Commands) usually is to parse its arguments.  There are lots of
 ways to do it, but some are indeed better than others and this tutorial will try to present them.
 
 If you're a Python beginner, this tutorial might help you a lot.  If you're already familiar with
@@ -652,7 +652,7 @@ about... what is this `"book"`?
 
 To get an object from a string, we perform an Evennia search.  Evennia provides a `search` method on
 all typeclassed objects (you will most likely use the one on characters or accounts).  This method
-supports a very wide array of arguments and has [its own tutorial](Part1/Searching-Things).
+supports a very wide array of arguments and has [its own tutorial](Starting/Part1/Searching-Things).
 Some examples of useful cases follow:
 
 ### Local searches

docs/source/Howto/Starting/Part1/Building-Quickstart.md

@@ -3,13 +3,13 @@
 [prev lesson](../Starting-Part1) | [next lesson](./Tutorial-World-Introduction)
 
 In this lesson we will test out what we can do in-game out-of-the-box. Evennia ships with 
-[around 90 default commands](../../../Component/Default-Command-Help), and while you can override those as you please, 
+[around 90 default commands](../../../Components/Default-Command-Help), and while you can override those as you please, 
 they can be quite useful.
 
 Connect and log into your new game and you will end up in the "Limbo" location. This 
 is the only room in the game at this point. Let's explore the commands a little.
 
-The default commands has syntax [similar to MUX](../../../Concept/Using-MUX-as-a-Standard):
+The default commands has syntax [similar to MUX](../../../Concepts/Using-MUX-as-a-Standard):
 
      command[/switch/switch...] [arguments ...]
 
@@ -127,14 +127,14 @@ dropped in the room, then try this:
 
     lock box = get:false()
 
-Locks represent a rather [big topic](../../../Component/Locks), but for now that will do what we want. This will lock
+Locks represent a rather [big topic](../../../Components/Locks), but for now that will do what we want. This will lock
 the box so noone can lift it. The exception is superusers, they override all locks and will pick it
 up anyway. Make sure you are quelling your superuser powers and try to get the box now:
 
     > get box
     You can't get that.
 
-Think thís default error message looks dull? The `get` command looks for an [Attribute](../../../Component/Attributes)
+Think thís default error message looks dull? The `get` command looks for an [Attribute](../../../Components/Attributes)
 named `get_err_msg` for returning a nicer error message (we just happen to know this, you would need
 to peek into the
 [code](https://github.com/evennia/evennia/blob/master/evennia/commands/default/general.py#L235) for
@@ -156,7 +156,7 @@ later, in the [Commands tutorial](./Adding-Commands).
 
 ## Get a Personality
 
-[Scripts](../../../Component/Scripts) are powerful out-of-character objects useful for many "under the hood" things.
+[Scripts](../../../Components/Scripts) are powerful out-of-character objects useful for many "under the hood" things.
 One of their optional abilities is to do things on a timer. To try out a first script, let's put one
 on ourselves. There is an example script in `evennia/contrib/tutorial_examples/bodyfunctions.py`
 that is called `BodyFunctions`. To add this to us we will use the `script` command:
@@ -185,14 +185,14 @@ When you are tired of your character's "insights", kill the script with
     script/stop self = tutorial_examples.bodyfunctions.BodyFunctions
 
 You create your own scripts in Python, outside the game; the path you give to `script` is literally
-the Python path to your script file. The [Scripts](../../../Component/Scripts) page explains more details.
+the Python path to your script file. The [Scripts](../../../Components/Scripts) page explains more details.
 
 ## Pushing Your Buttons
 
 If we get back to the box we made, there is only so much fun you can have with it at this point. It's
 just a dumb generic object. If you renamed it to `stone` and changed its description, noone would be
-the wiser. However, with the combined use of custom [Typeclasses](../../../Component/Typeclasses), [Scripts](../../../Component/Scripts)
-and object-based [Commands](../../../Component/Commands), you could expand it and other items to be as unique, complex
+the wiser. However, with the combined use of custom [Typeclasses](../../../Components/Typeclasses), [Scripts](../../../Components/Scripts)
+and object-based [Commands](../../../Components/Commands), you could expand it and other items to be as unique, complex
 and interactive as you want.
 
 Let's take an example. So far we have only created objects that use the default object typeclass
@@ -208,7 +208,7 @@ The same way we did with the Script Earler, we specify a "Python-path" to the Py
 to use for creating the object. There you go - one red button.
 
 The RedButton is an example object intended to show off a few of Evennia's features. You will find
-that the [Typeclass](../../../Component/Typeclasses) and [Commands](../../../Component/Commands) controlling it are 
+that the [Typeclass](../../../Components/Typeclasses) and [Commands](../../../Components/Commands) controlling it are 
 inside [evennia/contrib/tutorial_examples](api:evennia.contrib.tutorial_examples)
 
 If you wait for a while (make sure you dropped it!) the button will blink invitingly. 

docs/source/Howto/Starting/Part1/Django-queries.md

@@ -1,4 +1,4 @@
-## Django Database queries
+# Django Database queries
 
 [prev lesson](./Searching-Things) | [next lesson](../Starting-Part2)
 
@@ -184,7 +184,7 @@ will_transform = (
         
 Running this query makes our newly lycantrrophic Character appear in `will_transform`. Success! 
 
-> Don't confuse database fields with [Attributes](../../../Component/Attributes) you set via `obj.db.attr = 'foo'` or
+> Don't confuse database fields with [Attributes](../../../Components/Attributes) you set via `obj.db.attr = 'foo'` or
 `obj.attributes.add()`. Attributes are custom database entities *linked* to an object. They are not
 separate fields *on* that object like `db_key` or `db_location` are. 
 
@@ -390,7 +390,7 @@ in a format like the following:
 ]
 ```
 
-# Conclusions 
+## Conclusions 
 
 We have covered a lot of ground in this lesson and covered several more complex topics. Knowing how to 
 query using Django is a powerful skill to have. 

docs/source/Howto/Starting/Part1/Evennia-Library-Overview.md

@@ -53,25 +53,25 @@ This the the structure of the Evennia library:
 
  - evennia
    - [`__init__.py`](../../../Evennia-API#shortcuts) - The "flat API" of Evennia resides here. 
-   - [`settings_default.py`](../../../Component/Server-Conf#Settings-file) - Root settings of Evennia. Copy settings
+   - [`settings_default.py`](../../../Components/Server-Conf#Settings-file) - Root settings of Evennia. Copy settings
 from here to `mygame/server/settings.py` file.
-   - [`commands/`](../../../Component/Commands) - The command parser and handler.
-     - `default/` - The [default commands](../../../Component/Default-Command-Help) and cmdsets. 
-   - [`comms/`](../../../Component/Communications) - Systems for communicating in-game. 
+   - [`commands/`](../../../Components/Commands) - The command parser and handler.
+     - `default/` - The [default commands](../../../Components/Default-Command-Help) and cmdsets. 
+   - [`comms/`](../../../Components/Communications) - Systems for communicating in-game. 
    - `contrib/` - Optional plugins too game-specific for core Evennia.
    - `game_template/` - Copied to become the "game directory" when using `evennia --init`. 
-   - [`help/`](../../../Component/Help-System) - Handles the storage and  creation of help entries.
-   - `locale/` - Language files ([i18n](../../../Concept/Internationalization)).
-   - [`locks/`](../../../Component/Locks) - Lock system for restricting access to in-game entities.
-   - [`objects/`](../../../Component/Objects) - In-game entities (all types of items and Characters).
-   - [`prototypes/`](../../../Component/Spawner-and-Prototypes) - Object Prototype/spawning system and OLC menu
-   - [`accounts/`](../../../Component/Accounts) - Out-of-game Session-controlled entities (accounts, bots etc)
-   - [`scripts/`](../../../Component/Scripts) - Out-of-game entities equivalence to Objects, also with timer support. 
-   - [`server/`](../../../Component/Portal-And-Server) - Core server code and Session handling. 
+   - [`help/`](../../../Components/Help-System) - Handles the storage and  creation of help entries.
+   - `locale/` - Language files ([i18n](../../../Concepts/Internationalization)).
+   - [`locks/`](../../../Components/Locks) - Lock system for restricting access to in-game entities.
+   - [`objects/`](../../../Components/Objects) - In-game entities (all types of items and Characters).
+   - [`prototypes/`](../../../Components/Spawner-and-Prototypes) - Object Prototype/spawning system and OLC menu
+   - [`accounts/`](../../../Components/Accounts) - Out-of-game Session-controlled entities (accounts, bots etc)
+   - [`scripts/`](../../../Components/Scripts) - Out-of-game entities equivalence to Objects, also with timer support. 
+   - [`server/`](../../../Components/Portal-And-Server) - Core server code and Session handling. 
      - `portal/` - Portal proxy and connection protocols.
-   - [`typeclasses/`](../../../Component/Typeclasses) - Abstract classes for the typeclass storage and database system.
-   - [`utils/`](../../../Component/Coding-Utils) - Various miscellaneous useful coding resources.
-   - [`web/`](../../../Concept/Web-Features) - Web resources and webserver. Partly copied into game directory on initialization.
+   - [`typeclasses/`](../../../Components/Typeclasses) - Abstract classes for the typeclass storage and database system.
+   - [`utils/`](../../../Components/Coding-Utils) - Various miscellaneous useful coding resources.
+   - [`web/`](../../../Concepts/Web-Features) - Web resources and webserver. Partly copied into game directory on initialization.
 
 ```sidebar:: __init__.py
 

docs/source/Howto/Starting/Part1/Gamedir-Overview.md

@@ -59,7 +59,7 @@ and how you point to it correctly.
 
 ## commands/
 
-The `commands/` folder holds Python modules related to creating and extending the [Commands](../../../Component/Commands)
+The `commands/` folder holds Python modules related to creating and extending the [Commands](../../../Components/Commands)
 of Evennia. These manifest in game like the server understanding input like `look` or `dig`. 
 
 ```sidebar:: Classes
@@ -151,28 +151,28 @@ knows where they are and will read them to configure itself at startup.
 
 ### typeclasses/
 
-The [Typeclasses](../../../Component/Typeclasses) of Evennia are Evennia-specific Python classes whose instances save themselves
+The [Typeclasses](../../../Components/Typeclasses) of Evennia are Evennia-specific Python classes whose instances save themselves
 to the database. This allows a Character to remain in the same place and your updated strength stat to still
 be the same after a server reboot. 
 
 - [accounts.py](github:evennia/game_template/typeclasses/accounts.py) (Python-path: `typeclasses.accounts`) - An 
-    [Account](../../../Component/Accounts) represents the player connecting to the game. It holds information like email,
+    [Account](../../../Components/Accounts) represents the player connecting to the game. It holds information like email,
     password and other out-of-character details.
 - [channels.py](github:evennia/game_template/typeclasses/channels.py) (Python-path: `typeclasses.channels`) - 
-    [Channels](../../../Component/Channels) are used to manage in-game communication between players. 
+    [Channels](../../../Components/Channels) are used to manage in-game communication between players. 
 - [objects.py](github:evennia/game_template/typeclasses/objects.py) (Python-path: `typeclasses.objects`) - 
-   [Objects](../../../Component/Objects) represent all things having a location within the game world.
+   [Objects](../../../Components/Objects) represent all things having a location within the game world.
 - [characters.py](github:evennia/game_template/typeclasses/characters.py) (Python-path: `typeclasses.characters`) - 
-    The [Character](../../../Component/Objects#Characers) is a subclass of Objects, controlled by Accounts - they are the player's
+    The [Character](../../../Components/Objects#Characers) is a subclass of Objects, controlled by Accounts - they are the player's
     avatars in the game world.
 - [rooms.py](github:evennia/game_template/typeclasses/rooms.py) (Python-path: `typeclasses.rooms`) - A 
-    [Room](../../../Component/Objects#Room) is also a subclass of Object; describing discrete locations. While the traditional
+    [Room](../../../Components/Objects#Room) is also a subclass of Object; describing discrete locations. While the traditional
     term is 'room', such a location can be anything and on any scale that fits your game, from a forest glade, 
     an entire planet or an actual dungeon room.
 - [exits.py](github:evennia/game_template/typeclasses/exits.py) (Python-path: `typeclasses.exits`) - 
-    [Exits](../../../Component/Objects#Exit) is another subclass of Object. Exits link one Room to another. 
+    [Exits](../../../Components/Objects#Exit) is another subclass of Object. Exits link one Room to another. 
 - [scripts.py](github:evennia/game_template/typeclasses/scripts.py) (Python-path: `typeclasses.scripts`) - 
-    [Scripts](../../../Component/Scripts) are 'out-of-character' objects. They have no location in-game and can serve as basis for 
+    [Scripts](../../../Components/Scripts) are 'out-of-character' objects. They have no location in-game and can serve as basis for 
     anything that needs database persistence, such as combat, weather, or economic systems. They also
     have the ability to execute code repeatedly, on a timer. 
     
@@ -203,7 +203,7 @@ people change and re-structure this in various ways to better fit their ideas.
 - [batch_cmds.ev](github:evennia/game_template/world/batch_cmds.ev) - This is an `.ev` file, which is essentially
     just a list of Evennia commands to execute in sequence. This one is empty and ready to expand on. The 
     [Tutorial World](./Tutorial-World-Introduction) was built with such a batch-file.
-- [prototypes.py](github:evennia/game_template/world/prototypes.py) - A [prototype](../../../Component/Spawner-and-Prototypes) is a way
+- [prototypes.py](github:evennia/game_template/world/prototypes.py) - A [prototype](../../../Components/Spawner-and-Prototypes) is a way
     to easily vary objects without changing their base typeclass. For example, one could use prototypes to 
     tell that Two goblins, while both of the class 'Goblin' (so they follow the same code logic), should have different 
     equipment, stats and looks.

docs/source/Howto/Starting/Part1/Searching-Things.md

@@ -99,12 +99,12 @@ yourself and what you get back is now a list of zero, one or more matches!
 
 These are the main database entities one can search for:
 
-- [Objects](../../../Component/Objects)
-- [Accounts](../../../Component/Accounts)
-- [Scripts](../../../Component/Scripts),
-- [Channels](../../../Component/Communications#channels), 
+- [Objects](../../../Components/Objects)
+- [Accounts](../../../Components/Accounts)
+- [Scripts](../../../Components/Scripts),
+- [Channels](../../../Components/Communications#channels), 
 - [Messages](Communication#Msg) 
-- [Help Entries](../../../Component/Help-System).
+- [Help Entries](../../../Components/Help-System).
 
 Most of the time you'll likely spend your time searching for Objects and the occasional Accounts.
 
@@ -134,7 +134,7 @@ general search function. If we assume `room` is a particular Room instance,
 
 ### Search by Tags 
 
-Think of a [Tag](../../../Component/Tags) as the label the airport puts on your luggage when flying. 
+Think of a [Tag](../../../Components/Tags) as the label the airport puts on your luggage when flying. 
 Everyone going on the same plane gets a tag grouping them together so the airport can know what should 
 go to which plane. Entities in Evennia can be grouped in the same way. Any number of tags can be attached
 to each object. 
@@ -168,7 +168,7 @@ This gets all three books.
  
 ### Search by Attribute
 
-We can also search by the [Attributes](../../../Component/Attributes) associated with entities. 
+We can also search by the [Attributes](../../../Components/Attributes) associated with entities. 
 
 For example, let's give our rose thorns: 
 

docs/source/Howto/Starting/Part2/Game-Planning.md

@@ -125,18 +125,18 @@ gloss over this bit and jump directly to **World Building**. Vice versa, many "g
 tend to jump directly to this part without doing the **Planning** first. Neither way is good and
 *will* lead to you having to redo all your hard work at least once, probably more.
 
-Evennia's [Evennia Component overview](../../../Component/Component-Overview) tries to help you with this bit of development. We
+Evennia's [Evennia Component overview](../../../Components/Components-Overview) tries to help you with this bit of development. We
 also have a slew of [Tutorials](../../Howto-Overview) with worked examples. Evennia tries hard to make this
 part easier for you, but there is no way around the fact that if you want anything but a very basic
 Talker-type game you *will* have to bite the bullet and code your game (or find a coder willing to
 do it for you).
 
 Even if you won't code anything yourself, as a designer you need to at least understand the basic
-paradigms of Evennia, such as [Objects](../../../Component/Objects), 
-[Commands](../../../Component/Commands) and [Scripts](../../../Component/Scripts) and
+paradigms of Evennia, such as [Objects](../../../Components/Objects), 
+[Commands](../../../Components/Commands) and [Scripts](../../../Components/Scripts) and
 how they hang together. We recommend you go through the [Tutorial World](../Part1/Tutorial-World-Introduction) in detail (as well as glancing at its code) to get at least a feel for what is
 involved behind the scenes. You could also look through the tutorial for 
-[building a game from scratch](../Tutorial-for-basic-MUSH-like-game).
+[building a game from scratch](../Part3/Tutorial-for-basic-MUSH-like-game).
 
 During Coding you look back at the things you wanted during the **Planning** phase and try to
 implement them. Don't be shy to update your plans if you find things easier/harder than you thought.

docs/source/Howto/Starting/Part2/Some-Useful-Contribs.md

@@ -0,0 +1,3 @@
+# Some useful contribs
+
+TODO 

docs/source/Howto/Starting/Part3/Implementing-a-game-rule-system.md

@@ -45,12 +45,12 @@ makes it easier to change and update things in one place later.
 values for Health, a list of skills etc, store those things on the Character - don't store how to
 roll or change them.
 - Next is to determine just how you want to store things on your Objects and Characters. You can
-choose to either store things as individual [Attributes](../../Component/Attributes), like `character.db.STR=34` and
+choose to either store things as individual [Attributes](../../../Components/Attributes), like `character.db.STR=34` and
 `character.db.Hunting_skill=20`. But you could also use some custom storage method, like a
 dictionary `character.db.skills = {"Hunting":34, "Fishing":20, ...}`. A much more fancy solution is
 to look at the Ainneve [Trait
 handler](https://github.com/evennia/ainneve/blob/master/world/traits.py). Finally you could even go
-with a [custom django model](../../Concept/New-Models). Which is the better depends on your game and the
+with a [custom django model](../../../Concepts/New-Models). Which is the better depends on your game and the
 complexity of your system.
 - Make a clear [API](http://en.wikipedia.org/wiki/Application_programming_interface) into your
 rules. That is, make methods/functions that you feed with, say, your Character and which skill you

docs/source/Howto/Starting/Part3/Turn-based-Combat-System.md

@@ -31,7 +31,7 @@ allows for emoting as part of combat which is an advantage for roleplay-heavy ga
 To implement a freeform combat system all you need is a dice roller and a roleplaying rulebook. See
 [contrib/dice.py](https://github.com/evennia/evennia/blob/master/evennia/contrib/dice.py) for an
 example dice roller. To implement at twitch-based system you basically need a few combat
-[commands](../../Component/Commands), possibly ones with a [cooldown](../Command-Cooldown). You also need a [game rule
+[commands](../../../Components/Commands), possibly ones with a [cooldown](../../Command-Cooldown). You also need a [game rule
 module](Implementing-a-game-rule-system) that makes use of it. We will focus on the turn-based
 variety here.
 
@@ -61,22 +61,22 @@ reported. A new turn then begins.
 
 For creating the combat system we will need the following components:
 
-- A combat handler. This is the main mechanic of the system. This is a [Script](../../Component/Scripts) object
+- A combat handler. This is the main mechanic of the system. This is a [Script](../../../Components/Scripts) object
 created for each combat.  It is not assigned to a specific object but is shared by the combating
 characters and handles all the combat information. Since Scripts are database entities it also means
 that the combat will not be affected by a server reload.
-- A combat [command set](../../Component/Command-Sets) with the relevant commands needed for combat, such as the
+- A combat [command set](../../../Components/Command-Sets) with the relevant commands needed for combat, such as the
 various attack/defend options and the `flee/disengage` command to leave the combat mode.
 - A rule resolution system. The basics of making such a module is described in the [rule system
 tutorial](Implementing-a-game-rule-system). We will only sketch such a module here for our end-turn
 combat resolution.
-- An `attack` [command](../../Component/Commands) for initiating the combat mode. This is added to the default
+- An `attack` [command](../../../Components/Commands) for initiating the combat mode. This is added to the default
 command set. It will create the combat handler and add the character(s) to it. It will also assign
 the combat command set to the characters.
 
 ## The combat handler
 
-The _combat handler_ is implemented as a stand-alone [Script](../../Component/Scripts).  This Script is created when
+The _combat handler_ is implemented as a stand-alone [Script](../../../Components/Scripts).  This Script is created when
 the first Character decides to attack another and is deleted when no one is fighting any more. Each
 handler represents one instance of combat and one combat only. Each instance of combat can hold any
 number of characters but each character can only be part of one combat at a time (a player would
@@ -89,7 +89,7 @@ don't use this very much here this might allow the combat commands on the charac
 update the combat handler state directly.
 
 _Note: Another way to implement a combat handler would be to use a normal Python object and handle
-time-keeping with the [TickerHandler](../../Component/TickerHandler). This would require either adding custom hook
+time-keeping with the [TickerHandler](../../../Components/TickerHandler). This would require either adding custom hook
 methods on the character or to implement a custom child of the TickerHandler class to track turns.
 Whereas the TickerHandler is easy to use, a Script offers more power in this case._
 
@@ -506,7 +506,7 @@ class CmdAttack(Command):
 ```
 
 The `attack` command will not go into the combat cmdset but rather into the default cmdset. See e.g.
-the [Adding Command Tutorial](Part1/Adding-Commands) if you are unsure about how to do this.
+the [Adding Command Tutorial](../Part1/Adding-Commands) if you are unsure about how to do this.
 
 ## Expanding the example
 

docs/source/Howto/Starting/Part3/Tutorial-for-basic-MUSH-like-game.md

@@ -7,7 +7,7 @@ focused on free form storytelling. Even if you are not interested in MUSH:es, th
 first game-type to try since it's not so code heavy. You will be able to use the same principles for
 building other types of games.
 
-The tutorial starts from scratch. If you did the [First Steps Coding](./Starting-Part1) tutorial
+The tutorial starts from scratch. If you did the [First Steps Coding](../Starting-Part1) tutorial
 already you should have some ideas about how to do some of the steps already.
 
 The following are the (very simplistic and cut-down) features we will implement (this was taken from
@@ -61,7 +61,7 @@ class Character(DefaultCharacter):
         self.db.combat_score = 1
 ```
 
-We defined two new [Attributes](../../Component/Attributes) `power` and `combat_score` and set them to default
+We defined two new [Attributes](../../../Components/Attributes) `power` and `combat_score` and set them to default
 values. Make sure to `@reload` the server if you had it already running (you need to reload every
 time you update your python code, don't worry, no accounts will be disconnected by the reload).
 
@@ -94,8 +94,8 @@ check it. Using this method however will make it easy to add more functionality
 
 What we need are the following:
 
-- One character generation [Command](../../Component/Commands) to set the "Power" on the `Character`.  
-- A chargen [CmdSet](../../Component/Command-Sets) to hold this command. Lets call it `ChargenCmdset`.  
+- One character generation [Command](../../../Components/Commands) to set the "Power" on the `Character`.  
+- A chargen [CmdSet](../../../Components/Command-Sets) to hold this command. Lets call it `ChargenCmdset`.  
 - A custom `ChargenRoom` type that makes this set of commands available to players in such rooms.  
 - One such room to test things in.  
 
@@ -104,7 +104,7 @@ What we need are the following:
 For this tutorial we will add all our new commands to `mygame/commands/command.py` but you could
 split your commands into multiple module if you prefered.
 
-For this tutorial character generation will only consist of one [Command](../../Component/Commands) to set the
+For this tutorial character generation will only consist of one [Command](../../../Components/Commands) to set the
 Character s "power" stat. It will be called on the following MUSH-like form:
 
      +setpower 4
@@ -156,7 +156,7 @@ This is a pretty straightforward command. We do some error checking, then set th
 We use a `help_category` of "mush" for all our commands, just so they are easy to find and separate
 in the help list.
 
-Save the file. We will now add it to a new [CmdSet](../../Component/Command-Sets) so it can be accessed (in a full
+Save the file. We will now add it to a new [CmdSet](../../../Components/Command-Sets) so it can be accessed (in a full
 chargen system you would of course have more than one command here).
 
 Open `mygame/commands/default_cmdsets.py` and import your `command.py` module at the top. We also
@@ -210,7 +210,7 @@ class ChargenRoom(Room):
 ```
 Note how new rooms created with this typeclass will always start with `ChargenCmdset` on themselves.
 Don't forget the `permanent=True` keyword or you will lose the cmdset after a server reload. For
-more information about [Command Sets](../../Component/Command-Sets) and [Commands](../../Component/Commands), see the respective
+more information about [Command Sets](../../../Components/Command-Sets) and [Commands](../../../Components/Commands), see the respective
 links.
 
 ### Testing chargen
@@ -242,7 +242,7 @@ between fixes. Don't continue until the creation seems to have worked okay.
 This should bring you to the chargen room. Being in there you should now have the `+setpower`
 command available, so test it out. When you leave (via the `finish` exit), the command will go away
 and trying `+setpower` should now give you a command-not-found error. Use `ex me` (as a privileged
-user) to check so the `Power` [Attribute](../../Component/Attributes) has been set correctly.
+user) to check so the `Power` [Attribute](../../../Components/Attributes) has been set correctly.
 
 If things are not working, make sure your typeclasses and commands are free of bugs and that you
 have entered the paths to the various command sets and commands correctly. Check the logs or command
@@ -391,7 +391,7 @@ There are a few ways to define the NPC class. We could in theory create a custom
 and put a custom NPC-specific cmdset on all NPCs. This cmdset could hold all manipulation commands.
 Since we expect NPC manipulation to be a common occurrence among the user base however, we will
 instead put all relevant NPC commands in the default command set and limit eventual access with
-[Permissions and Locks](../../Component/Locks#Permissions).
+[Permissions and Locks](../../../Components/Locks#Permissions).
 
 ### Creating an NPC with +createNPC
 
@@ -443,13 +443,13 @@ class CmdCreateNPC(Command):
                                                 exclude=caller)        
 ```
 Here we define a `+createnpc` (`+createNPC` works too) that is callable by everyone *not* having the
-`nonpcs` "[permission](../../Component/Locks#Permissions)" (in Evennia, a "permission" can just as well be used to
+`nonpcs` "[permission](../../../Components/Locks#Permissions)" (in Evennia, a "permission" can just as well be used to
 block access, it depends on the lock we define). We create the NPC object in the caller's current
 location, using our custom `Character` typeclass to do so.
 
 We set an extra lock condition on the NPC, which we will use to check who may edit the NPC later --
 we allow the creator to do so, and anyone with the Builders permission (or higher). See
-[Locks](../../Component/Locks) for more information about the lock system.
+[Locks](../../../Components/Locks) for more information about the lock system.
 
 Note that we just give the object default permissions (by not specifying the `permissions` keyword
 to the `create_object()` call).  In some games one might want to give the NPC the same permissions
@@ -464,7 +464,7 @@ Since we re-used our custom character typeclass, our new NPC already has a *Powe
 defaults to 1. How do we change this?
 
 There are a few ways we can do this. The easiest is to remember that the `power` attribute is just a
-simple [Attribute](../../Component/Attributes) stored on the NPC object. So as a Builder or Admin we could set this
+simple [Attribute](../../../Components/Attributes) stored on the NPC object. So as a Builder or Admin we could set this
 right away with the default `@set` command:
 
      @set mynpc/power = 6
@@ -649,6 +649,6 @@ The simple "Power" game mechanic should be easily expandable to something more f
 useful, same is true for the combat score principle. The `+attack` could be made to target a
 specific player (or npc) and automatically compare their relevant attributes to determine a result.
 
-To continue from here, you can take a look at the [Tutorial World](Part1/Tutorial-World-Introduction). For
-more specific ideas, see the [other tutorials and hints](../Howto-Overview) as well
-as the [Evennia Component overview](../../Component/Component-Overview).
+To continue from here, you can take a look at the [Tutorial World](../Part1/Tutorial-World-Introduction). For
+more specific ideas, see the [other tutorials and hints](../../Howto-Overview) as well
+as the [Evennia Component overview](../../../Components/Components-Overview).

docs/source/Howto/Starting/Part5/Web-Tutorial.md

@@ -5,7 +5,7 @@ Evennia uses the [Django](https://www.djangoproject.com/) web framework as the b
 database configuration and the website it provides. While a full understanding of Django requires
 reading the Django documentation, we have provided this tutorial to get you running with the basics
 and how they pertain to Evennia. This text details getting everything set up. The 
-[Web-based Character view Tutorial](../Web-Character-View-Tutorial) gives a more explicit example of making a
+[Web-based Character view Tutorial](../../Web-Character-View-Tutorial) gives a more explicit example of making a
 custom web page connected to your game, and you may want to read that after finishing this guide.
 
 ## A Basic Overview
@@ -25,7 +25,7 @@ like [CSS](http://en.wikipedia.org/wiki/CSS), [Javascript](http://en.wikipedia.o
 and Image files (You may note your mygame/web folder does not have a `static` or `template` folder.
 This is intended and explained further below). Django applications may also have a `models.py` file
 for storing information in the database. We will not change any models here, take a look at the 
-[New Models](../../Concept/New-Models) page (as well as the [Django docs](https://docs.djangoproject.com/en/1.7/topics/db/models/) on models) if you are interested.
+[New Models](../../../Concepts/New-Models) page (as well as the [Django docs](https://docs.djangoproject.com/en/1.7/topics/db/models/) on models) if you are interested.
 
 There is also a root `urls.py` that determines the URL structure for the entire project. A starter
 `urls.py` is included in the default game template, and automatically imports all of Evennia's
@@ -104,7 +104,7 @@ run any extra commands to see these changes - reloading the web page in your bro
 
 To replace the index page's text, we'll need to find the template for it. We'll go into more detail
 about how to determine which template is used for rendering a page in the 
-[Web-based Character view Tutorial](../Web-Character-View-Tutorial). For now, you should know that the template we want to change
+[Web-based Character view Tutorial](../../Web-Character-View-Tutorial). For now, you should know that the template we want to change
 is stored in `evennia/web/website/templates/website/index.html`.
 
 To replace this template file, you will put your changed template inside the
@@ -120,7 +120,7 @@ original file already has all the markup and tags, ready for editing.
 ## Further reading
 
 For further hints on working with the web presence, you could now continue to the 
-[Web-based Character view Tutorial](../Web-Character-View-Tutorial) where you learn to make a web page that
+[Web-based Character view Tutorial](../../Web-Character-View-Tutorial) where you learn to make a web page that
 displays in-game character stats. You can also look at [Django's own
 tutorial](https://docs.djangoproject.com/en/1.7/intro/tutorial01/) to get more insight in how Django
 works and what possibilities exist.

docs/source/Howto/Starting/Starting-Part1.md

@@ -1,43 +1,51 @@
-# Evennia Starting Tutorial (Part 1)
+# Starting Tutorial (Part 1)
 
-  [Next lesson](Part1/Building-Quickstart)
+[Start](Part1/Building-Quickstart)
   
-This is a multi-part Tutorial that will gradually take you from first installation to making your 
-own first little game in Evennia. Let's get started! 
+```sidebar:: Tutorial Parts
 
-```sidebar:: Parts of the Starting tutorial
-
-  **Part 1**: What we have
+  **Part 1: What we have**
     A tour of Evennia and how to use the tools, including an introduction to Python.
-  Part 2: `What we want <Starting-Part2>`_
+  Part 2: `What we want <./Starting-Part2.html>`_
     Planning our tutorial game and what to think about when planning your own in the future.
-  Part 3: `How we get there <Starting-Part3>`_ 
+  Part 3: `How we get there <./Starting-Part3.html>`_ 
        Getting down to the meat of extending Evennia to make our game
-  Part 4: `Using what we created <Starting-Part4>`_
+  Part 4: `Using what we created <./Starting-Part4.html>`_
     Building a tech-demo and world content to go with our code
-  Part 5: `Showing the world <Starting-Part5>`_
+  Part 5: `Showing the world <./Starting-Part5.html>`_
     Taking our new game online and let players try it out
 ```
 
+Welcome to Evennia! This multi-part Tutorial will help you get off the ground. It consists
+of five parts, each with several lessons. You can pick what seems interesting, but if you 
+follow through to the end you will have created a little online game of your own to play 
+and share with others! 
+
 ## Lessons of Part 1 - "What we have"
 
-1. Introduction & Overview (you are here)
-1. [Building stuff](Part1/Building-Quickstart)
-1. [The Tutorial World](Part1/Tutorial-World-Introduction)
-1. [Python basics](Part1/Python-basic-introduction)
-1. [Game dir overview](Part1/Gamedir-Overview)
-1. [Python classes and objects](Part1/Python-classes-and-objects)
-1. [Accessing the Evennia library](Part1/Evennia-Library-Overview)
-1. [Typeclasses - Persistent objects](Part1/Learning-Typeclasses)
-1. [Making our first own commands](Part1/Adding-Commands)
-1. [Parsing and replacing default Commands](Part1/More-on-Commands)
-1. [Creating things](Part1/Creating-Things)
-1. [Searching for things](Part1/Searching-Things)
-1. [Advanced searching with Django queries](Part1/Django-queries)
+```toctree::
+    :numbered: 
+    :maxdepth: 1
+
+    Building stuff <Part1/Building-Quickstart>
+    The Tutorial World <Part1/Tutorial-World-Introduction>
+    Python basics <Part1/Python-basic-introduction>
+    Game dir overview <Part1/Gamedir-Overview>
+    Python classes and objects <Part1/Python-classes-and-objects>
+    Accessing the Evennia library <Part1/Evennia-Library-Overview>
+    Typeclasses and Persistent objects <Part1/Learning-Typeclasses>
+    Making first own Commands <Part1/Adding-Commands>
+    Parsing and replacing default Commands <Part1/More-on-Commands>
+    Creating things <Part1/Creating-Things>
+    Searching for things <Part1/Searching-Things>
+    Advanced searching with Django queries <Part1/Django-queries>
+```
 
 In this first part we'll focus on what we get out of the box in Evennia - we'll get used to the tools,
-where things are and how we find things we are looking for. We will also dive into some of things you'll 
-need to know to fully utilize the system, including giving a brief rundown of Python concepts. 
+and how to find things we are looking for. We will also dive into some of things you'll 
+need to know to fully utilize the system, including giving you a brief rundown of Python concepts. If you are
+an experienced Python programmer, some sections may feel a bit basic, but you will at least not have seen 
+these concepts in the context of Evennia before. 
 
 ## Things you will need 
 
@@ -106,4 +114,4 @@ first enter that gamedir and run
 
   You should now be good to go!  
   
-  [Next lesson](Part1/Building-Quickstart)
+  [Start](Part1/Building-Quickstart)

docs/source/Howto/Starting/Starting-Part2.md

@@ -1,17 +1,28 @@
 # Evennia Starting Tutorial (Part 2)
 
-```sidebar:: Parts of the Starting tutorial
+```sidebar:: Tutorial Parts
 
-  **Part 1**: What we have
+  Part 1: `What we have <./Starting-Part1.html>`_
     A tour of Evennia and how to use the tools, including an introduction to Python.
-  Part 2: `What we want <Starting-Part2>`_
+  **Part 2: What we want**
     Planning our tutorial game and what to think about when planning your own in the future.
-  Part 3: `How we get there <Starting-Part3>`_ 
+  Part 3: `How we get there <./Starting-Part3.html>`_ 
        Getting down to the meat of extending Evennia to make our game
-  Part 4: `Using what we created <Starting-Part4>`_
+  Part 4: `Using what we created <./Starting-Part4.html>`_
     Building a tech-demo and world content to go with our code
-  Part 5: `Showing the world <Starting-Part5>`_
+  Part 5: `Showing the world <./Starting-Part5.html>`_
     Taking our new game online and let players try it out
 ```
 
 ## Lessons for Part 2
+
+1. Introduction & Overview (you are here)
+1. [On planning a game](Part2/Game-Planning)
+1. [Multisession modes](../../Unimplemented)
+1. [Layout of our tutorial game](../../Unimplemented)
+1. [Some useful Contribs](Part2/Some-Useful-Contribs)
+
+In Part two of the Starting tutorial we'll step back and plan out the kind of tutorial 
+game we want to make. In the process we'll go through the common questions of "where to start"
+and "what to think about" when creating a multiplayer online text game. We'll also look at 
+some useful Evennia settings to tweak and designs to consider.

docs/source/Howto/Starting/Starting-Part3.md

@@ -1 +1,19 @@
-# Evennia Starting Tutorial (Part 3)
+# Evennia Starting Tutorial (Part 3)
+
+```sidebar:: Tutorial Parts
+
+  Part 1: `What we have <./Starting-Part1.html>`_
+    A tour of Evennia and how to use the tools, including an introduction to Python.
+  Part 2: `What we want <./Starting-Part2.html>`_
+    Planning our tutorial game and what to think about when planning your own in the future.
+  **Part 3: How we get there**
+       Getting down to the meat of extending Evennia to make our game
+  Part 4: `Using what we created <./Starting-Part4.html>`_
+    Building a tech-demo and world content to go with our code
+  Part 5: `Showing the world <./Starting-Part5.html>`_
+    Taking our new game online and let players try it out
+```
+
+Now that we have a good idea of what we want, we need to actually implement it. In part three of the 
+Starting tutorial will go through the creation of several key parts of our game. As we go, we will 
+test each part and create a simple "tech demo" to show off all the moving parts. 

docs/source/Howto/Starting/Starting-Part4.md

@@ -1,3 +1,21 @@
 # Evennia Starting Tutorial (Part 4)
 
-TODO. 
+```sidebar:: Tutorial Parts
+
+  Part 1: `What we have <./Starting-Part1.html>`_
+    A tour of Evennia and how to use the tools, including an introduction to Python.
+  Part 2: `What we want <./Starting-Part2.html>`_
+    Planning our tutorial game and what to think about when planning your own in the future.
+  Part 3: `How we get there <./Starting-Part3.html>`_ 
+       Getting down to the meat of extending Evennia to make our game to make a tech-demo
+  **Part 4: Using what we created**
+    Using the tech-demo and world content to go with our code
+  Part 5: `Showing the world <./Starting-Part5.html>`_
+    Taking our new game online and let players try it out
+``` 
+
+We now have the code underpinnings of everything we need. We have also tested the various components 
+and has a simple tech-demo to show it all works together. But there is no real coherence to it at this
+point - we need to actually make a world. 
+In part four we will expand our tech demo into a more full-fledged (if small) game by use of batchcommand
+and batchcode processors. 

docs/source/Howto/Starting/Starting-Part5.md

@@ -1 +1,19 @@
-# Evennia Starting Tutorial (part 5)
+# Evennia Starting Tutorial (part 5)
+
+```sidebar:: Tutorial Parts
+
+  Part 1: `What we have <./Starting-Part1.html>`_
+    A tour of Evennia and how to use the tools, including an introduction to Python.
+  Part 2: `What we want <./Starting-Part2.html>`_
+    Planning our tutorial game and what to think about when planning your own in the future.
+  Part 3: `How we get there <./Starting-Part3.html>`_ 
+       Getting down to the meat of extending Evennia to make our game
+  Part 4: `Using what we created <./Starting-Part4.html>`_
+    Building a tech-demo and world content to go with our code
+  **Part 5: Showing the world**
+    Taking our new game online and let players try it out
+```
+
+You have a working game! In part five we will look at the web-components of Evennia and how to modify them
+to fit your game. We will also look at hosting your game and if you feel up to it we'll also go through how 
+to bring your game online so you can invite your first players. 

docs/source/Howto/Tutorial-Aggressive-NPCs.md

@@ -5,17 +5,17 @@ This tutorial shows the implementation of an NPC object that responds to charact
 location. In this example the NPC has the option to respond aggressively or not, but any actions
 could be triggered this way.
 
-One could imagine using a [Script](../Component/Scripts) that is constantly checking for newcomers. This would be
+One could imagine using a [Script](../Components/Scripts) that is constantly checking for newcomers. This would be
 highly inefficient (most of the time its check would fail). Instead we handle this on-demand by
 using a couple of existing object hooks to inform the NPC that a Character has entered.
 
 It is assumed that you already know how to create custom room and character typeclasses, please see
-the [Basic Game tutorial](Starting/Tutorial-for-basic-MUSH-like-game) if you haven't already done this.
+the [Basic Game tutorial](Starting/Part3/Tutorial-for-basic-MUSH-like-game) if you haven't already done this.
 
 What we will need is the following: 
 
 - An NPC typeclass that can react when someone enters.
-- A custom [Room](../Component/Objects#rooms) typeclass that can tell the NPC that someone entered.
+- A custom [Room](../Components/Objects#rooms) typeclass that can tell the NPC that someone entered.
 - We will also tweak our default `Character` typeclass a little. 
 
 To begin with, we need to create an NPC typeclass. Create a new file inside of your typeclasses

docs/source/Howto/Tutorial-NPCs-listening.md

@@ -6,7 +6,7 @@ their location. In this example the NPC parrots what is said, but any actions co
 this way.
 
 It is assumed that you already know how to create custom room and character typeclasses, please see
-the [Basic Game tutorial](Starting/Tutorial-for-basic-MUSH-like-game) if you haven't already done this.
+the [Basic Game tutorial](Starting/Part3/Tutorial-for-basic-MUSH-like-game) if you haven't already done this.
 
 What we will need is simply a new NPC typeclass that can react when someone speaks.