Index: class.c
==================================================================
--- class.c
+++ class.c
@@ -26,11 +26,11 @@
 #define TF_KEY 0x0100 // token is a Hero Mesh key name
 #define TF_OPEN 0x0400 // token is (
 #define TF_CLOSE 0x0800 // token is )
 #define TF_INT 0x1000 // token is a number
 #define TF_FUNCTION 0x2000 // token is a user function
-#define TF_MACRO 0x4000 // token is a macro; never returned by nxttok()
+#define TF_MACRO 0x4000 // token is a macro
 #define TF_EOF 0x8000 // end of file
 typedef struct {
   const char*txt;
   Uint32 num;
 } Op_Names;
@@ -40,17 +40,39 @@
 Class*classes[0x4000];
 const char*messages[0x4000];
 Uint16 functions[0x4000];
 int max_animation=32;
 Sint32 max_volume=10000;
+Uint8 back_color=1;
 
 #define HASH_SIZE 8888
 #define LOCAL_HASH_SIZE 5555
 typedef struct {
   Uint16 id;
   char*txt;
 } Hash;
+
+typedef struct InputStack {
+  FILE*classfp;
+  int linenum;
+  struct InputStack*next;
+} InputStack;
+
+typedef struct TokenList {
+  Uint16 t;
+  Uint32 v;
+  char*str;
+  Uint16 ref;
+  struct TokenList*next;
+} TokenList;
+
+typedef struct MacroStack {
+  TokenList*tok;
+  Sint16 n;
+  TokenList**args;
+  struct MacroStack*next;
+} MacroStack;
 
 static FILE*classfp;
 static Uint16 tokent;
 static Uint32 tokenv;
 static int linenum=1;
@@ -58,10 +80,13 @@
 static int undef_class=1;
 static int undef_message=0;
 static int num_globals=0;
 static int num_functions=0;
 static Hash*glohash;
+static InputStack*inpstack;
+static MacroStack*macstack;
+static TokenList**macros;
 
 #define ParseError(a,...) fatal("On line %d: " a,linenum,##__VA_ARGS__)
 
 static const unsigned char chkind[256]={
   ['$']=1, ['!']=1, ['\'']=1, ['#']=1, ['@']=1, ['%']=1, ['&']=1, [':']=1,
@@ -69,10 +94,68 @@
   ['A'...'Z']=3, ['a'...'z']=3, ['_']=3, ['?']=3, ['.']=3, ['*']=3, ['/']=3,
 };
 
 #define MIN_VERSION 0
 #define MAX_VERSION 0
+
+#define MAX_MACRO 0x3FC0
+
+#define MAC_ADD 0xFFC0
+#define MAC_SUB 0xFFC1
+#define MAC_MUL 0xFFC2
+#define MAC_DIV 0xFFC3
+#define MAC_MOD 0xFFC4
+#define MAC_BAND 0xFFC5
+#define MAC_BOR 0xFFC6
+#define MAC_BXOR 0xFFC7
+#define MAC_BNOT 0xFFC8
+#define MAC_CAT 0xFFC9
+#define MAC_VERSION 0xFFE0
+#define MAC_DEFINE 0xFFE1
+#define MAC_INCLUDE 0xFFE2
+#define MAC_CALL 0xFFE3
+#define MAC_UNDEFINED 0xFFFF
+
+static TokenList*add_macro(void) {
+  TokenList*o=malloc(sizeof(TokenList));
+  if(!o) fatal("Allocation failed\n");
+  o->t=tokent;
+  o->v=tokenv;
+  o->str=0;
+  o->ref=0;
+  o->next=0;
+  if(*tokenstr) {
+    o->str=strdup(tokenstr);
+    if(!o->str) fatal("Allocation failed\n");
+  }
+  return o;
+}
+
+static void ref_macro(TokenList*o) {
+  while(o) {
+    if(++o->ref==65000) ParseError("Reference count of macro token list overflowed\n");
+    o=o->next;
+  }
+}
+
+static void free_macro(TokenList*o) {
+  TokenList*p;
+  while(o && !o->ref--) {
+    free(o->str);
+    o=(p=o)->next;
+    free(p);
+  }
+}
+
+static inline TokenList*step_macro(TokenList*o) {
+  TokenList*p=o->next;
+  if(!o->ref--) {
+    free(o->str);
+    free(o);
+  }
+  return p;
+}
 
 static void read_quoted_string(void) {
   int c,i,n;
   int isimg=0;
   for(i=0;i<0x1FFD;) {
@@ -195,18 +278,75 @@
     }
     h=(h+1)%size;
     if(h==m) ParseError("Hash table full\n");
   }
 }
+
+static Uint16 look_hash_mac(void) {
+  int h,i,m;
+  for(h=i=0;tokenstr[i];i++) h=(13*h+tokenstr[i])%HASH_SIZE;
+  m=h;
+  for(;;) {
+    if(glohash[h].id>=0xC000 && !strcmp(tokenstr,glohash[h].txt)) return h;
+    if(!glohash[h].id) {
+      glohash[h].txt=strdup(tokenstr);
+      if(!glohash[h].txt) ParseError("Out of string space in hash table\n");
+      glohash[h].id=0xFFFF;
+      return h;
+    }
+    h=(h+1)%HASH_SIZE;
+    if(h==m) ParseError("Hash table full\n");
+  }
+}
 
 #define ReturnToken(x,y) do{ tokent=x; tokenv=y; return; }while(0)
