TAME Documentation - TAME Execution Flow

Initialize:

FOR each ELEMENT in MODULE,
- If RESOLVE ELEMENT.init(),
  - CALL ELEMENT.init().
- Loop FOR.
If RESOLVE world.start(),
- CALL world.start().
Return.

Interpret:

ACTION = Read action.
If bad action,
- CALL [UNKNOWN Command].
- CALL [Failed Parse].
- Return.
Else If ACTION type is GENERAL,
- If ACTION is STRICT,
  - If more tokens,
    - CALL [MALFORMED Command].
    - CALL [Failed Parse].
    - Return.
- Enqueue COMMAND(ACTION).
Else If ACTION type is OPEN,
- If no more tokens,
  - CALL [INCOMPLETE Command].
  - CALL [Failed Parse].
  - Return.
- OPENSTRING = Accumulate tokens.
- Enqueue COMMAND(ACTION, OPENSTRING).
Else If ACTION type is MODAL,
- If no more tokens,
  - CALL [INCOMPLETE Command].
  - CALL [Failed Parse].
  - Return.
- MODE = Read mode.
- If bad mode,
  - CALL [MALFORMED Command].
  - CALL [Failed Parse].
  - Return.
- If ACTION is STRICT,
  - If more tokens,
    - CALL [MALFORMED Command].
    - CALL [Failed Parse].
    - Return.
- Enqueue COMMAND(ACTION, MODE).
Else If ACTION type is TRANSITIVE,
- If no more tokens,
  - CALL [INCOMPLETE Command].
  - CALL [Failed Parse].
  - Return.
- OBJECT1 = Read object.
- If best match refers to more than one object,
  - CALL [AMBIGUOUS Command].
  - CALL [Failed Parse].
  - Return.
- Else If unknown object,
  - CALL [MALFORMED Command].
  - CALL [Failed Parse].
  - Return.
- If ACTION is STRICT,
  - If more tokens,
    - CALL [MALFORMED Command].
    - CALL [Failed Parse].
    - Return.
- Enqueue COMMAND(ACTION, OBJECT1).
Else If ACTION type is DITRANSITIVE,
- If no more tokens,
  - CALL [INCOMPLETE Command].
  - CALL [Failed Parse].
  - Return.
- OBJECT1 = Read object.
- If best match refers to more than one object,
  - CALL [AMBIGUOUS Command].
  - CALL [Failed Parse].
  - Return.
- Else If unknown object,
  - CALL [MALFORMED Command].
  - CALL [Failed Parse].
  - Return.
- If no more tokens,
  - Enqueue COMMAND(ACTION, OBJECT1) (treat as transitive action).
- Else,
  - Read conjugate.
  - If bad conjugate,
    - CALL [MALFORMED Command].
    - CALL [Failed Parse].
    - Return.
  - If no more tokens,
    - CALL [INCOMPLETE Command].
    - CALL [Failed Parse].
    - Return.
  - OBJECT2 = Read object.
  - If best match refers to more than one object,
    - CALL [AMBIGUOUS Command].
    - CALL [Failed Parse].
    - Return.
  - Else If unknown object,
    - CALL [MALFORMED Command].
    - CALL [Failed Parse].
    - Return.
  - Enqueue COMMAND(ACTION, OBJECT1, OBJECT2).
CALL [Successful Parse].
Return.

COMMAND Loop:

WHILE Command Queue is not empty,
- COMMAND = Dequeue Command Queue.
- CALL [Process COMMAND].
- Loop WHILE.
Return.

Process COMMAND:

ACTION = COMMAND.ACTION.
If ACTION Type is GENERAL,
- CALL [General ACTION].
- Return.
Else If ACTION Type is OPEN,
- CALL [Open ACTION].
- Return.
Else If ACTION Type is MODAL,
- CALL [Modal ACTION].
- Return.
Else If ACTION Type is TRANSITIVE,
- CALL [Transitive ACTION].
- Return.
Else If ACTION Type is DITRANSITIVE,
- CALL [Ditransitive ACTION].
- Return.
Else,
- Throw INTERNAL ERROR.

General ACTION:

If current room is set,
- If RESOLVE room.onAction(ACTION),
  - CALL room.onAction(ACTION).
  - Return.
If current player is set,
- If RESOLVE player.onAction(ACTION),
  - CALL player.onAction(ACTION).
  - Return.
If RESOLVE world.onAction(ACTION),
- CALL world.onAction(ACTION).
- Return.
Return.

Open ACTION:

Set local ACTION.TARGET to COMMAND.STRING.
If current room is set,
- If RESOLVE room.onAction(ACTION),
  - CALL room.onAction(ACTION).
  - Return.
If current player is set,
- If RESOLVE player.onAction(ACTION),
  - CALL player.onAction(ACTION).
  - Return.
