<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>Teraum</title>
    <link>https://teraum.writeas.com/</link>
    <description>A tragically funny fantasy multiplayer role-playing game.</description>
    <pubDate>Tue, 17 Nov 2026 00:03:03 +0000</pubDate>
    <item>
      <title>Anatomy of Things</title>
      <link>https://teraum.writeas.com/anatomy-of-things?pk_campaign=rss-feed</link>
      <description>Introduction Enclosing variables Manipulating Enclosed Variables Passing Lambdas Around Things Introduction In this post I&#39;d like to expl...</description>
      <content:encoded><![CDATA[<ol><li><a href="#orga2e47f3" rel="nofollow ugc">Introduction</a></li>
<li><a href="#org78003b4" rel="nofollow ugc">Enclosing variables</a></li>
<li><a href="#orga3d52b4" rel="nofollow ugc">Manipulating Enclosed Variables</a></li>
<li><a href="#org383566a" rel="nofollow ugc">Passing Lambdas Around</a></li>
<li><a href="#org68157a0" rel="nofollow ugc">Things</a></li></ol>

<p><a id="orga2e47f3"></a></p>

<h2 id="introduction">Introduction</h2>

<p>In this post I&#39;d like to explain how <em>things</em> (in-game objects) work. (This will also, incidentally, be a short tutorial on <em>lambda calculus</em> and <em>closures</em>.)</p>

<p>In the language of game design, <em>Racket-MUD</em> uses a type <a href="https://en.wikipedia.org/wiki/Entity_component_system" rel="nofollow ugc">“entity component system,”</a> more or less. I call it <em>quality of things</em>, and developed it mostly in the isolation of solitary hacking, so there are some differences.</p>

<p>Everything a user interacts with inside <em>Racket-MUD</em> is a <em>thing</em>, and every <em>thing</em> has <em>qualities</em>, which define its capabilities.</p>

<p>From the user&#39;s perspective, a <em>thing</em> is a loaf of bread, a field, a starship, or even abstract <em>things</em> like jealousy: it all depends on the sort of MUD being implemented.</p>

<p>From the engine&#39;s perspective, a <em>thing</em> is a function, into which functions are thrown, and out of which comes a function.</p>

<hr/>

<p><a id="org78003b4"></a></p>

<h2 id="enclosing-variables">Enclosing variables</h2>

<p>Let&#39;s forget about <em>things</em> for a moment and look at some more generic code.</p>

<pre><code>    (define alef 7)
</code></pre>

<p>What&#39;s this do? It defines <code>alef</code> as <code>7</code>. Simple enough.</p>

<pre><code>    (define bet
      (λ () 7))
</code></pre>

<p>What does this one do? It defines <code>bet</code> as a function, that returns <code>7</code>. (<code>(λ () 7)</code> breaks down to “make a function (<code>λ</code>) that takes zero arguments (<code>()</code>) and returns <code>7</code>.“)</p>

<p>By-the-by, that <code>λ</code> symbol? That&#39;s the lowercase “lambda” character from the Greek alphabet; it&#39;s used in a few programming languages (and branches of mathematics) to mean “a function.”</p>

<pre><code>    alef  ; -&gt; 7
    bet   ; -&gt; &lt;#procedure:bet&gt;
    (bet) ; -&gt; 7
</code></pre>

<p>Calling <code>alef</code> returns <code>7</code>, but calling <code>bet</code> returns a procedure – so, we have to call that procedure, by doing <code>(bet)</code>: and now we get our <code>7</code>.</p>

<p>Pretty simple. Let&#39;s build on this.</p>

<pre><code>    (define gimel
      (λ ()
        (define num 7)
        (λ () num)))
</code></pre>

<p>Less simple: there are two of those <code>λ</code> things. We know that calling <code>gimel</code> will return a function: let&#39;s look at what that function actually would contain:</p>

<pre><code>    (define num 7)
    (λ () num)
</code></pre>

<p>So, first, it&#39;s defining <code>num</code> as <code>7</code> and then… it returns a function, that we can see, takes no arguments, and returns <code>num</code>. So how do we use <code>gimel</code>?</p>

<pre><code>    gimel     ; -&gt; &lt;#procedure:gimel&gt;
    (gimel)   ; -&gt; &lt;#procedure&gt;
    ((gimel)) ; -&gt; 7
</code></pre>

<p>Well, we&#39;ve certainly added complexity, but there hasn&#39;t been any new capabilities added.</p>

<pre><code>    (define dalet
      (λ ()
        (define num 7)
        (λ () (+ 1 num))))
</code></pre>

<p>Here, we&#39;ve replaced returning num with returning <code>(+ 1 num)</code>.</p>

<p>So, running these we get:</p>

<pre><code>    dalet     ; &lt;#procedure:dalet&gt;
    (dalet)   ; &lt;#procedure&gt;
    ((dalet)) ; 8
</code></pre>

<p><a id="orga3d52b4"></a></p>

<h2 id="manipulating-enclosed-variables">Manipulating Enclosed Variables</h2>

<p>Now we&#39;re getting somewhere. Let&#39;s add some more capabilities. Here, we&#39;re going to make it so that the procedure returned by the outer-function is capable of taking an argument; that&#39;ll be added (<code>+</code>) to <code>num</code>.</p>

<pre><code>    (define he
      (λ ()
        (define num 7)
        (λ (x) (+ x num))))
</code></pre>

<p>So now we can do:</p>

<pre><code>    he        ; &lt;#procedure:he&gt;
    (he)      ; &lt;#procedure&gt;
    ((he) 1)  ; 8
    ((he) 10) ; 17
</code></pre>

<p>Now that&#39;s something! Let&#39;s rename the function we&#39;ve been working on to make what it does more clear.</p>

<pre><code>    (define add-to-seven
      (λ ()
        (define seven 7)
        (λ (x) (+ x seven))))
</code></pre>

<p>Maybe now the point of <em>why</em> I&#39;ve done this will be a little more clear: we&#39;ve created a bit of data, <code>seven</code>, and it&#39;s held inside the function. Basically, all we can do is ask the function, “what would happen if we added <em>x</em> to 7?”</p>

<p>Let&#39;s make it a bit more general.</p>

<p><a id="org383566a"></a></p>

<h2 id="passing-lambdas-around">Passing Lambdas Around</h2>

<pre><code>      (define do-to-seven
        (λ ()
          (define seven 7)
          (λ (f) (f seven))))
</code></pre>

<p>We&#39;ve changed the returned function here: now it doesn&#39;t take <code>x</code> and return the result of <code>(+ x seven)</code>. It takes <code>f</code> and returns the result of <code>(f seven)</code>.</p>

<p>You might be able to infer that <code>f</code> is intended to be a function, not a number, and that it needs to take one argument, and that argument will be seven. Let&#39;s play around with this.</p>

<pre><code>    do-to-seven ; &lt;#procedure:do-to-seven&gt;
    (do-to-seven) ; &lt;#procedure&gt;
</code></pre>

<p>Y&#39;know these nested parantheses aren&#39;t always that easy to read. Let&#39;s switch up the style a bit.</p>

<pre><code>    (define seven-doer (do-to-seven))
    seven-doer ; &lt;#procedure&gt;
</code></pre>

<p>Alright – now we can directly access the enclosed function, <code>(λ (f) (f seven))</code>, with <code>seven-doer</code>. Let&#39;s move on.</p>

<pre><code>    (seven-doer
     (λ (S) S)) ; -&gt; 7
</code></pre>

<p>What does this do? It calls <code>seven-doer</code>, passing it a lambda function that takes one argument, <code>S</code>, and returns <code>S</code>. This returns <code>7</code>. Let&#39;s see how, by looking how the statement <strong><em>expands</em></strong>. First, the code above turns into, more-or-less:</p>

<pre><code>    ((λ (f) (f seven)) (λ (S) S))
</code></pre>

<p>Ew. Hard to read, but try to follow the parantheses. The whole thing is one statement, with two parts: the first is a lambda function that takes <code>f</code> and returns <code>(f seven)</code>, and the second is a lambda function that takes <code>S</code> and returns <code>S</code>.</p>

<p>The first part of the statement is treated as a function, and the second part is its argument, so the next step from here is to pass the second part into the first part. We get to</p>

<pre><code>    ((λ (S) S) seven)
</code></pre>

<p>(That is, <code>(f seven)</code> when <code>f</code> is <code>(λ (S) S)</code>.)</p>

<p>So, from here, we pass <code>seven</code> into the lambda function, which just returns whatever <code>seven</code> is, in this case, <code>7</code>.</p>

<p>Phew! That was a lot. The point is, now, we have a function that we can ask, “Hey, show me what would happen if I do the following to 7…“</p>

<p>…and “the following” can be just about anything you think of. Like, say, doubling it.</p>

<pre><code>    (define double
      (λ (x) (* x 2))) ; -&gt; &lt;#procedure:double&gt;
    
    (do-to-seven double) ; -&gt; 14
</code></pre>

<p>Now, this is a lot of semantic overhead for what is essentially <code>(* 7 2)</code>. but let&#39;s see how this relates to <em>Racket-MUD</em>&#39;s <em>things</em>.</p>

<p><a id="org68157a0"></a></p>

<h2 id="things">Things</h2>

<pre><code>    (define thing-maker
      (λ (name)
        (let ([thing (make-hash
    		  (list
    		   (cons &#39;name name)))])
          (λ (f) (f thing)))))
</code></pre>

<p><em>(This isn&#39;t actually the code for making a thing, just a simple version for explaining the concepts.)</em></p>

<p>Let&#39;s pull this apart:</p>

<p><code>thing-maker</code> is a function that takes one argument, <code>name</code>, creates a hash-table called <code>thing</code> to store the name, and returns a function that takes one argument, <code>f</code>, and returns the result of <code>(f thing)</code>.</p>

<pre><code>    (define bob (thing-maker &#34;Bob&#34;)) ; &lt;#procedure&gt;
    (bob (λ (thing) (hash-ref thing &#39;name))) ; &#34;Bob&#34;
</code></pre>

<p>So this defines <code>bob</code> as the result of <code>(thing-maker &#34;Bob&#34;)</code>: a procedure, <code>(λ (f) (thing f)</code>, where <code>thing</code> is a a hash-table of the key <code>&#39;name</code> to the value <code>&#34;Bob&#34;</code>.</p>

<p>Essentially, <code>bob</code>, the variable, is something into which we can throw queries about Bob, the <em>thing</em>.</p>

<p>So if we give the function <code>(λ (thing) (hash-ref thing &#39;name)))</code> to <code>bob</code> – or any <em>thing</em> – we&#39;re basically asking that thing, “Hey, what&#39;s your name?”</p>

<p>And the thing will look at itself, and say what it&#39;s name is – <code>&#34;Bob&#34;</code>.</p>

<p>In this way, we&#39;re able to arbitrarily define new <em>qualities</em> for the thing (by adding them to its hash-table), or manipulate them in new wyas, without having to extend the core functionality of the <em>thing</em>, which is, essentially, just making a hash-table and returning <code>(λ (f) (f hash-table))</code>.</p>

<p>And that&#39;s how <strong><em>things</em></strong> work!</p>
]]></content:encoded>
      <guid>https://teraum.writeas.com/anatomy-of-things</guid>
      <pubDate>Sun, 19 Jan 2020 17:31:12 +0000</pubDate>
    </item>
    <item>
      <title>The actions Event</title>
      <link>https://teraum.writeas.com/the-actions-event?pk_campaign=rss-feed</link>
      <description>For other discussion about the development of Teraum, try following @TeraumDev@gup.pe In this post I&#39;d like to explain how the (actions) ...</description>
      <content:encoded><![CDATA[<p>For other discussion about the development of Teraum, try following <a href="/@/TeraumDev@gup.pe" class="u-url mention" rel="nofollow ugc">@<span>TeraumDev@gup.pe</span></a></p>

<p>In this post I&#39;d like to explain how the <code>(actions)</code> event works. It grew out of the “Actions Service,” which is kind of a defunct concept now that <em>Racket-MUD</em> has gotten more <em>functional</em>.</p>

<p>Services were features loaded into the MUD as it loaded, and some of them provided <code>(tick)</code> functions which were added to a list and, as you might guess, tick&#39;d every, well, tick.</p>

<p>Now, there&#39;s no real “services” as a distinct feature: just a list of events which are passed to the the MUD when it&#39;s started. At the moment, the Teraum MUD is started by the following statement:</p>

<pre><code>    (run-engine
       (make-engine
        &#34;Teraum&#34;
        (list (accounts)
    	  (actions)
    	  (mudmap teraum-map)
    	  (mudsocket)
    	  (talker))))
</code></pre>

<p>The <code>(make-engine)</code> function takes a name, and then a sequence of functions. The one we&#39;ll be looking at this time is the second in that list – <code>(actions)</code>.</p>

<p>The reason we add <code>(actions)</code> to the list instead of just <code>actions</code> is because we actually want to add the <em>result</em> of calling the procedure to the list of initial events, not the procedure itself.</p>

<p>So, what is the result of calling the <code>actions</code> procedure?</p>

<pre><code>    (define (actions)
      (define actions (make-hash))
      (define (load state)
        (let ([schedule...])))
      (define (tick state)
        (let ([schedule...])))
      load)
</code></pre>

<p>I&#39;ve cut out the contents of the two procedure definitions that live inside the <code>actions</code> procedure, of <code>load</code> and <code>tick</code>, for now, to keep things more readable.</p>

<p>We can see that when <code>(actions)</code> is called, it defines a variable inside itself, <code>actions</code>, as an empty hash-table, and then defines the two procedures I just mentioned, and then returns one of them, the load procedure.</p>

<p>So, calling the <code>actions</code> returns another procedure, <code>load</code>.</p>

<p>This <code>load</code> procedure is what&#39;s scheduled as an event. Then, when <em>Racket-MUD</em> is started and begins ticking, it is called – and is passed the MUD&#39;s <code>(scheduler . state)</code> pair.<sup><a id="fnr.1" class="footref" href="#fn.1" rel="nofollow ugc">1</a></sup> We&#39;re ready to look at what the <code>load</code> procedure here actually contains, then.</p>

<p>Again, I&#39;m going to simplify it.</p>

<pre><code>    (define (load state)
      (let ([schedule (car state)]
    	[mud (cdr state)])
        (hash-set! (mud-hooks mud)
    	     &#39;apply-actions-quality
    	     (λ (thing)...))
        (schedule tick)
        state))
</code></pre>

<p>So, what is it that&#39;s happening when this event is called?</p>

<p>First, it looks at the <code>state</code> it is passed and breaks it into its constituent components: a <code>schedule</code> procedure for adding new events to be called in the next tick, and the <code>mud</code> data structure, which contains the current <em>state</em> of the MUD: name, scheduled <em>events</em>, extant <em>things</em>, and <em>hooks</em>.</p>

<p><strong><em>Hooks</em></strong> are procedure that are available across the engine, and serve as kind of a generalized key-value database of functions. Think of it like a table:</p>

<table>


<colgroup>
<col class="org-left"/>

<col class="org-left"/>
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">Hook</th>
<th scope="col" class="org-left">Procedure</th>
</tr>
</thead>

<tbody>
<tr>
<td class="org-left">`apply-actions-quality`</td>
<td class="org-left">`(λ (thing) (map (λ...`</td>
</tr>


<tr>
<td class="org-left">`broadcast`</td>
<td class="org-left">`(λ (chan speaker message)...`</td>
</tr>


<tr>
<td class="org-left">`move`</td>
<td class="org-left">`(λ (mover destination)...`</td>
</tr>
</tbody>
</table>

<p>So, this event, this <code>load</code> procedure returned by calling <code>(actions)</code>, adds the <code>apply-actions=quality</code> hook. We might end up looking at that hook&#39;s procedure in another explainer. Then, it schedules the <code>tick</code> procedure defined when we first called <code>(actions)</code>, and returns the MUD&#39;s new state, now that it contains the <code>apply-actions-quality</code>.</p>

<p>So in general, for any givenevent, the MUD&#39;s <code>(scheduler . state)</code> pair goes in, gets changed about, and then returned.</p>

<p>In this case, the MUD&#39;s state gets a hook added to it, and another event gets scheduled: tick.</p>

<p>After this, the other events scheduled for the engine&#39;s first tick happen, and then the engine moves on to the second tick, eventually coming to the event that <code>load</code> scheduled: <code>tick</code>.</p>

<p>Here&#39;s an abbreviated rendering of that procedure:</p>

<pre><code>    (define (tick state)
      (let ([schedule (car state)]
    	[mud (cdr state)]
    	[triggered (list)])
        (hash-map actions
    	      (λ (chance records)...))
        (schedule tick)
        state))
</code></pre>

<p>As you can see, the beginning and end of this procedure are nearly the same as <code>load</code> was: it breaks up the MUD&#39;s <code>(scheduler . state)</code> pair into its constituents, and then later, after doing some sutff, schedules itself, <code>tick</code>, and then returns the new state.</p>

<p>(<code>(scheduler . state)</code> <em>pair</em> takes a while to type out. You might also see it written as the lowercase theta, θ, with an uppercase delta, Δ,  used to represent schedule and a lowercase psi, ψ, for state. But not always -it depends on who wrote the code and documentation.)</p>

<p>Anyway! This brings us to the one thing about the <code>actions</code> procedure that&#39;s relatively unique, and handles what it actually <em>does</em>: what it does each <em>tick</em>.</p>

<p>It does two basic things:</p>
<ol><li>First it looks through every known action, a hash-table of actions added when the <code>apply-actions-quality</code> hook is called.
a) For every record, it generates a random number between 0 and 10,000. If that number is… greater-than? less-than? Whichever makes sense, then the event is triggered: added to a list of triggered events.</li>
<li>Second, for every triggered event, handle its <em>task</em> (the actual… action-y part of the action: not the actor, and not the chance, but the thing that happens.)
b) If the task is a string, and the actor is in some sort of environment, send the string to every client in that same environment.
c) If the task is a procedure, call it, passing it the actor.</li></ol>

<p>That&#39;s it! That&#39;s how those room chats y&#39;all who&#39;ve played the demo come to love work. For completeness, here&#39;s the actual statements that handle triggering and calling tasks, but it relies on procedures defined deeper in the engine, which haven&#39;t yet been explained:</p>

<pre><code>    (hash-map actions
    	  (λ (chance records)
    	    (for-each (λ (record)
    			(when (&lt;= (random 10000) chance)
    			  (set! triggered
    				(append (list record)
    					triggered))))
    		      records)))
       (for-each
         (λ (action)
           (let* ([actor (first action)]
    	      [task (third action)]
    	      [actor-quality (quality-getter actor)]
    	      [actor-location (actor-quality &#39;location)]
    	      [actor-exits (actor-quality &#39;exits)])
    	 (cond
    	   [(string? task)
    	    ;send to things in th environment
    	    (let* ([environment (cond [actor-location actor-location]
    				      [actor-exits actor])])
    	      (when (procedure? environment)
    		(let ([environment-contents
    		       ((quality-getter environment) &#39;contents)])
    		  (for-each
    		   (λ (thing)
    		     (((string-quality-appender thing) &#39;client-out)
    		     task))
    		   (things-with-quality environment-contents &#39;client-out)))))
    	    ]
    	   [(procedure? task)
    	    (task actor)])))
         triggered)
</code></pre>

<h2 id="footnotes">Footnotes</h2>

<p><sup><a id="fn.1" href="#fnr.1" rel="nofollow ugc">1</a></sup> An explanation of this will come… later.</p>
]]></content:encoded>
      <guid>https://teraum.writeas.com/the-actions-event</guid>
      <pubDate>Sun, 12 Jan 2020 01:10:56 +0000</pubDate>
    </item>
    <item>
      <title>Teraum&#39;s MUD Stack</title>
      <link>https://teraum.writeas.com/teraums-mud-stack?pk_campaign=rss-feed</link>
      <description>In this post I&#39;d like to explain the “MUD stack” behind Teraum, what each one is as a project and how they relate. Teraum is a MUD server...</description>
      <content:encoded><![CDATA[<p>In this post I&#39;d like to explain the “MUD stack” behind Teraum, what each one is as a project and how they relate.</p>

<p><strong><em>Teraum</em></strong> is a <em>MUD server</em> running the <strong>Racket-MUD</strong> <em>engine</em> loaded with the <strong>RPG-Basics</strong> <em>library</em> and a custom <em>map</em>.</p>

<p>Phew! Lot of terms.</p>
<ul><li><p>A <strong><em>MUD server</em></strong> is a single MUD, running somewhere. Folk can connect to it, create accounts, and do whatever that server allows.</p></li>

<li><p>A <strong><em>MUD engine</em></strong> is a piece of software that provides the game engine for running a MUD server. It usually doesn&#39;t come with too many game-like features itself, usually focused around providing connectivity and utilities.</p></li>

<li><p>A <strong><em>MUD library</em></strong> is a collection of code meant to be added into a *MUD engine to extend its features.</p></li></ul>

<p>There&#39;s our generic terms.</p>
<ul><li><p><strong><em>Racket-MUD</em></strong> is a <em>MUD engine</em> that&#39;s made by the same people who are making <strong>Teraum</strong>. It&#39;s written in the <em>Racket</em> programming language. It&#39;s about two hours older than the Teraum MUD, so is also in the very early stages of development.</p></li>

<li><p><strong><em>RPG-Basics</em></strong> is a <em>MUD library</em> that&#39;s being made by us same folk who are making <strong>Teraum</strong> and <strong>Racket-MUD</strong>. It&#39;s the first <em>library</em> being made for <strong>Racket-MUD</strong>, and as such, its code isn&#39;t well-segregated from the <em>engine</em>.</p></li></ul>

<p>Under-the-hood, the <em>engine</em> is just a procedure for handling the scheduling and sequential calling of <strong><em>events</em></strong>, another type of procedure for manipulating the state of the game world. When the engine is <code>made</code>, it&#39;s usually passed a list of <em>events</em> to call when it first starts. For example, <strong>Racket-MUD</strong> comes bundled with <em>events</em> for creating, loading, and saving user accounts, managing intra-engine user chat channels, and running the socket server to which those users will connect.</p>

<p>A <em>library</em> is a similar bundle of <em>events</em>. The <strong>RPG-Basics</strong> <em>library</em> currently provides events that load the world map and set up the ability for those created things to randomly act.</p>

<p>In practice, starting the MUD is done with the following line of Racket:</p>

<pre><code class="language-racket">(run-engine
 (make-engine &#34;Teraum&#34;
  (list (accounts)
        (mudsocket)
        (talker)
        (actions)
        (mudmap teraum-map))))
</code></pre>

<hr/>

<p>As <strong>Teraum</strong> increases in sophistication, the number of <em>events</em> passed when the <em>engine</em> is <code>made</code> will steadily increase, but the basic concept is there: pass a list of procedures to the engine to serve as the first <em>events</em>.</p>

<p>In follow-up posts, I plan on explaining how each of these events work, and providing a more thorough explanation of what <code>making</code> an <em>engine</em> actually means. Also, what goes into the <code>teraum-map</code>: how are in-game things represented, as source code.</p>
]]></content:encoded>
      <guid>https://teraum.writeas.com/teraums-mud-stack</guid>
      <pubDate>Mon, 06 Jan 2020 00:09:50 +0000</pubDate>
    </item>
    <item>
      <title>Introduction</title>
      <link>https://teraum.writeas.com/introduction?pk_campaign=rss-feed</link>
      <description>Teraum is a tragically funny fantasy multiplayer role-playing game, played through text: players type commands and receive text output in...</description>
      <content:encoded><![CDATA[<p><strong><em>Teraum</em></strong> is a tragically funny fantasy multiplayer role-playing game, played through text: players type commands and receive text output in response:</p>

<pre><code>&gt; look
[Crossed Candles Inn]
This is the Crossed Candles Inn: a simple wooden shack with several shuttered windows. There are a few wooden cots in one corner, and a long table which serves as the bar in another. There are some people seated at the table. A door leads out to Arathel County.
Contents: emsenn and Lexandra Terr
Exits: out

&gt; move out

You attempt to move out

[Turnwise Road, South Arathel, Greater Ack Metropolitan Enclosure, outside Crossed Candles Inn]
This is an area of the Turnwise Road, a circular road...
</code></pre>

<p>(This type of text-based MMORPG is called a <em>MUD</em>.)</p>

<p>This blog will be where we (the development team) share updates about the game&#39;s progress, until we have a blog set up within the MUD.</p>

<p>In this first post, we&#39;d like to explain to you a little bit about the project, our plans for its future, and how y&#39;all might get involved if you&#39;re interested.</p>

<hr/>

<p>Teraum is a fantasy setting created by <a href="https://emsenn.net" rel="nofollow ugc">emsenn</a> in the early 2000s, when they were a child. Since then it&#39;s been the setting of various short stories, tabletop RPG campaigns, and even a podcast. It&#39;s a world that used to have magic, but now doesn&#39;t: it&#39;s probably the most mundane fantasy setting you&#39;ll ever learn about.</p>

<p>Teraum is currently being implemented as a <strong><em>MUD</em></strong>, or multi-user dimension: a text-based multiplayer online role-playing game. In it, players can become a human living on Teraum, in approximately the 8th decade after the Break(, when magic went away.)</p>

<p>The MUD is being implemented using a custom MUD engine being written from the ground-up in Racket. While Teraum&#39;s source code is closed, so people have to actually play the game, the MUD engine&#39;s source <a href="https://gitlab.com/emsenn/racket-mud" rel="nofollow ugc">is available</a>.</p>

<p>Right now, the MUD doesn&#39;t have very many features. There are a bit more than fifty rooms you can walk around, representing some areas of the Old World, mostly centered around the Green Delta. That&#39;s about it: you can walk around.</p>

<p>In the immediate future, most of the development team&#39;s focus will be on developing the engine&#39;s features, while we plan what gameplay within the MUD might look like. (Adding colourful output, properly handling unicode, stuff like that.)</p>

<hr/>

<p>We want gameplay in Teraum to be meaningful, even bordering on moralistic. Conflict and combat aren&#39;t going to be prioritized; the latter might not ever be implemented. Instead, the gameplay is going to try and pit players against a turbulent game world, where the actions of things out of their control force them to perpetually adapt.</p>

<p>...The apples from Wultha never arrived. The Red Union puts out a notice, and players head to the the small remote town to <code>investigate</code>. It has been burnt down. Commercial interests begin to reconstruct the town. A small boom occurs along the route between those interests and the town. Players find opportunities for work: importing and exporting, helping <code>build</code>, <code>repair</code>, widen roads. Find their place in the situation, only for it to change again.</p>

<p>The world will not just need <code>exploration</code> but <code>examination</code> and <code>analysis</code>. Seasonal goods collected, roofs repaired before the spring showers come. Life is hard, even when no one&#39;s making it that way, but that doesn&#39;t make life bad.</p>

<hr/>

<p>How can you get involved? Teraum is looking for developers to help work on the Racket-MUD engine, as well as writers to help implement game areas. We&#39;re not yet ready for playtesters, but we&#39;ll be wanting them when we are!</p>

<p>If you want to get involved now, please send am email to <a href="mailto:emsenn+teraum@emsenn.net" rel="nofollow ugc">emsenn+teraum@emsenn.net</a>.</p>

<p>Otherwise I recommend following this blog&#39;s [RSS feed] or through the Fediverse at <strong><a href="/@/teraum@write.as" class="u-url mention" rel="nofollow ugc">@<span>teraum@write.as</span></a></strong></p>
]]></content:encoded>
      <guid>https://teraum.writeas.com/introduction</guid>
      <pubDate>Sun, 05 Jan 2020 18:36:37 +0000</pubDate>
    </item>
  </channel>
</rss>