-static void nxttok(void) {
+
+static void nxttok1(void) {
   int c,i,fl,n,pr;
+  magain: if(macstack) {
+    TokenList*tl=0;
+    pr=0;
+    tokent=macstack->tok->t;
+    if(tokent&TF_EOF) ParseError("Unexpected end of file in macro expansion\n");
+    tokenv=macstack->tok->v;
+    *tokenstr=0;
+    if(macstack->tok->str) strcpy(tokenstr,macstack->tok->str);
+    if(tokent==TF_MACRO+TF_INT && macstack->n>=0) {
+      if(tokenv&~0xFF) {
+        tokenv-=0x100;
+      } else {
+        if(tokenv<macstack->n) tl=macstack->args[tokenv];
+        if(tl) ref_macro(tl);
+        pr=1;
+      }
+    }
+    macstack->tok=step_macro(macstack->tok);
+    if(!macstack->tok) {
+      MacroStack*ms=macstack->next;
+      for(i=0;i<macstack->n;i++) free_macro(macstack->args[i]);
+      free(macstack->args);
+      free(macstack);
+      macstack=ms;
+    }
+    if(pr) {
+      if(tl) {
+        MacroStack*ms=malloc(sizeof(MacroStack));
+        if(!ms) fatal("Allocation failed\n");
+        ms->tok=tl;
+        ms->n=-1;
+        ms->args=0;
+        ms->next=macstack;
+        macstack=ms;
+      }
+      goto magain;
+    }
+    return;
+  }
   fl=n=pr=0;
   tokent=tokenv=0;
   *tokenstr=0;
-again:
+  again:
   c=fgetc(classfp);
   while(c==' ' || c=='\t' || c=='\r' || c=='\n') {
     if(c=='\n') ++linenum;
     c=fgetc(classfp);
   }
@@ -229,10 +369,43 @@
     c=fgetc(classfp);
   }
   if(c==',') {
     fl|=TF_COMMA;
     c=fgetc(classfp);
+  }
+  if(c=='{') {
+    c=fgetc(classfp);
+    while(c==' ' || c=='\t' || c=='\r' || c=='\n') {
+      if(c=='\n') ++linenum;
+      c=fgetc(classfp);
+    }
+    while(c>0 && (chkind[c]&2)) {
+      if(n==256) {
+        tokenstr[256]=0;
+        ParseError("Identifier too long: %s\n",tokenstr);
+      }
+      tokenstr[n++]=c;
+      c=fgetc(classfp);
+    }
+    tokenstr[n]=0;
+    if(!n) fatal("Expected macro name\n");
+    if(c!=EOF) ungetc(c,classfp);
+    ReturnToken(TF_MACRO|TF_OPEN,look_hash_mac());
+  }
+  if(c=='}') ReturnToken(TF_MACRO|TF_CLOSE,0);
+  if(c=='|') ReturnToken(TF_MACRO,1);
+  if(c=='\\') {
+    i=0;
+    while((c=fgetc(classfp))=='\\') i+=0x100;
+    tokenv=0;
+    for(;c>='0' && c<='9';c=fgetc(classfp)) tokenv=10*tokenv+c-'0';
+    --tokenv;
+    if(tokenv&~255) ParseError("Macro parameter reference out of range\n");
+    if(c!=EOF) ungetc(c,classfp);
+    tokent=TF_MACRO|TF_INT;
+    tokenv|=i;
+    return;
   }
   if(c==EOF) ParseError("Unexpected end of file\n");
   if(chkind[c]==1) {
     pr=c;
     c=fgetc(classfp);
@@ -326,10 +499,284 @@
       }
       ParseError("Invalid Hero Mesh key name: %s\n",tokenstr);
       break;
   }
 }
