Merry Tips

    > +tool merry edit %Examples:workinprogress:sam:sam-toy react:probe-dob
    EmitTo( $actor, dump_value( args ) ) ;

    > probe toy

    You approach a toy.
    ([ "actor":<Chatters:LC:ch:allen-christopher>,
       "dob":({ (43)O(/base/data/nref#-1, <[Examples:workinprogress:sam:sam-toy]#11527>, "default") }),
       "dob:description":"probe",
       "dob:distance":3,
       "imperative":"probe",
       "obscurity":0,
       "origtarget":"none",
       "parts":({ ({ "V" }), ({ "O", ({ (43)O(/base/data/nref#-1, <[Examples:workinprogress:sam:sam-toy]#11527>, "default") }) }) }),
       "preps":([ ]),
       "privacy":0,
       "rob":</base/data/result#-1>,
       "roles":({ "dob" }),
       "target":(43)O(/base/data/nref#-1, <[Examples:workinprogress:sam:sam-toy]#11527>, "default"),
       "this":<[Examples:workinprogress:sam:sam-toy]#11527>,
       "verb":"probe",
       "vob":<Socials:Verbs:probe>,
       "witnesses":({ <Examples:complete:desc:room-go-nowhere>, ({ }) }) ])
    >

   Look: [
      $[dump_value( args )]
   ]
   React-post:push-dob: [
      $[dump_value( args )]
   ]

   > look at toy's button
   ([ "actor":<Chatters:LC:ch:allen-christopher>,
      "looker":<Chatters:LC:ch:allen-christopher>,
      "node":</usr/SkotOS/data/merry#-1>,
      "this":<[Examples:complete:sam:sam-toy]#11527> ])
   > push toy's button
   You push a button.
   ([ "actor":<Chatters:LC:ch:allen-christopher>,
      "dob":({ (43)O(/base/data/nref#-1, <[Examples:complete:sam:sam-toy #11527>, "button") }),
      "dob:description":"push",
      "dob:distance":3,
      "imperative":"push",
      "ldef":X[S] $(you) $(verb) $(dobname).,
      "node":</usr/SkotOS/data/merry#-1>,
      "obscurity":0,
      "origtarget":"none",
      "parts":({ ({ "V" }), ({ "O", ({ (43)O(/base/data/nref#-1, <[Examples:complete:sam:sam-toy]#11527>, "button") }) }) }),
      "preps":([ ]), "privacy":0, "rob":</base/data/result#-1>,
      "roles":({ "dob" }),
      "target":(43)O(/base/data/nref#-1, <[Examples:complete:sam:sam-toy]#11527>, "button"),
      "this":<[Examples:complete:sam:sam-toy]#11527>,
      "verb":"push",
      "vob":<Socials:Verbs:push>,
      "witnesses":({ <Examples:complete:desc:room-go-nowhere>, ({ }) }) ])
      >

   > +tool sam exec $[dump_value( args )]

   Original input:
           $[dump_value( args )]

   Output:
           "([ \"actor\":<Chatters:LC:ch:allen-christopher>, \
                "body\":<Chatters:LC:ch:allen-christopher>, \
                "here\":<Examples:complete:desc:room-go-nowhere>, \
                "looker\":<Chatters:LC:ch:allen-christopher>, \
                "node\":</usr/SkotOS/data/merry#-1> ])"

   > +tool merry exec EmitTo( $actor, dump_value( args ) ) ;
   ([ "actor":<Chatters:LC:ch:allen-christopher>,
      "body":<Chatters:LC:ch:allen-christopher>,
      "here":<Examples:complete:desc:room-go-nowhere>,
      "looker":<Chatters:LC:ch:allen-christopher> ])

   Merry code:   EmitTo( $actor, dump_value( args ) ) ;
   Merry result: nil

if ( Get(this,"debug") ){
   EmitTo(${Chatters:LC:ch:allen-christopher},"SIGNAL: react-post:drop-what\n" + dump_value( args ) + "\n");
}

   > drop torch
   You drop a flaming torch.
   SIGNAL: react-post:drop-what
   ([ "action":"command",
   "actor":<Chatters:LC:ch:allen-christopher>,
   "imp":"drop",
   "imperative":"drop",
   "ldef":X[S] $(you) $(verb) $(whatname).,
   "origtarget":"none",
   "phase":"post",
   "rob":</base/data/result#-1>,
   "roles":({ "what" }),
   "target":(43)O(/base/data/nref#-1, <[Examples:incomplete:light:torch]#9591>, "default"),
   "this":<[Examples:incomplete:light:torch]#9591>,
   "verb":"drop",
   "vob":<Neoct:Base:Verbs:drop>,
   "what":({ (43)O(/base/data/nref#-1, <[Examples:incomplete:light:torch]#9591>, "default") }),
   "what:description":"drop",
   "witnesses":({ <Examples:complete:desc:room-go-nowhere>, ({ }) }) ])

   EmitTo(${Chatters:LC:ch:allen-christopher},
          TAG("SIGNAL: act:start\n" + dump_value(args),
              "debug"));

   Match($actor, "lighter")

will return an array of everything you are carrying that matches the
noun "lighter". Thus a check like

   if (sizeof(Match($actor, "lighter")) > 0) {
     /* the actor has a lighter */
   } else {
     /* the actor doesn't */
   }

         +tool merry exec int f,i; f=1; for(i=2;i<14;i++) f*=i; return f;

         +tool merry exec return <your expression here>;

         +tool merry eval (104 - 32) * 5 / 9
         +tool merry eval 100.0 * 1.04 * 1.04 * 1.04

         >+tool merry eval dump_value( args )
         Merry code:   dump_value( args )
         Merry result: "([ \"actor\":<Chatters:LC:ch:allen-christopher>,
                           \"body\":<Chatters:LC:ch:allen-christopher>,
                           \"here\":<Examples:complete:desc:room-go-nowhere>,
                           \"looker\":<Chatters:LC:ch:allen-christopher> ])"

     processed_string = UnSAM(ParseXML("You are {happy|sad}."));

   string * lightoptions;
   lightoptions = ({ "a", "b", "c" });
   EmitTo ($actor, "It is very " + lightoptions[ random (sizeof (lightoptions)) ] + " in here.");

   EmitTo( $actor, "It is very " + oneof( "a", "b", "c" ) + " in here." );

  string lightoptions;
  lightoptions = oneof( "a", "b", "c" );
  EmitTo( $actor, "It is very " + lightoptions + " in here." );

----- Original Message -----
From: "Par Winzell" <zell@skotos.net>
To: <skotos-seven@skotos.net>
Sent: Sunday, September 01, 2002 4:58 PM
Subject: Re: [skotos-seven] Merry scripts running time?


Kalle,

> The thought struck me -- for how long does merry scripts run, anyway?

They run forever, unless they either A) do a 'return' rather than a
$delay, or B) cause a run-time error, which aborts the execution.

> Some tests prove that scripts do not run forever. Especially in the
> case of a script ran in a character body.
>
> I had a script that occasionally made silly evokes in my environment, in
> a never-ending loop (with about 15 mins apart each evoke).
>
> I found the script was no longer running when I'd been logged out for
> some time.

This is a good case of B) -- when you log out, your environment becomes
'nil'. I bet your code sent the $actor's base:environment to a function
like perhaps EmitIn, which freaked out and triggered an error, aborting
the execution of the script.

There are various ways to make these things more sturdy. One is to catch
errors e.g. like this --

   while (TRUE) {
     catch {
       EmitIn($actor."base:environment", "Time passes...\n");
     }

     $delay(10);
   }

All code inside the catch {} statement will run as usual unless there is
a runtime error, in which case execution does not abort entirely -- but
rather jumps to the end of the catch block. In other words, the EmitIn
is safely encapsulated, so even if it breaks, the loop is guaranteed to
continue running.

Note that in this particular case, that would be an IDIOTIC solution to
the problem -- the correct thing to do is to check if base:environment
is nil before emitting in it! Otherwise the error logs will fill up with
un-ending streams of caught errors...


Another way to solve this problem is by using some Merry functions that
I wrote before I figured out how to do $delay, but which I haven't been
pushing on you guys since. There are reasons to use them occasionally,
though, because they provide a more robust way to do timing-sensitive
stuff like this. I'll try to remember to document them in the next few
days. Meanwhile, A) do checks on everything you think might break -- in
most cases, sending nil's to functions that don't know what to do with
them -- and B) sparing use of catch() statements around critical parts
of infinite loops, like the above.

Zell

----- Original Message -----
From: "Par Winzell" <zell@skotos.net>
To: <skotos-seven@skotos.net>
Sent: Monday, November 04, 2002 4:41 PM
Subject: Re: [skotos-seven] SAM descriptions (again,sorry)


Carl,

>> In reality this would get pretty sluggish; we can talk about how to
>> optimize it in a follow-up mail if you decide to use these hooks.
>>
>> And I do suggest you use them.
>
> ok then, lets talk optimization :)
> I'm going for an approach that will create something along the lines of
> trait:color:description for each trait and these properties will be used
> in simple SAM for the brief, look and examine.

Let's look at two extreme scenarios.

  A) For each trait:blah, you want to create trait:blah:description. In
this case you have nothing to worry about. Each trait:blah will have a
script associated with it that does just what's required.

  B) For each trait:blah, you call i.e. descsub. This is bad because in
many cases, 20 traits will be executed in a single thread (at once) and
each one would trigger a new call to descsub (which is a fairly complex
routine, as I recall). Only one call is required. In this case, there is
need to do something like,

merry:lib:maybe-descsub =
X[M]
   if (this."descsub-already-scheduled") {
     return;
   }
   this."descsub-already-scheduled" = TRUE;
   $delay(0);
   Call(this, "do-descsub");

merry:lib:do-descsub =
X[M]
   Call(this, "descsub");
   this."descsub-already-scheduled" = FALSE;


If you start off doing A) but slowly add components from B), you need to
keep this in mind so that expensive algorithms aren't needlessly run
more than once.

Zell