rt

Documentation

Overview

Package rt defines the runtime interfaces used to interact with the game world. We use interfaces rather than concrete implementations to decouple package dependencies.

Index

• Constants
• type Assignment
• type BoolEval
• type Execute
• type Jump
  • func (i Jump) String() string
• type NumListEval
• type NumberEval
• type RecordEval
• type RecordListEval
• type Rule
• type Runtime
• type Scope
• type TextEval
• type TextListEval

Constants

const NoResult errutil.NoPanicError = "no result"

Types

type Assignment

type Assignment interface {
	GetAssignedValue(Runtime) (g.Value, error)
}

Assignment accesses values in a generic way.

type BoolEval

type BoolEval interface {
	GetBool(Runtime) (g.Value, error)
}

BoolEval represents the result of some true or false expression.

type Execute

type Execute interface {
	Execute(Runtime) error
}

Execute runs a bit of code that has no return value.

type Jump

type Jump int

const (
	// transitions immediately.
	JumpNow Jump = iota
	// transitions after processing the current rule set.
	JumpNext
	// transition only after processing the entire phase.
	JumpLater
)

func (Jump) String

func (i Jump) String() string

type NumListEval

type NumListEval interface {
	GetNumList(Runtime) (g.Value, error)
}

NumListEval represents the computation of a series of numeric values.

type NumberEval

type NumberEval interface {
	GetNumber(Runtime) (g.Value, error)
}

NumberEval represents the result of some numeric expression.

type RecordEval

type RecordEval interface {
	GetRecord(Runtime) (g.Value, error)
}

RecordEval yields access to a set of fields and their values.

type RecordListEval

type RecordListEval interface {
	GetRecordList(Runtime) (g.Value, error)
}

RecordListEval represents the computation of a series of a set of fields.

type Rule

type Rule struct {
	Name string
	// controls the style of transition:
	// when true, stops processing of any other rules; otherwise moves to the next phase.
	// a stop before the main rule is considered a canceled action;
	// and the result of the action in that case is false.
	Stop bool
	// controls when a transitions happens
	Jump Jump
	// whether the rule needs to be updated
	// before jumping to the next phase ( ex. for counters )
	Updates bool
	// a chain of if-else statements is considered an "optional" rule;
	// otherwise its considered a mandatory rule.
	// mandatory rules block other rules from running ( based on stop/stop )
	// optional rules only block other rules if some part of the if chain tested true.
	Exe []Execute
}

Rule triggers a named series of statements when its filters and phase are satisfied. stopping before the action happens is considered a cancel.

type Runtime

type Runtime interface {
	// ActivateDomain - objects are grouped into potentially hierarchical "domains".
	// de/activating makes those groups hidden/visible to the runtime.
	// Domain hierarchy is defined at assembly time.
	ActivateDomain(name string) error
	// GetKindByName  -record manipulation.
	GetKindByName(name string) (*g.Kind, error)
	// Call - run the pattern defined by the passed record.
	// passes the expected return because patterns can be called in ambiguous context ( ex. template expressions )
	Call(name string, expectedReturn affine.Affinity, keys []string, vals []g.Value) (g.Value, error)
	// RelativesOf - returns a list, even for one-to-one relationships.
	RelativesOf(a, relation string) (g.Value, error)
	// ReciprocalsOf - returns a list, even for one-to-one relationships.
	ReciprocalsOf(b, relation string) (g.Value, error)
	// RelateTo - establish a new relation between nouns and and b.
	RelateTo(a, b, relation string) error
	// PushScope - modifies the behavior of Get/SetField meta.Variable
	// by adding a set of variables to the current namespace.
	// ex. loops add iterators
	PushScope(Scope)
	// PopScope - remove the most recently added set of variables from the internal stack.
	PopScope()
	// GetField - various runtime objects (ex. nouns, kinds, etc.) store data addressed by name.
	// the objects and their fields depend on implementation and context.
	// see package meta for a variety of common objects.
	GetField(object, field string) (g.Value, error)
	// SetField - store, or at least attempt to store, a *copy* of the value into the field of the named object.
	// it can return an error:
	// if the value is not of a compatible type,
	// if the field is considered to read-only,
	// or if there is no object or field of the indicated names.
	SetField(object, field string, value g.Value) error
	// PluralOf - turn single words into their plural variants, and vice-versa.
	// each plural word maps to a unique singular.
	// for example, if the singular of "people" is "person", it cant also be "personage".
	PluralOf(single string) string
	// note: one plural word can map to multiple single words.
	// in that case the returned singular word is arbitrary ( if theoretically consistent )
	// for example, "person" can have the plural "people" or "persons" and this could return either.
	SingularOf(plural string) string
	// Random - return a pseudo-random number.
	Random(inclusiveMin, exclusiveMax int) int
	// Writer - Return the built-in writer, or the current override.
	Writer() io.Writer
	// SetWriter - Override the current writer.
	SetWriter(io.Writer) (prev io.Writer)
}

Runtime environment for an in-progress game.

type Scope

type Scope interface {
	// note: return g.Unknown if the named field/variable isnt found.
	FieldByName(field string) (g.Value, error)
	// note: does not usually copy ( since Runtime does )
	SetFieldByName(field string, val g.Value) error
	// errors if the field doesnt exist
	SetFieldDirty(field string) error
}

Scope - establishes a pool of local variables. Scopes are usually accessed via the runtime Set/GetField.

type TextEval

type TextEval interface {
	GetText(Runtime) (g.Value, error)
}

TextEval represents the result of some expression which creates a string.

type TextListEval

type TextListEval interface {
	GetTextList(Runtime) (g.Value, error)
}

TextListEval represents the computation of a series of strings.