+
+static void define_macro(Uint16 name) {
+  int i;
+  TokenList**t;
+  if(glohash[name].id<0xC000) fatal("Confusion\n");
+  if(glohash[name].id<MAX_MACRO+0xC000) {
+    free_macro(macros[i=glohash[name].id-0xC000]);
+    macros[i]=0;
+  } else {
+    for(i=0;i<MAX_MACRO;i++) if(!macros[i]) break;
+    if(i==MAX_MACRO) ParseError("Too many macro definitions\n");
+  }
+  glohash[name].id=i+0xC000;
+  t=macros+i;
+  i=1;
+  for(;;) {
+    nxttok1();
+    if(tokent==TF_MACRO+TF_OPEN && ++i>65000) ParseError("Too much macro nesting\n");
+    if(tokent==TF_MACRO+TF_CLOSE && !--i) break;
+    *t=add_macro();
+    t=&(*t)->next;
+  }
+}
+
+static void begin_include_file(const char*name) {
+  InputStack*nxt=inpstack;
+  inpstack=malloc(sizeof(InputStack));
+  if(!inpstack) fatal("Allocation failed\n");
+  inpstack->classfp=classfp;
+  inpstack->linenum=linenum;
+  inpstack->next=nxt;
+  linenum=1;
+  //TODO: Use the correct directory to load the include file
+  classfp=fopen(name,"r");
+  if(!classfp) ParseError("Cannot open include file \"%s\": %m\n",name);
+}
+
+static void begin_macro(TokenList*mac) {
+  MacroStack*ms=malloc(sizeof(MacroStack));
+  TokenList**ap=0;
+  int a=0;
+  int b=0;
+  int c=0;
+  ref_macro(mac);
+  if(!ms) fatal("Allocation failed\n");
+  ms->tok=mac;
+  ms->n=0;
+  ms->args=0;
+  for(;;) {
+    nxttok1();
+    if(tokent&TF_EOF) ParseError("Unexpected end of file in macro argument\n");
+    if(tokent&TF_OPEN) {
+      ++a;
+      if(tokent&TF_MACRO) ++c;
+    }
+    if(tokent&TF_CLOSE) {
+      --a;
+      if(tokent&TF_MACRO) --c;
+    }
+    if(c==-1) {
+      if(a!=-1 && !b) ParseError("Misnested macro argument\n");
+      ms->next=macstack;
+      macstack=ms;
+      return;
+    } else if(a==-1 && !b) {
+      ParseError("Misnested macro argument\n");
+    } else if(tokent==TF_MACRO && tokenv==1 && !a && !b) {
+      if(c) ParseError("Misnested macro argument\n");
+      b=1;
+      ms->args=realloc(ms->args,++ms->n*sizeof(TokenList*));
+      if(!ms->args) fatal("Allocation failed\n");
+      ap=ms->args+ms->n-1;
+      *ap=0;
+    } else {
+      if(!b && !(tokent&TF_CLOSE) && a==(tokent&TF_OPEN?1:0)) {
+        ms->args=realloc(ms->args,++ms->n*sizeof(TokenList*));
+        if(!ms->args) fatal("Allocation failed\n");
+        ap=ms->args+ms->n-1;
+        *ap=0;
+      }
+      *ap=add_macro();
+      ap=&((*ap)->next);
+    }
+  }
+}
+
+static void nxttok(void) {
+  again:
+  nxttok1();
+  if(tokent&TF_EOF) {
+    if(inpstack) {
+      InputStack s=*inpstack;
+      free(inpstack);
+      fclose(classfp);
+      classfp=s.classfp;
+      linenum=s.linenum;
+      inpstack=s.next;
+      goto again;
+    }
+  } else if(tokent&TF_MACRO) {
+    Uint32 n;
+    char*s;
+    if(tokent&TF_OPEN) {
+      call:
+      switch(glohash[tokenv].id) {
+        case 0xC000 ... MAX_MACRO+0xC000-1:
+          begin_macro(macros[glohash[tokenv].id-0xC000]);
+          goto again;
+        case MAC_ADD:
+          n=0;
+          for(;;) {
+            nxttok();
+            if(tokent==TF_MACRO+TF_CLOSE) break;
+            if(tokent!=TF_INT) ParseError("Number expected\n");
+            n+=tokenv;
+          }
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_SUB:
+          nxttok();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          n=tokenv;
+          nxttok();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          n-=tokenv;
+          nxttok();
+          if(tokent!=TF_MACRO+TF_CLOSE) ParseError("Too many macro arguments\n");
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_MUL:
+          n=1;
+          for(;;) {
+            nxttok();
+            if(tokent==TF_MACRO+TF_CLOSE) break;
+            if(tokent!=TF_INT) ParseError("Number expected\n");
+            n*=tokenv;
+          }
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_DIV:
+          nxttok();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          n=tokenv;
+          nxttok();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          if(!tokenv) ParseError("Division by zero\n");
+          n/=tokenv;
+          nxttok();
+          if(tokent!=TF_MACRO+TF_CLOSE) ParseError("Too many macro arguments\n");
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_MOD:
+          nxttok();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          n=tokenv;
+          nxttok();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          if(!tokenv) ParseError("Division by zero\n");
+          n%=tokenv;
+          nxttok();
+          if(tokent!=TF_MACRO+TF_CLOSE) ParseError("Too many macro arguments\n");
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_BAND:
+          n=-1;
+          for(;;) {
+            nxttok();
+            if(tokent==TF_MACRO+TF_CLOSE) break;
+            if(tokent!=TF_INT) ParseError("Number expected\n");
+            n&=tokenv;
+          }
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_BOR:
+          n=0;
+          for(;;) {
+            nxttok();
+            if(tokent==TF_MACRO+TF_CLOSE) break;
+            if(tokent!=TF_INT) ParseError("Number expected\n");
+            n|=tokenv;
+          }
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_BXOR:
+          n=0;
+          for(;;) {
+            nxttok();
+            if(tokent==TF_MACRO+TF_CLOSE) break;
+            if(tokent!=TF_INT) ParseError("Number expected\n");
+            n^=tokenv;
+          }
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_BNOT:
+          nxttok();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          n=~tokenv;
+          nxttok();
+          if(tokent!=TF_MACRO+TF_CLOSE) ParseError("Too many macro arguments\n");
+          tokent=TF_INT;
+          tokenv=n;
+          break;
+        case MAC_CAT:
+          s=malloc(0x2000);
+          if(!s) fatal("Allocation failed\n");
+          n=0;
+          for(;;) {
+            nxttok();
+            if(tokent==TF_MACRO+TF_CLOSE) {
+              break;
+            } else if(tokent==TF_INT) {
+              sprintf(tokenstr,"%d",tokenv);
+              goto isname;
+            } else if(tokent&TF_NAME) {
+              isname:
+              if(strlen(tokenstr)+n>=0x1FFE) ParseError("Concatenated string too long\n");
+              strcpy(s+n,tokenstr);
+              n+=strlen(tokenstr);
+            } else if(tokent!=TF_MACRO || tokenv!=1) {
+              ParseError("Number or string or name expected\n");
+            }
+          }
+          s[n]=0;
+          strcpy(tokenstr,s);
+          free(s);
+          ReturnToken(TF_NAME|TF_ABNORMAL,OP_STRING);
+        case MAC_VERSION:
+          nxttok1();
+          if(tokent!=TF_INT) ParseError("Number expected\n");
+          if(tokenv<MIN_VERSION || tokenv>MAX_VERSION) ParseError("Version number out of range\n");
+          nxttok1();
+          if(tokent!=TF_MACRO+TF_CLOSE) ParseError("Too many macro arguments\n");
+          goto again;
+        case MAC_DEFINE:
+          if(!macros) {
+            macros=calloc(MAX_MACRO,sizeof(TokenList*));
+            if(!macros) fatal("Allocation failed\n");
+          }
+          nxttok();
+          if(!(tokent&TF_NAME) || tokenv!=OP_STRING) ParseError("String literal expected\n");
+          define_macro(look_hash_mac());
+          goto again;
+        case MAC_INCLUDE:
+          if(macstack) ParseError("Cannot use {include} inside of a macro\n");
+          nxttok1();
+          if(tokent==TF_MACRO && tokenv==1) ReturnToken(TF_EOF,0);
+          if(!(tokent&TF_NAME) || tokenv!=OP_STRING) ParseError("String literal expected\n");
+          n=look_hash_mac();
+          nxttok1();
+          if(tokent!=TF_MACRO+TF_CLOSE) ParseError("Too many macro arguments\n");
+          begin_include_file(glohash[n].txt);
+          goto again;
+        case MAC_CALL:
+          nxttok();
+          if(!(tokent&TF_NAME) || tokenv!=OP_STRING) ParseError("String literal expected\n");
+          tokenv=look_hash_mac();
+          goto call;
+        case MAC_UNDEFINED:
+          ParseError("Undefined macro: {%s}\n",tokenstr);
+          break;
+        default:
+          ParseError("Strange macro token: 0x%04X\n",glohash[tokenv].id);
+      }
+    }
+  }
+}
 
 void load_classes(void) {
   int i;
   char*nam=sqlite3_mprintf("%s.class",basefilename);
   if(!nam) fatal("Allocation failed\n");
@@ -336,10 +783,24 @@
   classfp=fopen(nam,"r");
   sqlite3_free(nam);
   if(!classfp) fatal("Cannot open class file '%s': %m\n",nam);
   glohash=calloc(HASH_SIZE,sizeof(Hash));
   if(!glohash) fatal("Allocation failed\n");
+  strcpy(tokenstr,"+"); glohash[look_hash_mac()].id=MAC_ADD;
+  strcpy(tokenstr,"-"); glohash[look_hash_mac()].id=MAC_SUB;
+  strcpy(tokenstr,"*"); glohash[look_hash_mac()].id=MAC_MUL;
+  strcpy(tokenstr,"/"); glohash[look_hash_mac()].id=MAC_DIV;
+  strcpy(tokenstr,"mod"); glohash[look_hash_mac()].id=MAC_MOD;
+  strcpy(tokenstr,"band"); glohash[look_hash_mac()].id=MAC_BAND;
+  strcpy(tokenstr,"bor"); glohash[look_hash_mac()].id=MAC_BOR;
+  strcpy(tokenstr,"bxor"); glohash[look_hash_mac()].id=MAC_BXOR;
+  strcpy(tokenstr,"bnot"); glohash[look_hash_mac()].id=MAC_BNOT;
+  strcpy(tokenstr,"cat"); glohash[look_hash_mac()].id=MAC_CAT;
+  strcpy(tokenstr,"version"); glohash[look_hash_mac()].id=MAC_VERSION;
+  strcpy(tokenstr,"define"); glohash[look_hash_mac()].id=MAC_DEFINE;
+  strcpy(tokenstr,"include"); glohash[look_hash_mac()].id=MAC_INCLUDE;
+  strcpy(tokenstr,"call"); glohash[look_hash_mac()].id=MAC_CALL;
   if(main_options['L']) {
     for(;;) {
       nxttok();
       printf("** %5d %04X %08X \"",linenum,tokent,tokenv);
       for(i=0;tokenstr[i];i++) {
@@ -351,9 +812,14 @@
     }
   }
   
   done:
   fclose(classfp);
+  if(main_options['H']) {
+    for(i=0;i<HASH_SIZE;i++) if(glohash[i].id) printf("\"%s\": %04X\n",glohash[i].txt,glohash[i].id);
+  }
   for(i=0;i<HASH_SIZE;i++) free(glohash[i].txt);
   free(glohash);
-  for(i=1;i<undef_class;i++) if(classes[i] && (classes[i]->cflags&CF_NOCLASS1)) fatal("Class $%s mentioned but not defined",classes[i]->name);
+  for(i=1;i<undef_class;i++) if(classes[i] && (classes[i]->cflags&CF_NOCLASS1)) fatal("Class $%s mentioned but not defined\n",classes[i]->name);
+  if(macros) for(i=0;i<MAX_MACRO;i++) if(macros[i]) free_macro(macros[i]);
+  free(macros);
 }

Index: heromesh.h
==================================================================
--- heromesh.h
+++ heromesh.h
@@ -82,12 +82,14 @@
   Uint8 cflags,shape,shovable,collisionLayers,nimages;
 } Class;
 
 extern Class*classes[0x4000]; // 0 isn't a real class
 extern const char*messages[0x4000]; // index is 256 less than message number