If RESOLVE world.onAction(ACTION),
- CALL world.onAction(ACTION).
- Return.
Return.

Modal ACTION:

MODE = COMMAND.STRING.
If current room is set,
- If RESOLVE room.onModalAction(ACTION, MODE),
  - CALL room.onModalAction(ACTION, MODE).
  - Return.
If current player is set,
- If RESOLVE player.onModalAction(ACTION, MODE),
  - CALL player.onModalAction(ACTION, MODE).
  - Return.
If RESOLVE world.onModalAction(ACTION, MODE),
- CALL world.onModalAction(ACTION, MODE).
- Return.
Return.

Transitive ACTION:

OBJECT1 = COMMAND.OBJECT1.
If RESOLVE OBJECT1.onAction(ACTION),
- CALL OBJECT1.onAction(ACTION).
- Return.
If current room is set,
- If RESOLVE room.onActionWith(ACTION, OBJECT1),
  - CALL room.onActionWith(ACTION, OBJECT1).
  - Return.
- ANCESTOR = OBJECT1.PARENT.
- WHILE ANCESTOR is NOT NULL:
  - If RESOLVE room.onActionWithAncestor(ACTION, ANCESTOR),
    - CALL room.onActionWithAncestor(ACTION, ANCESTOR).
    - Return.
  - ANCESTOR = ANCESTOR.PARENT.
  - Loop WHILE.
- If RESOLVE room.onActionWithOther(ACTION),
  - CALL room.onActionWithOther(ACTION).
  - Return.
If current player is set,
- If RESOLVE player.onActionWith(ACTION, OBJECT1),
  - CALL player.onActionWith(ACTION, OBJECT1).
  - Return.
- ANCESTOR = OBJECT1.PARENT.
- WHILE ANCESTOR is NOT NULL:
  - If RESOLVE player.onActionWithAncestor(ACTION, ANCESTOR),
    - CALL player.onActionWithAncestor(ACTION, ANCESTOR).
    - Return.
  - ANCESTOR = ANCESTOR.PARENT.
  - Loop WHILE.
- If RESOLVE player.onActionWithOther(ACTION),
  - CALL player.onActionWithOther(ACTION).
  - Return.
If RESOLVE world.onActionWith(ACTION, OBJECT1),
- CALL world.onActionWith(ACTION, OBJECT1).
- Return.
ANCESTOR = OBJECT1.PARENT.
WHILE ANCESTOR is NOT NULL:
- If RESOLVE world.onActionWithAncestor(ACTION, ANCESTOR),
  - CALL world.onActionWithAncestor(ACTION, ANCESTOR).
  - Return.
- ANCESTOR = ANCESTOR.PARENT.
- Loop WHILE.
If RESOLVE world.onActionWithOther(ACTION),
- CALL world.onActionWithOther(ACTION).
- Return.
Return.

Ditransitive ACTION:

OBJECT1 = COMMAND.OBJECT1.
OBJECT2 = COMMAND.OBJECT2.
If ACTION is STRICT,
- If ACTION is REVERSED,
  - If RESOLVE OBJECT2.onActionWith(ACTION, OBJECT1),
    - CALL OBJECT2.onActionWith(ACTION, OBJECT1).
    - Return.
  - ANCESTOR = OBJECT1.PARENT.
  - WHILE ANCESTOR is NOT NULL:
    - If RESOLVE OBJECT2.onActionWithAncestor(ACTION, ANCESTOR),
      - CALL OBJECT2.onActionWithAncestor(ACTION, ANCESTOR).
      - Return.
    - ANCESTOR = ANCESTOR.PARENT.
    - Loop WHILE.
  - If RESOLVE OBJECT2.onActionWithOther(ACTION),
    - CALL OBJECT2.onActionWithOther(ACTION).
    - Return.
  - CALL [UNHANDLED Action].
  - Return.
- Else,
  - If RESOLVE OBJECT1.onActionWith(ACTION, OBJECT2),
    - CALL OBJECT1.onActionWith(ACTION, OBJECT2).
    - Return.
  - ANCESTOR = OBJECT2.PARENT.
  - WHILE ANCESTOR is NOT NULL:
    - If RESOLVE OBJECT1.onActionWithAncestor(ACTION, ANCESTOR),
      - CALL OBJECT1.onActionWithAncestor(ACTION, ANCESTOR).
      - Return.
    - ANCESTOR = ANCESTOR.PARENT.
    - Loop WHILE.
  - If RESOLVE OBJECT1.onActionWithOther(ACTION),
    - CALL OBJECT1.onActionWithOther(ACTION).
    - Return.
  - CALL [UNHANDLED Action].
  - Return.
