'quoted text': Makes things more compact in example, actual content will be added later as appendix.
| Login | There are two players: JoeBlatz and Bork. They will both connect to the same server S. They have characters A and B respectively. There is a monster M that resides on monster server X. |
| Looking | A and B 'connect' to the server S. The server puts them in their current location which is in the middle of a road. A tree is to their left (at 10 meters). They see nothing else. |
| Appearing and movement | Then a monster jumps from a tree branch and goes for them. |
| Description | The monster is a geeklizard: a computer user who became green and lizard like after staring too long at his computer. |
| Spell casting and results | The geeklizard will try to slay them by talking them to death. It will start by a story about the advantage of calcium in the development of the infant. That speak is magic and will cause A to fall asleep, |
| Prepare for fight | player B will kill M by using a sword. The fight sequence is: B gets his sword in his hand, M continue to talk (no effect), |
| Swing with sword and damage | B swing and misses, M moved out of the way, M swing and hit (but only minimal damage), B swing and hit, M talks about the advantage of asynchronous transfer over TCP/IP will trying to flee, |
| Transmission error | B catches up to M,swings again. The server doesn't receive the last swing message. B sends the message again |
| Kill | and it kills M. |
| Steal money | Player B will steal the money from A |
| Tracking | and take off. A wakes up 1 hour later and tries to read the tracks on the road to see where B went. |
A->S (login):
<msg>
<op>
<from>JoeBlatz</from>
<id>login</id>
<ent>
<id>JoeBlatz</id>
<attr name="password">Rqv67.%</attr>
</ent>
</op>
</msg>
S->A (login accepted):
<op>
<from>S:</from>
<to>JoeBlatz</to>
<id>info</id>
<ent>
<id>JoeBlatz</id>
<type><id>Player</id></type>
<attr name="name">Joe Blatz</attr>
<attr name="password">Rqv67.%</attr>
<contains><id>A</id></contains>
</ent>
</op>
B->S, S->B: similar
M->S, S->M: similar (player=X, character=M)
Map by John R Street
01234567890
0+----+-+--+
1| | | |
2| |A| |
3|* | | |
4| |B| |
5| | | |
6| |P| |
7| |A| |
8| |T| |
9| |H| |
0+----+-+--+
*=tree
A->S (look around):
<op>
<from>A</from>
<id>look</id>
</op>
S->A (what A sees):
<op>
<to>A</to>
<id>sight</id>
<id>grass1</id>
</op>
A->S (look at grass):
<op>
<from>A</from>
<id>look</id>
<id>grass1</id>
</op>
S->A (what A sees):
<op>
<to>A</to>
<id>sight</id>
<ent>
<id>grass1</id>
<type><id>terrain</id></type>
<contains>
<id>path1</id>
<id>tree1</id>
</contains>
<attr name="description">Grass plains</attr>
<attr name="polygon">
<coords>0,0</coords><coords>10,0</coords><coords>10,10</coords>
<coords>0,10</coords><coords>0,0</coords>
</attr>
</ent>
</op>
A->S (look again specific objects):
<msg>
<op>
<from>A</from>
<id>look</id>
<id>path1</id>
</op>
<op>
<from>A</from>
<id>look</id>
<id>tree1</id>
</op>
</msg>
S->A (what A sees):
<msg>
<op>
<to>A</to>
<id>sight</id>
<ent>
<id>path1</id>
<type><id>road</id></type>
<contains>
<id>A</id>
<id>B</id>
</contains>
<loc><id>grass1</id><coords>5,0</coords></loc>
<attr name="description">Path</attr>
<attr name="polygon">
<!-- Note: relative coordinates to container (loc) -->
<coords>0,0</coords><coords>2,0</coords><coords>2,10</coords>
<coords>0,10</coords><coords>0,0</coords>
</attr>
</ent>
</op>
<op>
<to>A</to>
<id>sight</id>
<ent>
<id>tree1</id>
<type><id>tree</id></type>
<loc><id>grass1</id><coords>1,3</coords></loc>
<attr name="description">Tree</attr>
<attr name="height">5.6</attr>
</ent>
</op>
</msg>
A->S (look at B):
<op>
<from>A</from>
<id>look</id>
<id>B</id>
</op>
S->A (what A sees):
<op>
<to>A</to>
<id>sight</id>
<ent>
<id>B</id>
<type><id>human</id></type>
<loc><id>path1</id><coords>6,4</coords></loc>
<attr name="description">Player B, bla bla</attr>
<contains>
<id>swordB</id>
</contains>
</ent>
</op>
[A looks at swordB and receivers answer]
B<->S: similar
S->A (A sess Geeklizard jumping):
<msg>
<op>
<to>A</to>
<id>appear</id>
<ent>
<id>M</id>
<loc><id>tree1</id><coords>0,0,3.0</coords></loc>
</ent>
</op>
<op>
<to><id>A</id><to>
<id>sight</id>
<op>
<id>jump</id> <!-- derived from move -->
<ent>
<id>M</id>
<loc><id>grass1</id><coords>0.5,3.0,0.0</coords></loc>
</ent>
</op>
</op>
</msg>
A->S (looks at M: similar to earlier looking)
S->A (send info about M: note multiple inheritance)
<op>
<to>A</to>
<id>sight</id>
<ent>
<id>M</id>
<type><id>human</id><id>lizard</id></type>
<loc><id>grass1</id><coords>0.6,3.0,0.0</coords></loc>
<attr name="description">Geeklizard</attr>
<attr name="velocity">3,0</attr>
</ent>
</op>
A->S (get lizard type):
<op>
<from>A</from>
<id>get</id>
<id>lizard</id>
</op>
S->A (Lizard is green):
<op>
<to>A</to>
<id>info</id>
<ent>
<id>lizard</id>
<type><id>monster</id></type>
<attr name="color">Green</attr>
</ent>
</op>
M->S ('cast' magical speech):
<op>
<from>M</from>
<id>sleepy bore</id> <!-- see later: has multiple inheritance -->
<op>
<id>talk</id>
<ent><attr name="say">blah blah calcium blah blah</attr></ent>
</op>
<op>
<id>spell</id>
<ent><attr name="action">sleep</attr></ent>
</op>
</op>
S->A (notice spell and fall asleep):
<msg>
<op>
<to>A</to>
<id>perception</id>
'previous section copied here'
</op>
<op>
<to>A</to>
<id>change</id>
<ent><attr name="state">sleep</attr></ent>
</op>
</msg>
S->B (notice spell and see A to fall asleep):
<msg>
'perception op similar to above'
<op>
<to>B</to>
<id>sight</id>
'include above change op to A here'
</op>
</msg>
B->S (get 'sleepy bore' op: see above Lizard for example)
<op>
<to>B</to>
<id>info</id>
<ent>
<id>sleepy bore</id>
<type><id>talk</id><id>spell</id></type>
</ent>
</op>
B->S (gets his sword in his hand):
<op>
<from>B</from>
<id>grab</id>
<ent>
<id>swordB</id>
<loc><id>B#hand</id></loc>
</ent>
</op>
M->S and S->B (Ms spell):
similar to previous+sees sword to move it's hand
<op>
<to><id>B</id><to>
<id>sight</id>
'include previous op here'
</op>
B->S (B swings):
<op>
<from>B</from>
<id>swing</id> <!-- derived from attack -->
<ent>
<id>swordB</id>
<loc><id>B_hand</id>
<coords>'where M is - sword length'</coords>
</loc>
</ent>
</op>
S->B (misses):
M moves out of the way and swordB moves where M was.
movements, similar to above grab
M->S, S->B (M swing and hit):
swing like above, sight of it like above
hit:
<op>
<from>M</from>
<to>B</to>
<id>change</id>
<ent>
<id>B</id>
<attr name="status">0.9</attr>
<!-- previous value was: 1.0 -->
</ent>
</op>
B swing and hit, M talks about the advantage of
asynchronous transfer over TCP/IP will trying to flee,
Similar to previous...
Content similar previous.
To facialiate detection of missing messages:
B->S:
<msg no="100">
<op/>
</msg>
<msg no="102">
<op/>
</msg>
Now libatlas detects missing message "101" and asks sender to
resend it.
B->S (swing M):
<op no="101">
'similar to earlier swing'
</op>
S->M (B kills M):
It disappears:
<op no="200" refno="101"> <!-- when B sees this message
embedded inside sight message:
it has originated from me and
'refno' was from that swing:
I killed it with that swing -->
<from>B</from>
<to>M</to>
<id>kill</id> <!-- derived from delete -->
<id>M</id>
</op>
Alternative if it leaves corpse:
<op>
<from>B</from>
<to>M</to>
<id>dead</id> <!-- derived from change -->
<ent>
<id>M</id>
<attr name="status">0.0</attr>
<attr name="state">dead</attr>
</ent>
</op>
S->B (sees above):
<op>
<to>B</to>
<id>sight</id>
'above included here'
</op>
B->S (search body of A):
<op>
<from>B</from>
<id>search</id> <!-- derived from look -->
<id>A</id>
</op>
S->B (sees possessions):
<op>
<to>B</to>
<id>sight</id>
<ent>
<id>A</id>
'other attributes here..'
<contains>
<id>swordA</id>
<id>backpackA</id>
</contains>
</ent>
</op>
B->S (look at backpack)
<op>
<to>B</to>
<id>sight</id>
<ent>
<id>backpackA</id>
'other attributes here..'
<contains>
<id>moneyA</id>
</contains>
</ent>
</op>
B->S (look money):
<op>
<to>B</to>
<id>sight</id>
<ent>
<id>moneyA</id>
<attr name="amount">120</attr>
</ent>
</op>
B->S (try to steal sword and divide money to two heaps):
<msg>
<op no="105">
<from>B</from>
<id>steal</id> <!-- derived from grab -->
<ent>
<id>swordA</id>
<loc><id>backbackB</id></loc>
</ent>
</op>
<op no="106">
<from>B</from>
<id>divide</id>
<id>moneyA</id>
<ent>
<id>moneyA</id>
<attr name="amount">10</attr>
</ent>
<ent>
<type><id>money</id></type>
<attr name="amount">110</attr>
</ent>
</op>
</msg>
S->B (B sees sword stealing sword failed and dividing money succeeded):
<msg>
<!-- sword moves slightly in A's hand -->
<op no="210" refno="105">
<to><id>B</id>
<id>sight</id>
<op no="211" refno="105">
<from>B</from>
<id>move</id>
<ent>
<id>swordA</id>
<loc><id>handA</id><coords>'changes 0.02 meters'</coords></loc>
</ent>
</op>
</op>
<!-- A's hand moves -->
<op no="212" refno="105">
<to><id>B</id>
<id>sight</id>
<op no="213" refno="105">
<from>B</from>
<op>
<id>move</id>
<ent>
<id>handA</id>
<loc><id>A</id><coords>'changes 0.3 meters'</coords></loc>
</ent>
</op>
</op>
</op>
<!-- sees dividing succeeding -->
<op no="214" refno="106">
<to><id>B</id>
<id>sight</id>
<op no="215" refno="106">
<from>B</from>
'like content of divide except this line is added to latest entity:'
<id>moneyA_110</id>
</op>
</op>
</msg>
B->S (steal second part of divided money):S->B (sees stealing succeed):
<op no="216" refno="107">
<to>B</to>
<id>sight</id>
<op no="217" refno="107">
<from>B</from>
<id>steal</id>
<ent>
<id>moneyA_110</id>
<loc><id>backbackB</id></loc>
</ent>
</op>
</op>
B->S (Then combine it with existing money):
<op no="108">
<from>B</from>
<id>combine</id>
<id>moneyB</id>
<id>moneyB</id>
<id>moneyA_110</id>
</op>
S->B (sees result of combining):
<msg>
<op no="218" refno="108">
<to>B</to>
<id>change</id>
<ent>
<id>moneyB</id>
<attr name="amount">130</attr> <!-- had previously 20 pieces -->
</ent>
</op>
<op no="219" refno="108">
<to>B</to>
<id>delete</id>
<id>moneyA_110</id>
</op>
</msg>
B->S (movement like earlier)
S->B (sight like earlier)
S->A (awakening like sleeping earlier)
A->S (looking in the possession: like earlier)
S->A (result: similar like earlier)
What if A doesn't look at his possessions? Then it will become as surprise when he is next time shopping ;-)
and tries to read the tracks on the road to see where B went.
A->S (see road):
<op>
<from>A</from>
<id>track</id> <!-- derived from search -->
<id>road</id>
</op>
S->A (sees road):
<op>
<to>A</to>
<id>sight</id>
<ent>
<id>road</id>
<attr name="tracks of B" type="coordslist">
'listing of some coordinates where B went'
</attr>
</ent>
</op>
How do you know track is derived from search?
X->S:
<op
<id>get</id>
<id>track</id>
</op>
S->X:
<op
<id>info</id>
<ent>
<id>track</id>
<type><id>search</id></type> <!-- here is parent type told -->
</ent>
</op>