User:Marinus/ZOMBIE interpreter

Please note that this isn't tested very well. Also note that it uses strings "like this" (the original specification didn't tell me what kind of strings to use, but the Hello World example uses them).


 * 1) !/usr/bin/env python


 * 1) This is the world's first (I think) implementation of the
 * 2) ZOMBIE-ORIENTED MACHINE BEING INTERFACE ENGINE
 * 3) You know, like Hex, but with evil beings! Written in Python to offset the evil a bit.
 * 4) Evil necromancers might want to go here:
 * 5)  http://www.dangermouse.net/esoteric/zombie.html
 * 6) to read the specification, which was made over two years ago, and still nobody
 * 7) dared implement it.
 * 1)  http://www.dangermouse.net/esoteric/zombie.html
 * 2) to read the specification, which was made over two years ago, and still nobody
 * 3) dared implement it.

import re,sys,thread,time,random

comment_re = re.compile("\{.*?\}", re.DOTALL) declaration_re = re.compile(r'([A-Za-z0-9_\-]*?)\s+is\s+an?\s+(zombie|enslaved undead|' + \ r'ghost|restless undead|vampire|free-willed undead' + \ r'|demon|djinn)', re.I)
 * 1) regexps recognizing syntax elements

task_re = re.compile("task\s+([A-Za-z0-9_-]*)", re.I) remember_re = re.compile("remember\s+(.*)", re.I)

string_re = re.compile('".*?"') integer_re = re.compile('[\-0-9\.]+')

kill=False

def die(msg): global kill print "--- Fatal error: %s" % msg kill=True sys.exit
 * 1) error message


 * 1) split line according to whitespace, but keep strings intact

def splitline(string): cmds = [] # break line up into pieces prev_whitespace = False in_string = False temp = '' for c in reversed(range(0,len(string))): if string[c]==' ' and not (prev_whitespace or in_string): prev_whitespace = True cmds.insert(0,temp) temp = "" elif string[c]!=' ' or in_string: prev_whitespace = False if string[c]=='"': in_string = not in_string        temp = string[c]+temp   cmds.insert(0,temp)   return cmds class Entity:   environment = None   name = ''   memory = None   tasks = []   def runtasks(self):      self.active=True      # makes a thread; runs the tasks as the specific entity type does.      thread.start_new_thread( self.taskthread,  )   def taskthread(self):      pass; # overloaded by individual entities that have their own way of doing things
 * 1) Entity objects

def activate(self): self.active=True self.runtasks def banish(self): self.active=False # task threads check for this and stop class Undead (Entity): pass # which is what we make at undead people, of course :-) class Zombie (Undead):  active = False # zombies require animating   # zombies run their tasks in order   def taskthread(self):      while self.active and (not kill):         for task in [t for t in self.tasks if t.active]:            if not self.active: break            task.run            task.active=False         time.sleep(.05)         if not [t for t in self.tasks if t.active]: self.active = False

class Ghost (Undead): active = False # ghosts require desturbing # ghosts run their tasks in order, but may wait before starting a new task def taskthread(self): while self.active and (not kill): for task in [t for t in self.tasks if t.active]: time.sleep(int(random.random * 60)) if not self.active: break task.run task.active=False if not [t for t in self.tasks if t.active]: self.active = False class Vampire (Undead): active = True # vampires are active immediately # vampires process their tasks in random order def taskthread(self): random.shuffle(self.tasks) # tasks in random order while self.active and (not kill): for task in [t for t in self.tasks if t.active]: if not self.active: break task.run task.active=False time.sleep(.05) if not [t for t in self.tasks if t.active]: self.active = False

class Demon (Entity): active = True # demons are always active

