Cyc+Jamud This Site is Still under Heavy Construction
Jamud Plugin: Integrates a Java MUD with an OpenCyc Server 

| JaMUD.Com | Projects | Support Feature Requests | Bugs | CVS  | OpenCyc | CycL Programming |Douglas Miles 


Jamud Tools

Proxy MudObject that stores and queries in OpenCyc

     Complete readability of all Jamud primitive types into logical  paradigms (To better export to KIF/CycL)


With Christopher, the OLC interfaces to JaMUD

    Our mission is to increase number of ways to produce stylistic creations from the telnet

Persisted Data Model

JaMUD is saved an loaded from an XML pages.  This means at any time we can serialize the  'MOOState' context (Microtheory).

This is meant to be a solid context comprising of instances and sets.  The other ontologies about understanding and using these can stored as well as hypothetical rooms and objects.  They in could be called 'Exemplars' for example the Unicorn Pegasus is a mythological creature and could live cut off in in the 'Giant Room Of Mythological Creatures' and looks and save like an instance of Unicorn.  But Pegasus' room may not be part of the relevant KB and therefore not effecting to the rest of the system.  But how would we persist information that does not fit into a 4D space?    For example these two rules: 




        (isa ?PERSON Human) 

        (acquaintedWith ?OTHER ?PERSON))

    (acquaintances ?PERSON ?OTHER SimpleContactAcquaintance)) 



    (spouse ?X ?Y) 

    (friends ?X ?Y))


Each rule is kept in an instance of an Assertion.  Physical Regions of the MOO may be effected by any 'Set' of instances from the Assertion Class.  Assertions can be divided into Microtheories that can be believed by agents (or Mobs).  The MOO reserves no special entity for enforcement of rules unless an agent has been assigned specifically to a room to do so.  Most cases agents in the room are picking from there own private array of Assertions which is separate from  an entity using the room's set.   



              .-.__,___,_.-=-. )\`  a`\_
          .-.__\__,__,__.-=-. `/  \     `\
          {~,-~-,-~.-~,-,;;;;\ |   '--;`)/
           \-,~_-~_-,~-,(_(_(;\/   ,;/
            ",-.~_,-~,-~,)_)_)'.  ;;(               W E L C O M E
              `~-,_-~,-~(_(_(_(_\  `;\                   t o
        ,          `"~~--,)_)_)_)\_   \               J a M U D
        |\              (_(_/_(_,   \  ;
        \ '-.       _.--'  /_/_/_)   | |
         '--.\    .'          /_/    | |
             ))  /       \      |   /.'
            //  /,        | __.'|  ||
           //   ||        /`    (  ||           the java-based mud in
          ||    ||      .'       \ \\           T E C H N I C O L O R
          ||    ||    .'_         \ \\
           \\   //   / _ `\        \ \\__
     jgs    '-'/(   _  `\,;        \ '--:,
             `"`  `"` `-,,;         `"`",,;
Player Name:

Stage 1

  Deliverable: A small lightweight installation and demo world.
  Goal: To test and do practical Knowledge Engineering about a
  virtual realm:

    1) Build an existing simple realm inside of Jamud.

    2) Create rules that interface to the realm Jamud mapping
    existing object types into cyc Collections

      a) Enumerate the possibilities and confirm the ontology of how
      things work or exist.
      b) Map/Align to Cyc's ontology

      c) Create a BroadMicrothery to reflect this

      d) Create an import routine to build the world into a

    3) Inference in Cyc about the DataMicrotheory and see how many
    commonsense rules we can make about our possible world.

    4) Complete the interface for querying/asserting to OpenCyc from
    Jamud telnet interface.

    5) Create synchronization: (choices)

      a) Each time a subscribed event occurs in Jamud, use the
      existing OpenCyc Java API to update Cyc (current)

      b) Make each object instance get/set methods query/assert into
      OpenCyc into a DataMicrotheory (could easily be done)

      c) Create HL interface predicates to query the existing Jamud
      objects into a DataMicrotheory (supported yet?)

Stage 2
  Deliverable: Above with web interfaces to speed up the process below.
  Goal: To animate non-player character agents from Cyc rules

    1) Create an ontology of non-player character roles and jobs.

    2) Leverage commonsense rules from stage 1 into rules about how
    to conduct actions

      a) Create cyc queries (and the rules to satisfy) that
      consequent in a form of (actorStateAction ?Actor ?State

      b) Map the agent categories into partitions of background
      commonsense required

      c) Create a Microtheory system for single agents based on
      'knows about' and 'know how to' that can instance individual's
      current knowledge states.

    3) Interface!

      a) Create methods in Jamud that builds and initializes a new
      Cyc microtheories per agent.

      b) genlMt the agent character ?Mt based on job types for their

      c) Agent character enumerates his intrinsic goals by making a
      query to OpenCyc

      d) Agent character per-tick initiates query about its goal and
      gets bindings back for his next action

      e) Perform action inside Jamud and update states

    4) Practice and refine knowledge engineering for stage 1 and 2

  Stage 3

  Deliverable: Expertly build rooms with objects based on rules.  With rules below, we should
     be able to telnet into Jamud, enter a "damp room" and find and take parts of mold.

      (isa Mold FirstOrderCollection)
      (isa Mold ExistingObjectType)
      (isa Mold StuffType)
      (forAll ?Rooms
                (isa ?Room Room)
                (hasProperty ?Room Damp))
              (thereExists ?Mold
                    (isa ?Mold Mold)
                    (objectFoundInLocation ?Mold ?Room)))))
      (forAll ?Action
             (isa ?Action TakingPartOfObject)
             (occursAt ?Action ?Room)
             (objectFoundInLocation ?Object ?Room)
             (rolePart ?Action Actor ?Actor )
             (rolePart ?Action Object ?Object)
             (rolePart ?Action Region ?Room)
             (isa ?Object StuffType))
        (thereExists ?PartStuff
               (part ?Object ?PartStuff)
               (objectControlledBy ?PartStuff ?Actor))))

    1) Use the information from above stages to 'reflect back' into

      a) Find which state-action-state rules from stage 2 are
      administrative tasks

      b) Write a Microtheory that contains rules that both antecede
      and consequent in the DataMicrotheory like the first of the
      rules shown above.

      c) create a robust colorful environment that may go beyond
      persisted Jamud

    Practice running queries until the results make good sense

    2)  Interface
      a) Jamud queries the DataMicrotheory (leveraging the above
      rules) and gets a map of the expected state.

      b) Confirm that each object exists and has the expected
      properties in Jamud.

      c) Make sure that the world transitions make sense to players
      in the MUD.

  Stage 4

    Goal: Apply virtual environments beyond this MUD/MOO/RPG

    1) Confirm the constancy, soundness and operational completeness
    of the above.

    2) Create agents/objects in Jamud that will propagate/query
    state to another application realm

    3) Do knowledge engineering like the above for the new

    4) Evaluate and improve tools used.

The project is realized into finite number of non-vague tasks and
diverse enough.


Supported configurations

LINUX (currently developed on Redhat 7.x)

JDK 1.4

Jakarta Tomcat 4.x

OpenCyc 0.6.0


SourceForge Logo