MEMOTICA
OVERVIEW AND REFERENCE
DRAFT IV
Contents
INTRODUCTION ................................................................................................................................................. 3
WHY MEMOTICA? ............................................................................................................................................ 4
A note to the designer ........................................................................................................................... 5
A note on Terminology .......................................................................................................................... 5
A note on Visual Syntax ......................................................................................................................... 5
THE TWO TRINITIES .......................................................................................................................................... 6
THE WORLD TRINITY ....................................................................................................................................... 10
THE DNA TRINITY .......................................................................................................................................... 11
Meta Memes ............................................................................................................................................... 12
Meta Meme Properties ....................................................................................................................... 12
Member Metamemes ......................................................................................................................... 14
MetaMeme Extensions........................................................................................................................ 16
Memes ......................................................................................................................................................... 20
PATHS ........................................................................................................................................................... 25
Template Paths .................................................................................................................................... 26
Concatenated Template Paths ............................................................................................................ 27
Wildcards ............................................................................................................................................. 28
Properties of Members ....................................................................................................................... 29
THE DNA TRINITY .......................................................................................................................................... 29
Metameme and Meme Enhancements ............................................................................................... 30
Exclusive Membership (Switch) ........................................................................................................... 38
Distinct Membership and the distinct Attribute ................................................................................. 42
Unique Entities (a.k.a Singletons) ........................................................................................................ 44
Property Value Restrictions ................................................................................................................. 45
INTRODUCTION
“HE WHO LOVES PRACTICE WITHOUT THEORY IS LIKE THE SAILOR WHO BOARDS SHIP WITHOUT A RUDDER AND
COMPASS AND NEVER KNOWS WHERE HE MAY CAST.”
-LEONARDO DA VINCI
WHY MEMOTICA?
Memotica is the answer to a difficult problem in virtual world design; the reuse "gameplay".
Designers create everything from scratch every time they work on a project. In fact, a designer is
unlikely to even be able to reuse his work from a previous project as he is usually working on a
new engine and simply can't. This goes against the fact that players are always demanding more
immersive environments and better AI; both of which are design heavy and too expensive to
produce. Yet we can learn something from traditional object oriented programming languages, as
well as web services frameworks. There, content is re-usable. Any solution for re-usable designer
content must fulfill the following:
It needs to be able to meet the needs of beginner world designers who ask “what
should my level cap be?” without first asking whether his desired gameplay is best
met with classes, skills, hard skill/level caps, soft skill/level caps or indeed none at all.
It needs to meet the needs of experienced and knowledgeable designers
experimenting at the edge of the envelope.
It should make no assumptions on what a ruleset might actually look like. Not
everything is a diku.
It should lend itself to working at any depth in a ruleset. If a designer simply wishes to
tweak a few agent memes or actions in a diku clone, this should be possible. If the
designer wishes to think in depth and abstractly about his world design – three layers
below anything seen by a player - it should be possible.
It should be cross platform. This implies either an interpreted or bytecode solution.
It should be modular and re-useable the way classes and packages are in modern OO
languages. A designer should be able to re-use something from an earlier project, or
use something from an off the shelf library.
It should be something that lends itself to the use of graphical design tools. It should
not be a "graphical language" such as the Unreal Engine 3"s Kismet, Microsoft's Visual
Programming Language or National Instruments'' LabView, but rather something that
can be rendered in graphical form.
Most importantly, it should free the designer to look at his or her world and its ruleset
from first principles and not through the restrictive lens of an engine toolkit.
Memotica tries to solve all of these. There is an active project building a prototype Memotica
interpreter called Angela. (http://sourceforge.net/projects/projectangela/)
A note to the designer
Memotica is an extremely powerful design tool. It is also extremely easy to wield on one condition. It
demands that the designer think like an architect; not like a carpenter. Memotica encourages you to
work from first principles to build your vision up from rather than taking the carpentry approach
A note on Terminology
Wait… isn’t this all just normal classes with different names? A programmer might ask himself this
question. It has been asked before. In principle, a metameme could be regarded as a class. A meme
might be an object (being an instance of the class) bearing some set of “default” values. A meme
instance could be created by copying the template object and proceeding to copy its values. After all,
this is already a common approach to these problems. The extremely pedantic might even start
mentioning interfaces and abstract classes (as in metameme==interface or abstract class, meme==class).
It is important to consider two things about Memotica. The first is the standard library metamemes –
whose memes invoke specific behavior in the interpreter for handling actions, stimuli and agents. This
means that Memotica is in some ways more closely related to web services than to a programming
language and you could make the argument that Memotica is a form of object oriented web services.
Collectively lumping memes and metamemes under the “services” moniker is confusing. Actions, agents
and stimuli could conceivably be labeled services, but not the atoms (memes and metamemes that they
are made of) so precise terminology is needed. Secondly, its target user – the designer - is not always an
experienced programmer. He or she may be, but is just as likely not. Rather than inappropriately use
terminology, or invent terminology targeted at people outside the target user base, we went with
“meme” and “metameme”. Designers will understand the concept of “units of information” as defined
by Dawkins.
A note on Visual Syntax
The astute may note that Memotica graphs; or more precisely, the graph representations memes and
metamemes, bear a resemblance to UML. This is a deliberate usability aid; much as most web browsers
follow a similar layout to allow easy orientation. Anyone with a bit of UML knowledge should instantly
recognize extension and membership for what they are. Restriction and enhancement references are
also easy to decipher this way and it is not a big leap from classes to memes and metamemes. Our aim
here is low cognitive overhead so that designers can quickly get to thinking about the problem instead of
the graphing conventions. We do not stick slavishly to UML conventions however.
THE TWO TRINITIES
DESIGNERS REALLY SHOULD KNOW EVERYTHING ABOUT THE PHYSICS OF THEIR VIRTUAL WORLD. THEY SHOULD
KNOW WHAT CONVENTIONS HAVE BEEN ADOPTED, THEY SHOULD KNOW WHY THEY WERE ADOPTED, AND THEY
SHOULD KNOW THEIR IMPLICATIONS. ARMED WITH THIS, THEY SHOULD CONSIDER WAYS AND MEANS TO IMPROVE
ON THEM FOR THE BENEFIT OF THEIR VIRTUAL WORLD AND ITS PLAYERS. IF YOU DO GO WITH THE FLOW, IT OUGHT
ONLY TO BE BECAUSE THE FLOW IS GOING WHERE YOU WANT TO GO.”
-RICHARD BARTLE (Designing Virtual Worlds)
It is difficult to come up with a term for what Memotica actually is. At a high level, it is cross
between a directed graph language and web services. This level is chiefly made up of agents,
actions and stimuli. Agents are things. Anything that has a state is an agent. Mobs, characters,
loot, etc. are all agents. They go by different names on different engines (SimObject, Entity, Actor,
etc.) and in Memotica they are called agents. If we were unable to change the state of agents, we
would not be able to do much of anything interesting; so we have actions to change the state of
agents. Actions are stateless and transient. They are invoked by clients (either human or AI). All
is not always what it seems and it is the job of Stimuli to govern what seems. Stimuli control what
those human and AI decision makers know about the state of agents and the actions that made
them the way they are. Figure 1 shows how this trinity acts as an ensemble.
Action Changes
state of Agent
Action
Agent
Actions Trigger
Actions
Agent Broadcasts
Action
Stimulus
Action Triggers
Action
Stimulus
Client Triggers
Action
Stimulus
Client Side Decisions
(AI or Human)
Stimulus to
Client
Figure 1
At a low level, Memotica is a way of defining simulation data objects (Entities), the models from
which they are made (memes) and the meta-models with which those models are defined
(metamemes). The deep core of Memotica is a second trinity of the meme, metameme and
entity. Designers may come to Memotica thinking of the macro trinity (agent, stimulus, action)
that makes it like a directed graph language, but if they want to do anything serious, they’ll have
to roll up their sleeves and understand the low level trinity as memes, metamemes and entities
form the DNA of agents, stimuli and actions. Figure 2 is evocative of how they work in concert.
Figure 2
Meme is a term created by Richard Dawkins to define a unit of information and that is the role
that it plays in Memotica. It is the designer’s workhorse and may define an entity of some sorts, it
may define a change of state for that entity, or it may define the reporting of the state of an entity
to a client. Memes are defined by designers who create a meta model of the meme, called a
metameme. This defines its structure.
What exactly are memes and metamemes? They provide a “clean” way of organizing and
designing objects. For example, someone designing a fantasy MMO might want to have orcs. An
individual orc would be an object. That orc would be created as needed from a template; a model
of an orc. We call this a meme. A metameme is the definition of the structure of a meme; a
generic “mob” in this case. (see Figure 3) Memotica’s metamemes and memes are intended to
allow designers to design their own objects and data structures without writing any code. They
are also intended to lend portability, allowing re-use and trade of structures and concepts.
As applied in a fantasy MMO
Object
(Instance of a meme)
Individual Orc
Applies „default data“ to a metameme
Meme
to define a category of objects
Orc „Template“
(Instance of a metameme)
Metameme
Defines the structure of the meme
Structure of mobs in general
Figure 3
There is an XML schema version for the exchange of metamemes and memes. This document has
a single root element called RMLDocument. Both memes and metamemes are nested within this
in the ListOfMeme and ListOfMetameme child elements respectively. The XSD is available at
http://rulesetmodeling.svn.sourceforge.net/viewvc/rulesetmodeling/Schemas/RMLDocument.xsd
Though no schema exists yet (ver 0.0), there is an outlines use case for transferring an
RMLDocument as a payload in a SOAP or XML-RPC message, allowing for direct machine to
machine transfer of memes and metamemes.
THE WORLD TRINITY
“ACTION TO BE EFFECTIVE MUST BE DIRECTED TO CLEARLY CONCEIVED ENDS.”
-JAWAHARLAL NEHRU
Add New Comment