# demons process their tasks in random order, and sometimes multiple times def taskthread(self): random.shuffle(self.tasks) # tasks in random order # may run multiple tasks at once (this may cause weird things to happen with     # threading, but I don't care; you shouldn't trust demons anyway) if bool(int(random.random * 4)): thread.start_new_thread( self.taskthread, ) while self.active and (not kill): for task in [t for t in self.tasks if t.active]: if not self.active: break task.run task.active= not bool(int(random.random*4)) # 1 in 4 chance a task will be repeated time.sleep(.05) if not [t for t in self.tasks if t.active]: self.active = False class Djinn (Entity): active = True # djinn are always active def taskthread(self): random.shuffle(self.tasks) # tasks in random order # may run multiple tasks at once (this may cause weird things to happen with     # threading, but I don't care; you shouldn't trust demons anyway) if bool(int(random.random * 4)): thread.start_new_thread( self.taskthread, ) while self.active and (not kill): for task in [t for t in self.tasks if t.active]: if not self.active: break # tasks may not run at all if task.active: task.active= not bool(int(random.random*4)) # 1 in 4 chance a task will be repeated if task.active: task.run time.sleep(.05) if not [t for t in self.tasks if t.active]: self.active = False class Task: entity = None lines = [] name = '' active = False def __init__(self): self.commands = \ {'animate': self.c_animate, 'banish': self.c_banish, 'disturb': self.c_disturb, 'forget': self.c_forget, 'invoke': self.c_invoke, 'moan': self.c_moan, 'remember': self.c_remember, 'say': self.c_say} # commands def c_animate(self,stack): if stack and len(stack)>=1 and isinstance(stack[-1],Entity): if not isinstance(stack[-1], Zombie): die("task %s, entity %s: attempt to animate non-zombie entity %s." % \               (self.name, self.entity.name, stack[-1].name)) stack.pop.activate else: if not isinstance(self.entity, Zombie): die("task %s, entity %s: attempt to animate non-zombie entity %s." % \               (self.name, self.entity.name, self.entity.name)) self.entity.activate def c_banish(self,stack): if stack and len(stack)>=1 and isinstance(stack[-1],Entity): stack.pop.banish else: self.entity.banish def c_disturb(self,stack): if stack and len(stack)>=1 and isinstance(stack[-1],Entity): if not isinstance(stack[-1], Ghost): die("task %s, entity %s: attempt to disturb non-ghost entity %s." % \               (self.name, self.entity.name, stack[-1].name)) stack.pop.activate else: if not isinstance(self.entity, Ghost): die("task %s, entity %s: attempt to disturb non-ghost entity %s." % \               (self.name, self.entity.name, self.entity.name)) self.entity.activate def c_forget(self,stack): if stack and len(stack)>=1 and isinstance(stack[-1],Entity): stack.pop.memory=None else: self.entity.memory=None def c_invoke(self,stack): if stack and len(stack)>=1 and isinstance(stack[-1],Entity): stack.pop.activate else: self.entity.activate def c_moan(self,stack): if stack and len(stack)>=1 and isinstance(stack[-1],Entity): #sys.stdout.write(str(stack[-1].memory)) stack.append(stack.pop.memory) else: stack.append(self.entity.memory) #sys.stdout.write(str(self.entity.memory)) def c_remember(self,stack): #print "\n Remember :%s: " % str(stack) if stack and len(stack)>=1 and isinstance(stack[-1],Entity): theEntity = stack[-1] values = stack[:-1] else: theEntity = self.entity values = stack total = 0 for value in values: if isinstance(value, int): # numbers simply get added total += value elif isinstance(value, str): # strings with numbers in get added, others get ignored try: total += int(value) except: pass elif isinstance(value, Entity): # entities get their memories added try: total += value.memory except: pass else: # just try to add it, ignore if not possible try: total += value except: pass for i in range(0,len(values)): stack.pop theEntity.memory = total def c_say(self, stack): if not stack or (isinstance(stack[0],Entity) and len(stack)==1): die("task %s, entity %s: argument error for SAY: nothing to say." % \            (self.name,self.entity.name)) if isinstance(stack[0],Entity): sys.stdout.write(str(stack[1])) if not isinstance(stack[1], str): sys.stdout.write(" ") else: sys.stdout.write(str(stack[0])) if not isinstance(stack[0], str) or isinstance(stack[0], float): sys.stdout.write(" ") # do task def run(self): try:self._run except:die("task %s, entity %s: something weird happened; program terminated to insure safety." \                % (self.name, self.entity.name)) def _run(self): line_no = 0; while (line_no < len(self.lines)): cmds = splitline(self.lines[line_no]) stack = [] #print self.lines[line_no] for cmd in reversed(cmds): if cmd.lower in ['animate', 'banish', 'disturb', 'forget', 'invoke', 'moan', 'remember', 'say']: self.commands[cmd.lower](stack) elif cmd.lower == "remembering": if len(stack)>=1: if isinstance(stack[-1],Entity): if len(stack)>=2: val = int(stack[-1].memory == stack[-2]) stack.pop stack.pop stack.append(val) else: die("task %s, entity %s: argument error for REMEMBERING." % \                           (self.name, self.entity.name)) else: stack.append( int(stack.pop == self.entity.memory) ) else: die("task %s, entity %s: argument error for REMEMBERING." % \                     (self.name, self.entity.name)) elif cmd.lower == "stumble": return; elif cmd.lower == "rend": try: a=stack.pop stack.append(stack.pop / a)              except: die("task %s, entity %s: argument error for REND." % (self.name,self.entity.name)) elif cmd.lower == "turn": try: stack.append(-stack.pop) except: die("task %s, entity %s: argument error for TURN." % (self.name,self.entity.name)) elif cmd.lower == "around": t = 1 try: while t:                    line_no -= 1 if self.lines[line_no].split[0].lower in ['around', 'until']: t += 1 if self.lines[line_no].split[0].lower == 'shamble': t -= 1 #break except: die("task %s, entity %s: unbalanced loop." % (self.name, self.entity.name)) elif cmd.lower == "until": if (not stack) or (not stack[0]): t = 1 try: while t:                       line_no -= 1 if self.lines[line_no].split[0].lower == 'shamble': t -= 1 if self.lines[line_no].split[0].lower in ['around', 'until']: t += 1 #break except: die("task %s, entity %s: unbalanced loop." % (self.name, self.entity.name)) elif cmd.lower == "taste": if (not stack) or (not stack[0]): t = 1 try: while t:                       line_no += 1 if self.lines[line_no].split[0].lower == 'taste': t += 1 if self.lines[line_no].split[0].lower == 'spit': t -= 1 if self.lines[line_no].split[0].lower == 'bad' and t == 1: break except: die("task %s, entity %s: unbalanced taste/spit." %(self.name,self.entity.name)) elif cmd.lower == "bad": # this'll only happen if "taste" didn't send it to "bad"; so skip to "spit" t = 1 try: while t:                    line_no += 1 if self.lines[line_no].split[0].lower == 'taste': t += 1 if self.lines[line_no].split[0].lower == 'spit': t -= 1 except: die("task %s, entity %s: unbalanced taste/spit." % (self.name, self.entity.name)) elif cmd.lower in ['shamble', 'good', 'spit']: # syntax elements that do nothing themselves when reached pass; else: # it's a value if string_re.match(cmd): stack.append(cmd[1:-1].replace('\\n','\n').replace('\\t','\t')) elif integer_re.match(cmd): stack.append(float(cmd)) if stack[-1] == int(stack[-1]): stack[-1] = int(stack[-1]) elif str(cmd) in self.entity.environment.entities: stack.append(self.entity.environment.entities[cmd]) else: die("task %s, entity %s: '%s' does not exist." % (self.name,self.entity.name,cmd)) line_no += 1
 * 1) Task objects store tasks and can be run