+extern Uint16 functions[0x4000];
 extern int max_animation; // max steps in animation queue (default 32)
 extern Sint32 max_volume; // max total volume to allow moving diagonally (default 10000)
+extern Uint8 back_color;
 
 void load_classes(void);
 
 // == bindings ==
 

Index: instruc
==================================================================
--- instruc
+++ instruc
@@ -154,13 +154,15 @@
 ,=Departures
 ,=Busy
 ,=Invisible
 ,=KeyCleared
 ,=UserSignal
+,=UserState
 ,=VisualOnly
 ,=Stealthy
 ,=Moved
+,Destroyed
 ,Player
 ,Compatible
 Self
 Msg
 From
@@ -170,10 +172,11 @@
 MoveNumber
 Level
 Key
 
 ; Class definitions
+-Background ; used at top level only; not in a class
 -Input
 -Quiz
 -InPlace
 -DefaultImage
 -Help
@@ -207,13 +210,15 @@
 .,MovePlus "Move+" ; obj.Inertia+=Strength instead of obj.Inertia=Strength
 .,MoveTo ; the internal MoveTo() function
 NewX
 NewY
 ,ObjAbove
-ObjClassAt
 ,ObjBelow
+ObjBottomAt
+ObjClassAt
 ,ObjDir
+ObjTopAt
 PopUp
 *PopUpArgs ; for (PopUp [number])
 QueueTurn ; queue another turn that automatically occurs after this one
 .,Send
 .,SendEx ; send with three arguments

