Prep docs for branch move

docs/source/Howtos/Beginner-Tutorial/Part1/Beginner-Tutorial-Building-Quickstart.md

@@ -132,10 +132,7 @@ up anyway. Make sure you are quelling your superuser powers and try to get the b
     You can't get that.
 
 Think this default error message looks dull? The `get` command looks for an [Attribute](../../../Components/Attributes.md)
-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
-the `get` command to find out.). You set attributes using the `set` command:
+named `get_err_msg` for returning a nicer error messageod (this can be seen from the default `get` command code). You set attributes using the `set` command:
 
     set box/get_err_msg = It's way too heavy for you to lift.
 

docs/source/Howtos/Beginner-Tutorial/Part5/Add-a-simple-new-web-page.md

@@ -75,7 +75,7 @@ If you'd rather not take advantage of Evennia's base styles, you can do somethin
 When you enter the address `http://localhost:4001/story` in your web browser, Django will parse that
 field to figure out which page you want to go to. You tell it which patterns are relevant in the
 file
-[mygame/web/urls.py](https://github.com/evennia/evennia/blob/master/evennia/game_template/web/urls.py).
+[mygame/web/urls.py](https://github.com/evennia/evennia/blob/main/evennia/game_template/web/urls.py).
 Open it now
 
 Django looks for the variable `urlpatterns` in this file. You want to add your new pattern to the

docs/source/Howtos/Implementing-a-game-rule-system.md

@@ -46,15 +46,8 @@ values for Health, a list of skills etc, store those things on the Character - d
 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](../Components/Attributes.md), 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](../Concepts/Models.md). Which is the better depends on your game and the
-complexity of your system.
-- Make a clear [API](https://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
-want to check. That is, you want something similar to this:
+`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 [Trait handler contrib](../Contribs/Contrib-Traits.md). Finally you could even go with a [custom django model](../Concepts/Models.md). Which is the better depends on your game and the complexity of your system.
+- Make a clear [API](https://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 want to check. That is, you want something similar to this:
 
     ```python
         from world import rules
@@ -66,8 +59,7 @@ You might need to make these functions more or less complex depending on your ga
 
 ## Coded systems
 
-Inspired by tabletop role playing games, most game systems mimic some sort of die mechanic. To this end Evennia offers a full [dice roller](https://github.com/evennia/evennia/blob/master/evennia/contrib/dice.py) in its `contrib`
-folder. For custom implementations, Python offers many ways to randomize a result using its in-built `random` module. No matter how it's implemented, we will in this text refer to the action of determining an outcome as a "roll".
+Inspired by tabletop role playing games, most game systems mimic some sort of die mechanic. To this end Evennia offers a full [dice roller contribution](../Contribs/Contrib-Dice.md). For custom implementations, Python offers many ways to randomize a result using its in-built `random` module. No matter how it's implemented, we will in this text refer to the action of determining an outcome as a "roll".
 
 In a freeform system, the result of the roll is just compared with values and people (or the game
 master) just agree on what it means. In a coded system the result now needs to be processed somehow. There are many things that may happen as a result of rule enforcement:

docs/source/Howtos/Turn-based-Combat-System.md

@@ -13,7 +13,7 @@ Most MUDs will use some sort of combat system. There are several main variations
 - _Twitch_ - This is the traditional MUD hack&slash style combat. In a twitch system there is often no difference between your normal "move-around-and-explore mode" and the "combat mode". You enter an attack command and the system will calculate if the attack hits and how much damage was caused. Normally attack commands have some sort of timeout or notion of recovery/balance to reduce the advantage of spamming or client scripting. Whereas the simplest systems just means entering `kill <target>` over and over, more sophisticated twitch systems include anything from defensive stances to tactical positioning.
 - _Turn-based_ - a turn based system means that the system pauses to make sure all combatants can choose their actions before continuing. In some systems, such entered actions happen immediately (like twitch-based) whereas in others the resolution happens simultaneously at the end of the turn. The disadvantage of a turn-based system is that the game must switch to a "combat mode" and one also needs to take special care of how to handle new combatants and the passage of time. The advantage is that success is not dependent on typing speed or of setting up quick client macros. This potentially allows for emoting as part of combat which is an advantage for roleplay-heavy games.
 
-To implement a freeform combat system all you need is a dice roller and a roleplaying rulebook. See [contrib/dice.py](Contrib-Dice) for an example dice roller. To implement at twitch-based system you basically need a few combat [commands](../Components/Commands.md), possibly ones with a [cooldown](./Howto-Command-Cooldown.md). You also need a [game rule module](./Implementing-a-game-rule-system.md) that makes use of it. We will focus on the turn-based variety here. 
+To implement a freeform combat system all you need is a dice roller and a roleplaying rulebook. See [contrib/dice.py](../Contribs/Contrib-Dice.md) for an example dice roller. To implement at twitch-based system you basically need a few combat [commands](../Components/Commands.md), possibly ones with a [cooldown](./Howto-Command-Cooldown.md). You also need a [game rule module](./Implementing-a-game-rule-system.md) that makes use of it. We will focus on the turn-based variety here. 
 
 ## Tutorial overview
 

docs/source/Howtos/Tutorial-for-basic-MUSH-like-game.md

@@ -334,9 +334,8 @@ this:
     This is a great warrior.
 
 We don't actually have to modify the `look` command itself however. To understand why, take a look
-at how the default `look` is actually defined. It sits in `evennia/commands/default/general.py` (or
-browse it online
-[here](https://github.com/evennia/evennia/blob/master/evennia/commands/default/general.py#L44)).
+at how the default `look` is actually defined. It sits in [evennia/commands/default/general.py](evennia.commands.default.general).
+
 You will find that the actual return text is done by the `look` command calling a *hook method*
 named `return_appearance` on the object looked at. All the `look` does is to echo whatever this hook
 returns.  So what we need to do is to edit our custom Character typeclass and overload its
@@ -344,10 +343,9 @@ returns.  So what we need to do is to edit our custom Character typeclass and ov
 comes into play for real).
 
 Go back to your custom Character typeclass in `mygame/typeclasses/characters.py`. The default
-implementation of `return appearance` is found in  `evennia.DefaultCharacter` (or online
-[here](https://github.com/evennia/evennia/blob/master/evennia/objects/objects.py#L1438)).  If you
-want to make bigger changes you could copy & paste the whole default thing into our overloading
-method. In our case the change is small though:
+implementation of `return appearance` is found in  [evennia.DefaultCharacter](evennia.objects.objects.DefaultCharacter).
+
+If you  want to make bigger changes you could copy & paste the whole default thing into our overloading method. In our case the change is small though:
 
 ```python
 class Character(DefaultCharacter):