class Environment: entities = {} def __init__(self, file): # read file try: f = open(file, "r") code = f.read f.close except: die("cannot open file %s." % file) # parse code self.parse(code) def run(self): global kill # activate all entities that should be activated [self.entities[e].runtasks for e in self.entities if self.entities[e].active] # keep the main thread running until all entities are done while (not kill) and [e for e in self.entities if self.entities[e].active]: time.sleep(1) if kill: sys.exit print "\n" # Make entities according to the code supplied def parse(self, code): currentEntity = None inEntity = False currentTask = None # remove comments from code code = comment_re.sub(lambda x:'', code) # split into lines and remove whitespace lines = [a.strip for a in code.split("\n") if not a.strip == ''] line_no = 0 while line_no < len(lines): #      print "LINE : '%s'" % lines[line_no] if not inEntity: a = declaration_re.match(lines[line_no]) if a:              if lines[line_no+1].lower == 'summon': # we're in an entity declaration block. # start a new entity, if possible if a.group(1) in self.entities: die("line %d: entity '%s' is already defined." % (line_no, a.group(1))) if a.group(2).lower in ['zombie', 'enslaved undead']: type=Zombie elif a.group(2).lower in ['ghost', 'restless undead']: type=Ghost elif a.group(2).lower in ['vampire', 'free-willed undead']: type=Vampire elif a.group(2).lower == 'demon': type=Demon elif a.group(2).lower == 'djinn': type=Djinn else: die("line %d: '%s' is not a valid entity type." % a.group(2)) currentEntityName = a.group(1) currentEntity = type currentEntity.name = currentEntityName line_no += 1 inEntity = True else: die("line %d: entity declaration incomplete, missing SUMMON." % line_no) else: die("line %d: only entity declarations may appear outside of entities." % line_no) else: a = task_re.match(lines[line_no]) b = remember_re.match(lines[line_no]) if a:              #read the task, store it in the entity currentTask = Task currentTask.name = a.group(1) while True: line_no += 1 if lines[line_no].lower in ['bind', 'animate']: currentTask.active = lines[line_no].lower == 'animate' currentTask.entity = currentEntity currentEntity.tasks += [currentTask] break else: currentTask.lines += [lines[line_no]] elif b:              #default value if b.group(1)[0] == '"' and b.group(1)[-1] == '"': # string currentEntity.memory = b.group(1)[1:-1] else: try: currentEntity.memory = int(b.group(1)) except ValueError: die("line %d: REMEMBER outside of task may only use a constant." % line_no) else: if not lines[line_no].lower in ['animate', 'bind', 'disturb']: die("line %d: not allowed outside of task." % line_no) else: inEntity = False if lines[line_no].lower != 'bind': # a state change (to active) is required if not isinstance(currentEntity, Undead): die(("line %d: safety check failed: free-willed non-undead *must* be bound " +\ "or all hell will break loose quite literally.") % line_no) if lines[line_no].lower == 'animate' and not isinstance(currentEntity,Zombie) \ or lines[line_no].lower == 'disturb' and not isinstance(currentEntity,Ghost) : die(("line %d: type error: you are either animating a ghost or disturbing " +\ "a zombie; both aren't a very good idea.") % line_no) # The fact that we're still here means that the program hasn't been killed. # That means the safety checks have passed, we can safely activate the entity. currentEntity.active = True currentEntity.environment = self self.entities[currentEntity.name] = currentEntity line_no += 1 if __name__ == '__main__': if (len(sys.argv)) != 2: die("argument error.") env = Environment(sys.argv[1]) env.run
 * 1) The environment in which the entities do their tasks.
 * 2) Not necessarily a graveyard, one can work around that
 * 3) by not using any undead.