Index: instruc.h
==================================================================
--- instruc.h
+++ instruc.h
@@ -217,140 +217,149 @@
 #define OP_KEYCLEARED_EC 39003
 #define OP_USERSIGNAL 32860
 #define OP_USERSIGNAL_C 34908
 #define OP_USERSIGNAL_E 36956
 #define OP_USERSIGNAL_EC 39004
-#define OP_VISUALONLY 32861
-#define OP_VISUALONLY_C 34909
-#define OP_VISUALONLY_E 36957
-#define OP_VISUALONLY_EC 39005
-#define OP_STEALTHY 32862
-#define OP_STEALTHY_C 34910
-#define OP_STEALTHY_E 36958
-#define OP_STEALTHY_EC 39006
-#define OP_MOVED 32863
-#define OP_MOVED_C 34911
-#define OP_MOVED_E 36959
-#define OP_MOVED_EC 39007
-#define OP_PLAYER 32864
-#define OP_PLAYER_C 34912
-#define OP_COMPATIBLE 32865
-#define OP_COMPATIBLE_C 34913
-#define OP_SELF 32866
-#define OP_MSG 32867
-#define OP_FROM 32868
-#define OP_ARG1 32869
-#define OP_ARG1_E 36965
-#define OP_ARG2 32870
-#define OP_ARG2_E 36966
-#define OP_ARG3 32871
-#define OP_ARG3_E 36967
-#define OP_MOVENUMBER 32872
-#define OP_LEVEL 32873
-#define OP_KEY 32874
-#define OP_INPUT 32875
-#define OP_QUIZ 32876
-#define OP_INPLACE 32877
-#define OP_DEFAULTIMAGE 32878
-#define OP_HELP 32879
-#define OP_EDITORHELP 32880
-#define OP_SUBS 32881
-#define OP_ANIMATE 32882
-#define OP_ASSASSINATE 32883
-#define OP_ASSASSINATE_C 34931
-#define OP_BROADCAST 32884
-#define OP_BROADCAST_D 41076
-#define OP_BROADCASTCLASS 32885
-#define OP_BROADCASTEX 32886
-#define OP_BROADCASTEX_D 41078
-#define OP_BROADCASTSUM 32887
-#define OP_BROADCASTSUMEX 32888
-#define OP_CREATE 32889
-#define OP_CREATE_D 41081
-#define OP_DELINVENTORY 32890
-#define OP_DELTA 32891
-#define OP_DESTROY 32892
-#define OP_DESTROY_C 34940
-#define OP_DESTROY_D 41084
-#define OP_DESTROY_CD 43132
-#define OP_FLUSHCLASS 32893
-#define OP_FLUSHOBJ 32894
-#define OP_GETINVENTORY 32895
-#define OP_HEIGHTAT 32896
-#define OP_IGNOREKEY 32897
-#define OP_INTMOVE 32898
-#define OP_INTMOVE_C 34946
-#define OP_INTMOVE_D 41090
-#define OP_INTMOVE_CD 43138
-#define OP_JUMPTO 32899
-#define OP_JUMPTO_C 34947
-#define OP_LOC 32900
-#define OP_LOC_C 34948
-#define OP_LOCATEME 32901
-#define OP_LOSELEVEL 32902
-#define OP_MAXINVENTORY 32903
-#define OP_MOVE 32904
-#define OP_MOVE_C 34952
-#define OP_MOVE_D 41096
-#define OP_MOVE_CD 43144
-#define OP_MOVEPLUS 32905
-#define OP_MOVEPLUS_C 34953
-#define OP_MOVEPLUS_D 41097
-#define OP_MOVEPLUS_CD 43145
-#define OP_MOVETO 32906
-#define OP_MOVETO_C 34954
-#define OP_MOVETO_D 41098
-#define OP_MOVETO_CD 43146
-#define OP_NEWX 32907
-#define OP_NEWY 32908
-#define OP_OBJABOVE 32909
-#define OP_OBJABOVE_C 34957
-#define OP_OBJCLASSAT 32910
-#define OP_OBJBELOW 32911
-#define OP_OBJBELOW_C 34959
-#define OP_OBJDIR 32912
-#define OP_OBJDIR_C 34960
-#define OP_POPUP 32913
-#define OP_POPUPARGS 32914
-#define OP_QUEUETURN 32915
-#define OP_SEND 32916
-#define OP_SEND_C 34964
-#define OP_SEND_D 41108
-#define OP_SEND_CD 43156
-#define OP_SENDEX 32917
-#define OP_SENDEX_C 34965
-#define OP_SENDEX_D 41109
-#define OP_SENDEX_CD 43157
-#define OP_SETINVENTORY 32918
-#define OP_SOUND 32919
-#define OP_TRACE 32920
-#define OP_VOLUMEAT 32921
-#define OP_WINLEVEL 32922
-#define OP_XDIR 32923
-#define OP_XDIR_C 34971
-#define OP_YDIR 32924
-#define OP_YDIR_C 34972
-#define OP_FUNCTION 32925
-#define OP_LOCAL 32926
-#define OP_LABEL 32927
-#define OP_STRING 32928
+#define OP_USERSTATE 32861
+#define OP_USERSTATE_C 34909
+#define OP_USERSTATE_E 36957
+#define OP_USERSTATE_EC 39005
+#define OP_VISUALONLY 32862
+#define OP_VISUALONLY_C 34910
+#define OP_VISUALONLY_E 36958
+#define OP_VISUALONLY_EC 39006
+#define OP_STEALTHY 32863
+#define OP_STEALTHY_C 34911
+#define OP_STEALTHY_E 36959
+#define OP_STEALTHY_EC 39007
+#define OP_MOVED 32864
+#define OP_MOVED_C 34912
+#define OP_MOVED_E 36960
+#define OP_MOVED_EC 39008
+#define OP_DESTROYED 32865
+#define OP_DESTROYED_C 34913
+#define OP_PLAYER 32866
+#define OP_PLAYER_C 34914
+#define OP_COMPATIBLE 32867
+#define OP_COMPATIBLE_C 34915
+#define OP_SELF 32868
+#define OP_MSG 32869
+#define OP_FROM 32870
+#define OP_ARG1 32871
+#define OP_ARG1_E 36967
+#define OP_ARG2 32872
+#define OP_ARG2_E 36968
+#define OP_ARG3 32873
+#define OP_ARG3_E 36969
+#define OP_MOVENUMBER 32874
+#define OP_LEVEL 32875
+#define OP_KEY 32876
+#define OP_BACKGROUND 32877
+#define OP_INPUT 32878
+#define OP_QUIZ 32879
+#define OP_INPLACE 32880
+#define OP_DEFAULTIMAGE 32881
+#define OP_HELP 32882
+#define OP_EDITORHELP 32883
+#define OP_SUBS 32884
+#define OP_ANIMATE 32885
+#define OP_ASSASSINATE 32886
+#define OP_ASSASSINATE_C 34934
+#define OP_BROADCAST 32887
+#define OP_BROADCAST_D 41079
+#define OP_BROADCASTCLASS 32888
+#define OP_BROADCASTEX 32889
+#define OP_BROADCASTEX_D 41081
+#define OP_BROADCASTSUM 32890
+#define OP_BROADCASTSUMEX 32891
+#define OP_CREATE 32892
+#define OP_CREATE_D 41084
+#define OP_DELINVENTORY 32893
+#define OP_DELTA 32894
+#define OP_DESTROY 32895
+#define OP_DESTROY_C 34943
+#define OP_DESTROY_D 41087
+#define OP_DESTROY_CD 43135
+#define OP_FLUSHCLASS 32896
+#define OP_FLUSHOBJ 32897
+#define OP_GETINVENTORY 32898
+#define OP_HEIGHTAT 32899
+#define OP_IGNOREKEY 32900
+#define OP_INTMOVE 32901
+#define OP_INTMOVE_C 34949
+#define OP_INTMOVE_D 41093
+#define OP_INTMOVE_CD 43141
+#define OP_JUMPTO 32902
+#define OP_JUMPTO_C 34950
+#define OP_LOC 32903
+#define OP_LOC_C 34951
+#define OP_LOCATEME 32904
+#define OP_LOSELEVEL 32905
+#define OP_MAXINVENTORY 32906
+#define OP_MOVE 32907
+#define OP_MOVE_C 34955
+#define OP_MOVE_D 41099
+#define OP_MOVE_CD 43147
+#define OP_MOVEPLUS 32908
+#define OP_MOVEPLUS_C 34956
+#define OP_MOVEPLUS_D 41100
+#define OP_MOVEPLUS_CD 43148
+#define OP_MOVETO 32909
+#define OP_MOVETO_C 34957
+#define OP_MOVETO_D 41101
+#define OP_MOVETO_CD 43149
+#define OP_NEWX 32910
+#define OP_NEWY 32911
+#define OP_OBJABOVE 32912
+#define OP_OBJABOVE_C 34960
+#define OP_OBJBELOW 32913
+#define OP_OBJBELOW_C 34961
+#define OP_OBJBOTTOMAT 32914
+#define OP_OBJCLASSAT 32915
+#define OP_OBJDIR 32916
+#define OP_OBJDIR_C 34964
+#define OP_OBJTOPAT 32917
+#define OP_POPUP 32918
+#define OP_POPUPARGS 32919
+#define OP_QUEUETURN 32920
+#define OP_SEND 32921
+#define OP_SEND_C 34969
+#define OP_SEND_D 41113
+#define OP_SEND_CD 43161
+#define OP_SENDEX 32922
+#define OP_SENDEX_C 34970
+#define OP_SENDEX_D 41114
+#define OP_SENDEX_CD 43162
+#define OP_SETINVENTORY 32923
+#define OP_SOUND 32924
+#define OP_TRACE 32925
+#define OP_VOLUMEAT 32926
+#define OP_WINLEVEL 32927
+#define OP_XDIR 32928
+#define OP_XDIR_C 34976
+#define OP_YDIR 32929
+#define OP_YDIR_C 34977
+#define OP_FUNCTION 32930
+#define OP_LOCAL 32931
+#define OP_LABEL 32932
+#define OP_STRING 32933
 #ifdef HEROMESH_CLASS
 static const Op_Names op_names[]={
 {"*",8486933},
 {"+",8421395},
 {"-",8421396},
 {".",10518528},
 {"/",8486934},
 {"ANHH",8389394},
 {"ARRIVED",8389124},
-{"Animate",8421490},
-{"Arg1",8552549},
-{"Arg2",8552550},
-{"Arg3",8552551},
+{"Animate",8421493},
+{"Arg1",8552551},
+{"Arg2",8552552},
+{"Arg3",8552553},
 {"Arrivals",8618071},
 {"Arrived",8618069},
-{"Assassinate",8487027},
+{"Assassinate",8487030},
 {"B",9437196},
 {"BANG",8389380},
 {"BEDOINGNG",8389406},
 {"BEEDEEP",8389404},
 {"BEGIN_TURN",8389123},
@@ -358,14 +367,15 @@
 {"BOUNCE",8389415},
 {"BRRREEET",8389396},
 {"BRRRT",8389395},
 {"BUZZER",8389420},
 {"BWEEP",8389397},
-{"Broadcast",10518644},
-{"BroadcastEx",10518646},
-{"BroadcastSum",8421495},
-{"BroadcastSumEx",8421496},
+{"Background",8683629},
+{"Broadcast",10518647},
+{"BroadcastEx",10518649},
+{"BroadcastSum",8421498},
+{"BroadcastSumEx",8421499},
 {"Busy",8618073},
 {"CHEEP",8389393},
 {"CHYEW",8389392},
 {"CLEANUP",8389140},
 {"CLICK",8389388},
@@ -373,115 +383,118 @@
 {"COLLIDING",8389141},
 {"CREATE",8389121},
 {"CREATED",8389137},
 {"Class",8486955},
 {"Climb",9142335},
-{"Compatible",8487009},
-{"Create",10518649},
+{"Compatible",8487011},
+{"Create",10518652},
 {"DEEP_POP",8389417},
 {"DEPARTED",8389125},
 {"DESTROY",8389122},
 {"DESTROYED",8389136},
 {"DINK",8389390},
 {"DOOR",8389378},
 {"DRLRLRINK",8389398},
 {"DYUPE",8389413},
-{"DefaultImage",8683630},
-{"DelInventory",8421498},
-{"Delta",8421499},
+{"DefaultImage",8683633},
+{"DelInventory",8421501},
+{"Delta",8421502},
 {"Density",9142327},
 {"Departed",8618070},
 {"Departures",8618072},
-{"Destroy",10584188},
+{"Destroy",10584191},
+{"Destroyed",8487009},
 {"Dir",8618033},
 {"Distance",9142325},
 {"E",9437184},
 {"END_TURN",8389139},
-{"EditorHelp",8683632},
+{"EditorHelp",8683635},
 {"F",9437192},
 {"FAROUT",8389421},
 {"FFFFTT",8389399},
 {"FLOATED",8389132},
 {"FROG",8389383},
-{"FlushClass",8421501},
-{"FlushObj",8421502},
-{"From",8421476},
+{"FlushClass",8421504},
+{"FlushObj",8421505},
+{"From",8421478},
 {"GLASS",8389379},
 {"GLISSANT",8389419},
-{"GetInventory",8421503},
+{"GetInventory",8421506},
 {"HAWK",8389425},
 {"HEARTBEAT",8389407},
 {"HIT",8389134},
 {"HITBY",8389135},
 {"Hard",8618051},
 {"Height",9142333},
-{"HeightAt",8421504},
-{"Help",8683631},
+{"HeightAt",8421507},
+{"Help",8683634},
 {"INIT",8389120},
-{"IgnoreKey",8421505},
+{"IgnoreKey",8421508},
 {"Image",8618034},
-{"InPlace",8683629},
+{"InPlace",8683632},
 {"Inertia",9142323},
-{"Input",8683627},
-{"IntMove",10584194},
+{"Input",8683630},
+{"IntMove",10584197},
 {"Invisible",8618074},
 {"JAYAYAYNG",8389416},
 {"JUMPED",8389128},
-{"JumpTo",8487043},
+{"JumpTo",8487046},
 {"KEWEL",8389422},
 {"KEY",8389129},
 {"KLECK",8389387},
 {"KLINKK",8389385},
-{"Key",8421482},
+{"Key",8421484},
 {"KeyCleared",8618075},
 {"L",9437194},
 {"LASTIMAGE",8389126},
 {"LB",9437195},
 {"LF",9437193},
 {"LOCK",8389408},
 {"LOOP",8388610},
-{"Level",8421481},
-{"Loc",8487044},
-{"LocateMe",8421509},
-{"LoseLevel",8421510},
+{"Level",8421483},
+{"Loc",8487047},
+{"LocateMe",8421512},
+{"LoseLevel",8421513},
 {"MOVED",8389127},
 {"MOVING",8389130},
-{"MaxInventory",8421511},
+{"MaxInventory",8421514},
 {"Misc1",9142343},
 {"Misc2",9142345},
 {"Misc3",9142347},
 {"Misc4",9142349},
 {"Misc5",9142351},
 {"Misc6",9142353},
 {"Misc7",9142355},
-{"Move",10584200},
-{"Move+",10584201},
-{"MoveNumber",8421480},
-{"MoveTo",10584202},
-{"Moved",8618079},
-{"Msg",8421475},
+{"Move",10584203},
+{"Move+",10584204},
+{"MoveNumber",8421482},
+{"MoveTo",10584205},
+{"Moved",8618080},
+{"Msg",8421477},
 {"N",9437186},
 {"NE",9437185},
 {"NW",9437187},
-{"NewX",8421515},
-{"NewY",8421516},
+{"NewX",8421518},
+{"NewY",8421519},
 {"OLDPHONE",8389402},
 {"ONCE",8388609},
 {"OSC",8388616},
 {"OSCLOOP",8388618},
-{"ObjAbove",8487053},
-{"ObjBelow",8487055},
-{"ObjClassAt",8421518},
-{"ObjDir",8487056},
+{"ObjAbove",8487056},
+{"ObjBelow",8487057},
+{"ObjBottomAt",8421522},
+{"ObjClassAt",8421523},
+{"ObjDir",8487060},
+{"ObjTopAt",8421525},
 {"PLAYERMOVING",8389133},
 {"POSTINIT",8389138},
 {"POUR",8389377},
 {"POWER",8389386},
-{"Player",8487008},
-{"PopUp",8421521},
-{"QueueTurn",8421523},
-{"Quiz",8683628},
+{"Player",8487010},
+{"PopUp",8421526},
+{"QueueTurn",8421528},
+{"Quiz",8683631},
 {"R",9437198},
 {"RATCHET1",8389418},
 {"RATCHET2",8389412},
 {"RATTLE",8389403},
 {"RB",9437197},
@@ -490,46 +503,47 @@
 {"SE",9437191},
 {"SMALL_POP",8389389},
 {"SPLASH",8389376},
 {"STEAM",8389424},
 {"STOP",8388608},
-{"SUBS",8683633},
+{"SUBS",8683636},
 {"SUNK",8389131},
 {"SW",9437189},
-{"Self",8421474},
-{"Send",10584212},
-{"SendEx",10584213},
-{"SetInventory",8421526},
+{"Self",8421476},
+{"Send",10584217},
+{"SendEx",10584218},
+{"SetInventory",8421531},
 {"Shape",8618030},
 {"ShapeDir",8618053},
 {"Sharp",8618052},
 {"Shovable",8618054},
-{"Sound",8421527},
-{"Stealthy",8618078},
+{"Sound",8421532},
+{"Stealthy",8618079},
 {"Strength",9142337},
 {"TAHTASHH",8389409},
 {"THMP_thmp",8389405},
 {"THWIT",8389384},
 {"TICK",8389391},
 {"Temperature",9142316},
-{"Trace",8421528},
+{"Trace",8421533},
 {"UH_OH",8389382},
 {"UNCORK",8389414},
 {"UNHH",8389381},
 {"UserSignal",8618076},
+{"UserState",8618077},
 {"VACUUM",8389411},
-{"VisualOnly",8618077},
+{"VisualOnly",8618078},
 {"Volume",9142329},
-{"VolumeAt",8421529},
+{"VolumeAt",8421534},
 {"W",9437188},
 {"WAHOO",8389400},
 {"WHACK",8389423},
 {"Weight",9142331},
-{"WinLevel",8421530},
-{"XDir",8487067},
+{"WinLevel",8421535},
+{"XDir",8487072},
 {"Xloc",8486959},
-{"YDir",8487068},
+{"YDir",8487073},
 {"YEEHAW",8389401},
 {"Yloc",8486960},
 {"again",8683530},
 {"band",8421403},
 {"begin",8683529},
@@ -597,7 +611,7 @@
 {"then",8683527},
 {"tuck",8421380},
 {"until",8683531},
 {"while",8683532},
 };