Else,
- If RESOLVE OBJECT1.onActionWith(ACTION, OBJECT2),
  - CALL OBJECT1.onActionWith(ACTION, OBJECT2).
  - Return.
- If RESOLVE OBJECT2.onActionWith(ACTION, OBJECT1),
  - CALL OBJECT2.onActionWith(ACTION, OBJECT1).
  - Return.
- ANCESTOR = OBJECT2.PARENT.
- WHILE ANCESTOR is NOT NULL:
  - If RESOLVE OBJECT1.onActionWithAncestor(ACTION, ANCESTOR),
    - CALL OBJECT1.onActionWithAncestor(ACTION, ANCESTOR).
    - Return.
  - ANCESTOR = ANCESTOR.PARENT.
  - Loop WHILE.
- ANCESTOR = OBJECT1.PARENT.
- WHILE ANCESTOR is NOT NULL:
  - If RESOLVE OBJECT2.onActionWithAncestor(ACTION, ANCESTOR),
    - CALL OBJECT2.onActionWithAncestor(ACTION, ANCESTOR).
    - Return.
  - ANCESTOR = ANCESTOR.PARENT.
  - Loop WHILE.
- If RESOLVE OBJECT1.onActionWithOther(ACTION),
  - CALL OBJECT1.onActionWithOther(ACTION).
  - Return.
- If RESOLVE OBJECT2.onActionWithOther(ACTION),
  - CALL OBJECT2.onActionWithOther(ACTION).
  - Return.
- CALL [UNHANDLED Action].
- Return.

Successful Parse:

CALL [COMMAND Loop].
If RESOLVE world.afterSuccessfulCommand(),
- CALL world.afterSuccessfulCommand().
CALL [COMMAND Loop].
If RESOLVE world.afterEveryCommand(),
- CALL world.afterEveryCommand().
CALL [COMMAND Loop].
Return.

Failed Parse:

CALL [COMMAND Loop].
If RESOLVE world.afterFailedCommand(),
- CALL world.afterFailedCommand().
CALL [COMMAND Loop].
If RESOLVE world.afterEveryCommand(),
- CALL world.afterEveryCommand().
CALL [COMMAND Loop].
Return.

UNKNOWN Command:

If current player is set,
- If RESOLVE player.onUnknownCommand(),
  - CALL player.onUnknownCommand().
  - Return.
If RESOLVE world.onUnknownCommand(),
- CALL world.onUnknownCommand().
- Return.
Add ERROR cue: UNKNOWN.
Return.

MALFORMED Command:

If current player is set,
- If RESOLVE player.onMalformedCommand(ACTION),
  - CALL player.onMalformedCommand(ACTION).
  - Return.
- If RESOLVE player.onMalformedCommand(),
  - CALL player.onMalformedCommand().
  - Return.
If RESOLVE world.onMalformedCommand(ACTION),
- CALL world.onMalformedCommand(ACTION).
- Return.
If RESOLVE world.onMalformedCommand(),
- CALL world.onMalformedCommand().
- Return.
Add ERROR cue: MALFORMED.
Return.

INCOMPLETE Command:

If current player is set,
- If RESOLVE player.onIncompleteCommand(ACTION),
  - CALL player.onIncompleteCommand(ACTION).
  - Return.
- If RESOLVE player.onIncompleteCommand(),
  - CALL player.onIncompleteCommand().
  - Return.
If RESOLVE world.onIncompleteCommand(ACTION),
- CALL world.onIncompleteCommand(ACTION).
- Return.
If RESOLVE world.onIncompleteCommand(),
- CALL world.onIncompleteCommand().
- Return.
Add ERROR cue: INCOMPLETE.
Return.

AMBIGUOUS Command:

If current player is set,
- If RESOLVE player.onAmbiguousCommand(ACTION),
  - CALL player.onAmbiguousCommand(ACTION).
  - Return.
- If RESOLVE player.onAmbiguousCommand(),
  - CALL player.onAmbiguousCommand().
  - Return.
If RESOLVE world.onAmbiguousCommand(ACTION),
- CALL world.onAmbiguousCommand(ACTION).
- Return.
If RESOLVE world.onAmbiguousCommand(),
- CALL world.onAmbiguousCommand().
- Return.
Add ERROR cue: AMBIGUOUS.
Return.

UNHANDLED Action:

If current player is set,
- If RESOLVE player.onUnhandledAction(ACTION),
  - CALL player.onUnhandledAction(ACTION).
  - Return.
- If RESOLVE player.onUnhandledAction(),
  - CALL player.onUnhandledAction().
  - Return.
If RESOLVE world.onUnhandledAction(ACTION),
- CALL world.onUnhandledAction(ACTION).
- Return.
If RESOLVE world.onUnhandledAction(),
- CALL world.onUnhandledAction().
- Return.
Add ERROR cue: UNHANDLED.
Return.