-#define N_OP_NAMES 263
+#define N_OP_NAMES 268
 #endif

Index: main.c
==================================================================
--- main.c
+++ main.c
@@ -255,17 +255,17 @@
   }
 }
 
 int main(int argc,char**argv) {
   int optind=1;
-  fprintf(stderr,"FREE HERO MESH\n");
   while(argc>optind && argv[optind][0]=='-') {
     int i;
     const char*s=argv[optind++];
     if(s[1]=='-' && !s[2]) break;
     for(i=1;s[i];i++) main_options[s[i]&127]=1;
   }
+  if(!main_options['c']) fprintf(stderr,"FREE HERO MESH\n");
   if(argc<=optind) fatal("usage: %s [switches] [--] basename [options...]\n",argc?argv[0]:"heromesh");
   if(xrm_init(realloc)) fatal("Failed to initialize resource manager\n");
   if(xrm_init_quarks(global_quarks)) fatal("Failed to initialize resource manager\n");
   resourcedb=xrm_create();
   if(!resourcedb) fatal("Allocation of resource database failed\n");
@@ -273,10 +273,14 @@
   if(argc>optind && argv[1][0]=='=') {
     globalclassname=argv[optind++]+1;
   } else if(find_globalclassname()) {
     globalclassname=strrchr(basefilename,'/');
     globalclassname=globalclassname?globalclassname+1:basefilename;
+  }
+  if(main_options['c']) {
+    load_classes();
+    return 0;
   }
   load_options();
   if(argc>optind) read_options(argc-optind,argv+optind);
   *optionquery=xrm_make_quark(globalclassname,0)?:xrm_anyq;
   init_sql();