attr

package
v0.0.12 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 23, 2018 License: BSD-2-Clause Imports: 18 Imported by: 0

Documentation

Overview

Package attr (attributes) implements all of the functionality for objects in a WolfMUD world. All objects are instances of the Thing type. To these instances various attributes are added depending on the functionality required. The functionality of an object may be changed at runtime by adding or removing attributes.

A Thing can be searched for specific Attribute types using finders. All finders return a typed nil in the event of the specific Attribute type not being found. Returning a typed nil such as (*Alias)(nil) allows the finder to be chained to any other methods taking the a pointer to the Attribute type as a receiver. For example: 

if attr.FindAlias(t).HasAlias("test") {
	// do something...
}

If you need to check specifically if the finder returns nil, compare the returned value to the typed nil: 

if a := attr.FindAlias(t); a == (*Alias)(nil) {
	// do something...
}

Or if available use the Found method: 

if !attr.FindAlias(t).Found() {
	// do something...
}

All methods that take a pointer to an Attribute as a receiver are expected to be able to handle a nil receiver unless otherwise stated.

All typed nils should be of the same type as the default implementation for the type. For example the has.Alias interface has attr.Alias as the default implementation, therefore the typed nil should also be of type *Alias.

While it may seem unusual to return a typed nil it simplifies and reduces a lot of code in WolfMUD.

Index

Constants

View Source 
const (
	North byte = iota
	Northeast
	East
	Southeast
	South
	Southwest
	West
	Northwest
	Up
	Down
)

Constants for direction indexes. These can be used for the Link, AutoLink, Unlink and AutoUnlink methods. If these constants are modified probably need to update the Return function as well.

View Source 
const (
	It byte = iota
	Male
	Female
)

Constants for gender indexes.

Variables

View Source 
var ThingCount chan uint64

ThingCount is a channel storing the current number of Things. The value should only be incremented by NewThing and decremented by Free. ThingCount is a channel so that the value can be updated concurrently and shared with e.g. the stats package.

Functions

func DumpFmt 

func DumpFmt(format string, args ...interface{}) string

func FindAction added in v0.0.6 

func FindAction(t has.Thing) has.Action

FindAction searches the attributes of the specified Thing for attributes that implement has.Action returning the first match it finds or a *Action typed nil otherwise.

func FindAlias 

func FindAlias(t has.Thing) has.Alias

FindAlias searches the attributes of the specified Thing for attributes that implement has.Alias returning the first match it finds or a *Alias typed nil otherwise.

func FindAllDescription 

func FindAllDescription(t has.Thing) (matches []has.Description)

FindAllDescription searches the attributes of the specified Thing for attributes that implement has.Description returning all that match. If no matches are found an empty slice will be returned.

func FindAllVetoes added in v0.0.12 

func FindAllVetoes(t has.Thing) (matches []has.Vetoes)

FindAllVetoes searches the attributes of the specified Thing for attributes that implement has.Vetoes returning all that match. If no matches are found an empty slice will be returned.

func FindBarrier added in v0.0.12 

func FindBarrier(t has.Thing) has.Barrier

FindBarrier searches the attributes of the specified Thing for attributes that implement has.Barrier returning the first match it finds or a *Barrier typed nil otherwise.

func FindCleanup added in v0.0.5 

func FindCleanup(t has.Thing) has.Cleanup

FindCleanup searches the attributes of the specified Thing for attributes that implement has.Cleanup returning the first match it finds or a *Cleanup typed nil otherwise.

func FindDoor added in v0.0.4 

func FindDoor(t has.Thing) has.Door

FindDoor searches the attributes of the specified Thing for attributes that implement has.Door returning the first match it finds or a *Door typed nil otherwise.

func FindExits 

func FindExits(t has.Thing) has.Exits

FindExits searches the attributes of the specified Thing for attributes that implement has.Exits returning the first match it finds or a *Exits typed nil otherwise.

func FindGender added in v0.0.9 

func FindGender(t has.Thing) has.Gender

FindGender searches the attributes of the specified Thing for attributes that implement has.Gender returning the first match it finds or a *Gender typed nil otherwise.

func FindInventory 

func FindInventory(t has.Thing) has.Inventory

FindInventory searches the attributes of the specified Thing for attributes that implement has.Inventory returning the first match it finds or a *Inventory typed nil otherwise.

func FindLocate 

func FindLocate(t has.Thing) has.Locate

FindLocate searches the attributes of the specified Thing for attributes that implement has.Locate returning the first match it finds or a *Locate typed nil otherwise.

func FindName 

func FindName(t has.Thing) has.Name

FindName searches the attributes of the specified Thing for attributes that implement has.Name returning the first match it finds or a *Name typed nil otherwise.

func FindNarrative 

func FindNarrative(t has.Thing) has.Narrative

FindNarrative searches the attributes of the specified Thing for attributes that implement has.Narrative returning the first match it finds or a *Narrative typed nil otherwise.

func FindOnAction added in v0.0.6 

func FindOnAction(t has.Thing) has.OnAction

FindOnAction searches the attributes of the specified Thing for attributes that implement has.OnAction returning the first match it finds or a *OnAction typed nil otherwise.

func FindOnCleanup added in v0.0.6 

func FindOnCleanup(t has.Thing) has.OnCleanup

FindOnCleanup searches the attributes of the specified Thing for attributes that implement has.OnCleanup returning the first match it finds or a *OnCleanup typed nil otherwise.

func FindOnReset added in v0.0.6 

func FindOnReset(t has.Thing) has.OnReset

FindOnReset searches the attributes of the specified Thing for attributes that implement has.OnReset returning the first match it finds or a *OnReset typed nil otherwise.

func FindPlayer 

func FindPlayer(t has.Thing) has.Player

FindPlayer searches the attributes of the specified Thing for attributes that implement has.Player returning the first match it finds or a *Player typed nil otherwise.

func FindReset added in v0.0.5 

func FindReset(t has.Thing) has.Reset

FindReset searches the attributes of the specified Thing for attributes that implement has.Reset returning the first match it finds or a *Reset typed nil otherwise.

func FindStart 

func FindStart(t has.Thing) has.Start

FindStart searches the attributes of the specified Thing for attributes that implement has.Start returning the first match it finds or a *Start typed nil otherwise.

func FindWriting 

func FindWriting(t has.Thing) has.Writing

FindWriting searches the attributes of the specified Thing for attributes that implement has.Writing returning the first match it finds or a *Writing typed nil otherwise.

func Return 

func Return(direction byte) byte

Return calculates the opposite/return direction for the direction given. This is handy for calculating things like normal exits where if you go north you return by going back south. It is also useful for implementing ranged weapons, thrown weapons and spells. For example if you fire a bow west the person will see the arrow come from the east (from their perspective).

Types

type Action added in v0.0.6 

type Action struct {
	Attribute

	event.Cancel
	// contains filtered or unexported fields
}

Action implements an Attribute to display random action messages. Messages are specified via an OnAction Attribute. Action schedules a $action command to display a message everytime the event fires. The period when Action fires is between Action.after and Action.after+Action.jitter. An Action event can be cancelled by calling Action.Abort or by closing the Action.Cancel channel.

func NewAction added in v0.0.6 

func NewAction(after time.Duration, jitter time.Duration) *Action

NewAction returns a new Action attribute initialised with the passed after and jitter durations. The after and jitter Duration set the delay period to between after and after+jitter for when a Thing performs an action.

func (*Action) Abort added in v0.0.6 

func (a *Action) Abort()

Abort cancels any pending action events.

func (*Action) Action added in v0.0.6 

func (a *Action) Action()

Action schedules an action. If there is already an action event pending it will be cancelled and a new one queued.

func (*Action) Copy added in v0.0.6 

func (a *Action) Copy() has.Attribute

Copy returns a copy of the Action receiver. The copy will not inherit any pending action events.

func (*Action) Dump added in v0.0.6 

func (a *Action) Dump() (buff []string)

func (*Action) Found added in v0.0.6 

func (a *Action) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Action) Free added in v0.0.6 

func (a *Action) Free()

Free makes sure references are nil'ed and channels closed when the Action attribute is freed.

func (*Action) Marshal added in v0.0.9 

func (a *Action) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Action) Unmarshal added in v0.0.6 

func (*Action) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Action attribute.

type Alias 

type Alias struct {
	Attribute
	// contains filtered or unexported fields
}

Alias implements an attribute for referring to a Thing. An alias is a single word used to refer to things. Things may have more than one alias. For example a sword may have the aliases 'SWORD' and 'SHORTSWORD'. Given these aliases a player may use commands such as: 

GET SWORD
EXAMINE SHORTSWORD
DROP SHORTSWORD

Every Alias attribute that has a parent Thing set will have a unique ID equal to the result of calling Alias.Parent().UID(). Therefore a specific, unique Thing can be found by unique ID using, for example, Alias.HasAlias(Thing.UID()) or Inventory.Search(Thing.UID()).

NOTE: It is important to switch to the unique alias whenever possible, especially when scripting, so that the correct Thing is used for commands. This avoids picking the wrong Thing when a given alias identifies multiple Things. For example if we have a respawnable runestone and we get and drop the runestone it will be registered for cleanup. However if we just use the alias 'RUNESTONE' either the dropped or respawned runestone could be cleaned up. If the respawned runestone is cleaned up we could end up in a loop respawning and cleaning up the wrong runestone. Using the unique alias of the dropped runestone avoids this situation.

TODO: Need to implement alias prefixes. This would allow us to distinguish between two similar items with the same alias. For example if there are two coins, one copper and one silver, we could use either "GET COPPER COIN" or "GET SILVER COIN". If there is only one coin then "GET COIN" would be sufficient. See also BUG about aliases being single words.

func NewAlias 

func NewAlias(aliases ...string) *Alias

NewAlias returns a new Alias attribute initialised with the specified aliases. The specified aliases are automatically uppercased when stored. A unique alias using the parent Thing.UID will be added automatically.

func (*Alias) Aliases 

func (a *Alias) Aliases() (aliases []string)

Aliases returns a []string of all the aliases for an Alias attribute. If there are no aliases an empty slice will be returned.

func (*Alias) Copy added in v0.0.4 

func (a *Alias) Copy() has.Attribute

Copy returns a copy of the Alias receiver.

func (*Alias) Dump 

func (a *Alias) Dump() []string

func (*Alias) Found 

func (a *Alias) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Alias) HasAlias 

func (a *Alias) HasAlias(alias string) (found bool)

HasAlias checks the passed string for a matching alias. Returns true if a match is found otherwise false.

func (*Alias) Marshal added in v0.0.9 

func (a *Alias) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Alias) SetParent added in v0.0.5 

func (a *Alias) SetParent(t has.Thing)

SetParent overrides the default Attribute.SetParent in order to set a unique alias based on the parent Thing unique ID. The alias will be equal to the value returned by calling Alias.Parent().UID(). When the parent for the attribute changes the old unique identifier is removed (if there is one) and the new unique alias added before setting the new parent.

func (*Alias) Unmarshal 

func (*Alias) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Alias attribute.

type Attribute 

type Attribute struct {
	// contains filtered or unexported fields
}

Attribute implements a stub for other attributes. Any types providing attributes can embed this type instead of implementing their own Parent and SetParent methods. Updating and querying the parent is concurrent safe.

NOTE: Attribute does NOT provide a default Copy implementation. Each attribute must implement its own Copy method. This is due to the fact that other attributes will know best how to create copies based on their own implementation.

func (*Attribute) Free added in v0.0.5 

func (a *Attribute) Free()

Free makes sure references are nil'ed when the Attribute is freed. Other attributes should override Free to release their own references and resources. Attributes that implement their own Free method should also call Attribute.Free.

func (*Attribute) Parent 

func (a *Attribute) Parent() has.Thing

Parent returns the Thing that the Attribute has been added to.

func (*Attribute) SetParent 

func (a *Attribute) SetParent(t has.Thing)

SetParent is used to set the Thing that the Attribute has been added to. If it is not currently added to a Thing nil is returned. This method is automatically called by the Thing Add method.

type Barrier added in v0.0.12 

type Barrier struct {
	Attribute
	// contains filtered or unexported fields
}

Barrier implements an attribute for conditionally vetoing movement in a given direction. The barrier may be invisible or invisible and interactive or non-interactive depending on the Thing the attribute is attached to. A Barrier has two lists of aliases: those allowed to pass through the barrier and those not allowed to pass through the barrier. The allowed aliases are checked before those in the denied list. For example: 

b := NewBarrier(East, []string{"GUARD"}, []{"NPC"})

This would define a barrier preventing all mobiles with an alias of "NPC" from going east, unless they also has an alias of "GUARD". In this respect "NPC" is acting as a group alias, and can be applied to all mobiles that are considered non-player characters. If a mobile (or player) does not match an alias in the denied list they are allowed to pass through.

func NewBarrier added in v0.0.12 

func NewBarrier(direction byte, allow []string, deny []string) *Barrier

NewBarrier returns a new Barrier attribute. The direction is the conditionally blocked exit's direction. The allow and deny slices are lists of aliases that decide if movement in the given direction is vetoed or not.

func (*Barrier) Allowed added in v0.0.12 

func (b *Barrier) Allowed() (aliases []string)

Allowed returns a string slice of aliases that can unconditionally pass through the barrier.

func (*Barrier) Check added in v0.0.12 

func (b *Barrier) Check(actor has.Thing, cmd ...string) has.Veto

Check will veto passing through a Barrier dynamically based on the command (direction) given and the aliases of the actor wishing to pass through the Barrier. If an alias of the actor matches a denied alias we veto movement, unless overridden by a matching allowed alias. Otherwise we don't veto.

func (*Barrier) Copy added in v0.0.12 

func (b *Barrier) Copy() has.Attribute

Copy returns a copy of the Barrier receiver.

func (*Barrier) Denied added in v0.0.12 

func (b *Barrier) Denied() (aliases []string)

Denied returns a string slice of aliases that can cannot pass through the barrier, unless overridden unconditionally by allowed aliases.

func (*Barrier) Dump added in v0.0.12 

func (b *Barrier) Dump() (buff []string)

func (*Barrier) Found added in v0.0.12 

func (b *Barrier) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Barrier) Marshal added in v0.0.12 

func (b *Barrier) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Barrier) Unmarshal added in v0.0.12 

func (*Barrier) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Barrier attribute.

type Cleanup added in v0.0.5 

type Cleanup struct {
	Attribute

	event.Cancel
	// contains filtered or unexported fields
}

Cleanup implements an Attribute for disposing of Things left laying around in the game world. When an item is dropped it will be cleaned up after a delay period has elapsed. Otherwise the world would get cluttered with items.

The delay period is between Cleanup.after and Cleanup.after+Cleanup.jitter. If a Thing is being cleaned up and is in its delay period the Cleanup.Cancel channel will be non-nil and the clean up may be aborted by closing the channel or by calling Cleanup.Abort which will cancel clean up requests recursively for a Thing.

SPECIFICS

If an item is put into any Inventory and the item ends up not being carried by a player - either in their Inventory or in a container in their Inventory - and the receiving inventory has no parent Inventory that are already scheduled for clean up then the item is scheduled for a clean up. If the item has an Inventory (a container) the contents do not need to be scheduled for clean up recursively as everything will be cleaned up when the item itself is cleaned up. This is also why we don't schedule a clean up when putting an item in an Inventory where a parent Inventory is scheduled for a clean up already.

If an item is removed from any Inventory any pending clean ups are cancelled. If the item has an Inventory its content - checked recursively - will have any pending clean ups cancelled. If we don't cancel pending clean ups recursively then putting an item into a container and then picking the container up would result in the item still being scheduled for a clean up, resulting in the item disappearing from the container.

func NewCleanup added in v0.0.5 

func NewCleanup(after time.Duration, jitter time.Duration) *Cleanup

NewCleanup returns a new Cleanup attribute initialised with the passed after and jitter durations. The after and jitter Duration set the delay period to between after and after+jitter for when a Thing is cleaned up after being dropped.

func (*Cleanup) Abort added in v0.0.5 

func (c *Cleanup) Abort()

Abort causes an outstanding clean up event to be cancelled for the parent Thing. If the Thing has an Inventory Abort is called on the contents recursively. If we don't do this putting an item into a container and then picking the container up would result in the item still being scheduled for a clean up and disappearing from the container.

func (*Cleanup) Active added in v0.0.5 

func (c *Cleanup) Active() bool

Active returns true if any of the Inventories the parent Thing is in already have a clean up scheduled, otherwise false.

func (*Cleanup) Cleanup added in v0.0.5 

func (c *Cleanup) Cleanup()

Cleanup schedules a clean up of the parent Thing. If there is already a clean up event pending it will be cancelled and a new one queued.

func (*Cleanup) Copy added in v0.0.5 

func (c *Cleanup) Copy() has.Attribute

Copy returns a copy of the Cleanup receiver. The copy will not inherit any pending clean up events.

func (*Cleanup) Dump added in v0.0.5 

func (c *Cleanup) Dump() (buff []string)

func (*Cleanup) Found added in v0.0.5 

func (c *Cleanup) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Cleanup) Free added in v0.0.5 

func (c *Cleanup) Free()

Free makes sure references are nil'ed and channels closed when the Cleanup attribute is freed.

func (*Cleanup) Marshal added in v0.0.9 

func (c *Cleanup) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Cleanup) Unmarshal added in v0.0.5 

func (*Cleanup) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Cleanup attribute.

type Description 

type Description struct {
	Attribute
	// contains filtered or unexported fields
}

Description implements an attribute for describing Things. Things can have multiple descriptions or other attributes that implement the has.Description interface to add additional information to descriptions.

func NewDescription 

func NewDescription(description string) *Description

NewDescription returns a new Description attribute initialised with the specified description.

func (*Description) Copy added in v0.0.4 

func (d *Description) Copy() has.Attribute

Copy returns a copy of the Description receiver.

func (*Description) Description 

func (d *Description) Description() string

Description returns the descriptive string of the attribute.

func (*Description) Dump 

func (d *Description) Dump() []string

func (*Description) Found 

func (d *Description) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Description) Marshal added in v0.0.9 

func (d *Description) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Description) Unmarshal 

func (*Description) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Description attribute.

type Door added in v0.0.4 

type Door struct {
	Attribute
	// contains filtered or unexported fields
}

Door implements an attribute for blocking exits. Doors are the most common way of blocking an exit but this attribute may relate to gates, grills, bookcases and other such obstacles.

A complete working door consists of two Thing each with a Door attribute. One is the original door and the other is the 'other side'. The original Door is added to the location with the exit to be blocked, the 'other side' is added to the location the exit to be blocked leads to. Taking the tavern entrance in data/zones/zinara.wrj as an example: 

 _________________________________________
|L3                  |L5                  |
|    Tavern          #   Between Tavern   |
     Entrance        #   & Bakery
                     #
     (Door)          #   ('Other Side')
|                    #                    |   # = a door
|__                __|__                __|

Here we have locations L3 (Tavern Entrance) and L5 (Between Tavern * Bakery). Between them is the Tavern door. It is defined as: 

%%
      Ref: L3N1
Narrative:
     Name: the tavern door
  Aliases: DOOR
     Door: EXIT→E RESET→1m JITTER→1m

This is a sturdy wooden door with a simple latch.
%%

This adds a Thing representing the door to L3 and blocks the exit going east (EXIT→E) to L5. During zone loading and Unmarshaling OtherSide is called on the original door Thing. This creates another Thing used for the 'Other Side'. It is added to the location found by taking the exit the original door is blocking, in this case we are blocking the east exit which leads to L5. The 'Other Side' is added to L5 and is setup to block the returning exit, in this case west - back to L3. Now in L3 if we do 'EXAMINE DOOR' we are examining the original, in L5 we are examining the 'Other Side' which appears to be the same door. Because the original and 'Other Side' share state be can also issue 'OPEN DOOR' or 'CLOSE DOOR' in either L3 or L5.

When the door is not in it's initial state it will reset after a delay of between 1 and 2 minutes. That is, sometime between delay and delay+jitter.

If delay and jitter are both zero the door will not reset automatically.

NOTE: For now a Door attribute should only be added to a Thing with a Narrative attribute that is placed at a location. Adding a Door attribute to a location directly or to a moveable object will result in odd - possibly interesting - behaviour.

func NewDoor added in v0.0.4 

func NewDoor(direction byte, open bool, reset time.Duration, jitter time.Duration) *Door

NewDoor returns a new Door attribute. The direction is the direction the door blocks - specified as per attr.Exit constants. Open specifies whether the door is initially open (true) or closed (false). The reset is the duration to wait before resetting the door to its initial state - open or closed as specified by open. The jitter is a random amount of time to add to the reset delay. Adding jitter means the Door will reset with an actual delay of between delay and delay+jitter.

This actually only creates one side of a door. To create the 'other side' of the door Door.OtherSide should be called.

func (*Door) Check added in v0.0.4 

func (d *Door) Check(actor has.Thing, cmd ...string) has.Veto

Check will veto passing through a Door dynamically based on the command (direction) given and the current state of the Door - open or closed.

func (*Door) Close added in v0.0.4 

func (d *Door) Close()

Close changes a Door state from open to closed. If there is a pending event to close the door it will be cancelled. If the door should automatically open again an event to "OPEN <door>" will be queued. If the door is already closed calling Close does nothing.

func (*Door) Closed added in v0.0.4 

func (d *Door) Closed() bool

Closed returns true if the door is currently closed else false.

func (*Door) Copy added in v0.0.4 

func (d *Door) Copy() has.Attribute

Copy returns a copy of the Door receiver. Copy will only copy a specific Door not an original and 'other side' pair - they have to be copied separately if required.

func (*Door) Description added in v0.0.4 

func (d *Door) Description() string

func (*Door) Direction added in v0.0.4 

func (d *Door) Direction() byte

Direction returns the direction of the exit being blocked. The returned value matches the constants defined in attr.Exits.

func (*Door) Dump added in v0.0.4 

func (d *Door) Dump() (buff []string)

func (*Door) Found added in v0.0.4 

func (d *Door) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Door) Free added in v0.0.5 

func (d *Door) Free()

Free makes sure references are nil'ed and channels closed when the Door attribute is freed.

func (*Door) Marshal added in v0.0.9 

func (d *Door) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Door) Open added in v0.0.4 

func (d *Door) Open()

Open changes a Door state from closed to open. If there is a pending event to open the door it will be cancelled. If the door should automatically close again an event to "CLOSE <door>" will be queued. If the door is already open calling Open does nothing.

func (*Door) Opened added in v0.0.4 

func (d *Door) Opened() bool

Opened returns true if the door is currently open else false.

func (*Door) OtherSide added in v0.0.4 

func (d *Door) OtherSide()

OtherSide creates the 'other side' of a Door and places it in the World. The 'other side' will be placed in the Inventory found by following the exit that is being blocked by the original Door. Creating the 'other side' will fail if:

  • The original Door attribute has not been added to a Thing
  • The parent Thing of the original Door is not in an Inventory (e.g. location)
  • The parent Thing of the Inventory the parent Thing of the Door is in has no Exits
  • There is no exit in the direction the door is supposed to be blocking

For more details see the attr.Door type.

func (*Door) Unmarshal added in v0.0.4 

func (*Door) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Door attribute.

type Exits 

type Exits struct {
	Attribute
	// contains filtered or unexported fields
}

Exits implements an attribute describing exits for the eight compass points north, northeast, east, southeast, south, southwest, west and northwest as well as the directions up and down and where they lead to. Exits are usually in pairs, for example one north and one back south. You can have one way exits or return exits that do not lead back to where you came from.

func NewExits 

func NewExits() *Exits

NewExits returns a new Exits attribute with no exits set. Exits should be added to the attribute using the Link and AutoLink methods. The reason exits cannot be set during initialisation like most other attributes is that all 'locations' have to be setup before they can all be linked together. 

func (e *Exits) AutoLink(direction byte, to has.Inventory)

AutoLink links the given exit, calculates the opposite return exit and links that automatically as well - as long as the parent Thing of the to Inventory has an Exits attribute. 

func (e *Exits) AutoUnlink(direction byte)

AutoUnlink unlinks the given exit, calculates the opposite return exit and unlinks that automatically as well.

BUG(diddymus): Does not check that exit A links to B and B links back to A. For example a maze may have an exit going North from A to B but going South from B takes you to C instead of back to A as would be expected!

func (*Exits) Copy added in v0.0.4 

func (e *Exits) Copy() has.Attribute

Copy returns a copy of the Exits receiver.

func (*Exits) Dump 

func (e *Exits) Dump() []string

func (*Exits) Found 

func (e *Exits) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Exits) Free added in v0.0.5 

func (e *Exits) Free()

Free makes sure references are nil'ed when the Exits attribute is freed.

func (*Exits) LeadsTo 

func (e *Exits) LeadsTo(direction byte) has.Inventory

LeadsTo returns the Inventory of the location found by taking a specific exit. If a particular direction leads nowhere nil will be returned. 

func (e *Exits) Link(direction byte, to has.Inventory)

Link links the given exit direction to the given Inventory. If the given direction was already linked the exit will be overwritten - in effect the same as unlinking the exit first and then relinking it.

func (*Exits) List 

func (e *Exits) List() string

List will return a string listing the exits you can see. For example: 

You can see exits east, southeast and south.

func (*Exits) Marshal added in v0.0.9 

func (e *Exits) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Exits) NormalizeDirection 

func (*Exits) NormalizeDirection(name string) (direction byte, err error)

NormalizeDirection takes a long or short variant of a direction name in any case and returns the direction.

So 'N', 'NORTH', 'n', 'north', 'North' and 'NoRtH' all return the constant NORTH which is 0.

If the direction name given cannot be normalized, maybe because it is invalid, a non-nil error will be returned.

func (*Exits) Surrounding 

func (e *Exits) Surrounding() []has.Inventory

Surrounding returns an Inventory slice of all locations immediatly reachable from the current location. The cuurent location is specified by the receiver. If there are no immediatly reachable locations an empty slice will be returned.

func (*Exits) ToName 

func (*Exits) ToName(direction byte) (name string)

ToName returns the lowercased long name of a direction or an empty string if the direction is invalid. 

func (e *Exits) Unlink(direction byte)

Unlink sets the exit for the given direction to nil. It does not matter if the given direction was not linked in the first place.

func (*Exits) Unmarshal 

func (*Exits) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Exits attribute.

func (*Exits) Within 

func (e *Exits) Within(moves int, from has.Inventory) (locations [][]has.Inventory)

Within returns all of the locations within the given number of moves from the location specified by from Inventory. It is 3D and will follow up and down exits as well. The locations are returned as a slice of Inventory slices. The first slice index represents the number of moves. This indexes a slice that contains all locations within that number of moves. The first index, representing 0 moves, is always the current location.

Assume the following map of the Tavern and surrounding locations: 

 ____________________________________________________________
|1             |3             |5              |6             |
|  Fireplace       Entrance     Between           Bakery     |
|                               Tavern/Bakery                |
|__                         __|__           __|______________|
|2              4             |7              |8             |
|  Common Room     Bar        | Street outside    Pawn Shop  |
|                             | Pawn Shop                    |
|______________|______________|__           __|______________|
               |10            |9              |
               |   Outside      Fountain      |
               |   Armourer     Square        |
               |______________|_______________|

If we are at location 7 on the map then Within(2) will return all locations within 2 moves: 

 [][]has.Inventory{
	[]has.Inventory{ 7 },					// Within 0 moves of location 7
	[]has.Inventory{ 5, 8, 9 },   // Within 1 move of location 7
	[]has.Inventory{ 6, 3, 10 },  // Within 2 moves of location 7
 }

The above numbers e.g. 5,8,9 refer to the map locations. In reality they would actually be references to has.Inventory interface types.

If there are no Inventories reachable at a given number of moves the slice indexed with have zero length.

See cmd/sneeze.go for an example of using the Within method.

type Gender added in v0.0.9 

type Gender struct {
	Attribute
	// contains filtered or unexported fields
}

Gender implements an attribute for specifying the gender of a Thing. If a Thing does not have a specific gender attribute the gender will be the non-specific 'It'.

func NewGender added in v0.0.9 

func NewGender(gender string) *Gender

NewGender returns a gender attribute initialised to the specified gender. The gender can be specified using an upper, lower or title cased string. An upper or lower case 'M' or 'F' is also understood. If the gender specified is not valid the gender will default to a non-specific 'It'.

func (*Gender) Copy added in v0.0.9 

func (g *Gender) Copy() has.Attribute

Copy returns a copy of the Gender receiver.

func (*Gender) Dump added in v0.0.9 

func (g *Gender) Dump() []string

func (*Gender) Found added in v0.0.9 

func (g *Gender) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Gender) Gender added in v0.0.9 

func (g *Gender) Gender() string

Gender returns the gender stored in the attribute as a title-cased string. If the receiver is nil a non-specific "It" will be returned.

func (*Gender) Marshal added in v0.0.9 

func (g *Gender) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Gender) Unmarshal added in v0.0.9 

func (*Gender) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Gender attribute.

type Inventory 

type Inventory struct {
	Attribute

	internal.BRL
	// contains filtered or unexported fields
}

Inventory implements an attribute for container inventories. The most common container usage is for locations and rooms as well as actual containers like bags, boxes and inventories for mobiles. WolfMUD does not actually define a specific type for locations. Locations are simply Things that have an Exits attribute.

Any Thing added to an Inventory will automatically be assigned a Locate attribute. A locate attribute is simply a back reference to the Inventory a Thing is in. This enables a Thing to work out where it is.

NOTE: The contents slice is split into two parts. Things with a Narrative attribute are added to the beginning of the slice. All other Things are appended to the end of the slice. Which items are narrative and which are not is automatically tracked by split: 

narratives := contents[:split]
other := contents[split:]

countNarratives := split
countOther := len(contents) - split

For a complete description of narratives see the Narrative attribute type.

A Thing in an Inventory may be disabled and taken out of play or enabled and put back into play. A disabled Thing is inaccessible to players but is still covered by the Inventory lock. This is so that any Thing can always be covered by a lock in an Inventory. An example usage of disabling/enabling a Thing is when an item is cleaned up and needs to be reset. In this case the clean up event triggering would cause the Thing to be moved to its origin Inventory and then disabling the Thing would cause it to go out of play. When the reset event triggers the Thing would be enabled and brought back into play.

TODO: A slice for contents is fine for convenience and simplicity but maybe a linked list would be better? This would possibly save reslicing in Remove.

BUG(diddymus): Inventory capacity is not implemented yet.

func NewInventory 

func NewInventory(t ...has.Thing) *Inventory

NewInventory returns a new Inventory attribute initialised with the specified Things as initial contents. All of the Thing added will be enabled and in play - although the Thing itself may not be enabled and in play.

func (*Inventory) Add 

func (i *Inventory) Add(t has.Thing)

Add puts a Thing into an Inventory marking at as being initially out of play. The Locate attribute of the Thing will be updated to reference the Inventory the Thing is put into. If the Thing does not have a Locate attribute one will be added. The Thing may be enabled and put in play by calling Enable.

func (*Inventory) Carried added in v0.0.5 

func (i *Inventory) Carried() bool

Carried returns true if putting an item into the Inventory would result in it being carried by a player, otherwise false. The Inventory can be the player's actual Inventory or the Inventory of a container (checked recursively) in the player's inventory.

TODO: Need to check for players or mobiles

func (*Inventory) Contents 

func (i *Inventory) Contents() []has.Thing

Contents returns a 'copy' of the Inventory non-narrative contents. That is a copy of the slice containing has.Thing interface headers. Therefore the Inventory contents may be indirectly manipulated through the copy but changes to the actual slice are not possible - use the Add and Remove methods instead.

func (*Inventory) Copy added in v0.0.4 

func (i *Inventory) Copy() has.Attribute

Copy returns a copy of the Inventory receiver. The copy will be made recursively copying the complete content of the Inventory as well.

NOTE: There are no checks made for cyclic references which could send us into infinite recursion. However cyclic references should be prevented by the zone loader. See zones.isParent function.

func (*Inventory) Crowded 

func (i *Inventory) Crowded() (crowded bool)

Crowded tests to see if an Inventory has so many players in it that it is considered crowded. If the Inventory is considered crowded true is returned otherwise false. An Inventory is considered crowded if there are more than config.Inventory.CrowdSize players in it.

func (*Inventory) Disable added in v0.0.7 

func (i *Inventory) Disable(t has.Thing)

Disable marks a Thing in an Inventory as being out of play.

func (*Inventory) Disabled added in v0.0.7 

func (i *Inventory) Disabled() []has.Thing

func (*Inventory) Dump 

func (i *Inventory) Dump() (buff []string)

func (*Inventory) Empty 

func (i *Inventory) Empty() bool

Empty returns true if there are no non-Narrative items else false.

func (*Inventory) Enable added in v0.0.7 

func (i *Inventory) Enable(t has.Thing)

Enabled marks a Thing in an Inventory as being in play.

func (*Inventory) Everything added in v0.0.12 

func (i *Inventory) Everything() []has.Thing

Everything returns all of the narratives and contents of the Inventory. It is a single call equivelent to: append(i.Narratives(), i.Contents()...)

func (*Inventory) Found 

func (i *Inventory) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Inventory) Free added in v0.0.5 

func (i *Inventory) Free()

Free recursively calls Free on all of it's content when the Inventory attribute is freed.

func (*Inventory) List 

func (i *Inventory) List() string

List returns a string describing the non-narrative contents of an Inventory. The layout of the description returned is dependant on the number of items. If the Inventory is empty and the Parent Thing has a narrative attribute we return nothing. Otherwise if the Inventory is empty we return: 

It is empty.

A single item only we return: 

It contains xxx.

For multiple items we return: 

It contains:
	Item
	Item
	Item
	...

If the inventory cannot be listed an empty string will be returned.

func (*Inventory) Marshal added in v0.0.9 

func (i *Inventory) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Inventory) Move added in v0.0.5 

func (i *Inventory) Move(t has.Thing, where has.Inventory)

Move removes an enabled Thing from the receiver Inventory and puts it into the 'where' Inventory. After the move the Thing's Locate attribute will be updated to reflect the new Inventory it is in.

func (*Inventory) Narratives added in v0.0.4 

func (i *Inventory) Narratives() []has.Thing

Narratives returns a 'copy' of the Inventory narrative contents. That is a copy of the slice containing has.Thing interface headers. Therefore the Inventory narratives may be indirectly manipulated through the copy but changes to the actual slice are not possible - use the Add and Remove methods instead.

func (*Inventory) Outermost added in v0.0.7 

func (i *Inventory) Outermost() has.Inventory

Outermost returns the top level inventory in an Inventory hierarchy.

func (*Inventory) Players added in v0.0.6 

func (i *Inventory) Players() bool

Players returns true if there are any players in the Inventory else false.

func (*Inventory) Remove 

func (i *Inventory) Remove(t has.Thing)

Remove takes a disabled Thing out of an Inventory.

NOTE: Once the Thing is removed it will no longer be under a lock. Ideally once a Thing is removed Thing.Free should be called to release the Thing for garbage collection.

func (*Inventory) Search 

func (i *Inventory) Search(alias string) has.Thing

Search returns the first Inventory Thing that matches the alias passed. If no matches are found nil is returned.

func (*Inventory) Unmarshal 

func (*Inventory) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Inventory attribute.

type Locate 

type Locate struct {
	Attribute
	// contains filtered or unexported fields
}

Locate implements an attribute that refers to the Inventory of where something is. When a Thing is added to an Inventory a Locate attribute will be added automatically if the Thing does not already have one. When a Thing is added to or removed from an Inventory the Locate.SetWhere method is called to update the reference. See inventory.Add for more details. Locate also records the initial starting position or origin of a Thing. Concurrent access of a Locate attribute is safe.

func NewLocate 

func NewLocate(i has.Inventory) *Locate

NewLocate returns a new Locate attribute initialised to refer to the passed Inventory. Passing nil is a valid reference and is usually treated as being nowhere.

func (*Locate) Copy added in v0.0.4 

func (l *Locate) Copy() has.Attribute

Copy returns a copy of the Locate receiver.

func (*Locate) Dump 

func (l *Locate) Dump() (buf []string)

func (*Locate) Found 

func (l *Locate) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Locate) Free added in v0.0.5 

func (l *Locate) Free()

Free makes sure references are nil'ed when the Locate attribute is freed.

func (*Locate) Marshal added in v0.0.9 

func (*Locate) Marshal() (string, []byte)

Marshal returns a tag and []byte that represents the receiver. In this case we return empty values as the Locate attribute is not persisted.

func (*Locate) Origin added in v0.0.5 

func (l *Locate) Origin() (origin has.Inventory)

Origin return the initial starting Inventory that a Thing is placed into.

func (*Locate) SetOrigin added in v0.0.5 

func (l *Locate) SetOrigin(i has.Inventory)

SetOrigin is use to specify the initial starting Inventory that a Thing is placed into.

func (*Locate) SetWhere 

func (l *Locate) SetWhere(i has.Inventory)

SetWhere is used to set the Inventory containing the parent Thing. Passing nil is a valid reference and is usually treated as being nowhere. The current reference can be retrieved by calling Where.

NOTE: This is called automatically by the Inventory Add and Remove methods.

func (*Locate) Unmarshal 

func (*Locate) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Locate attribute. At the moment Locate attributes are created internally so return an untyped nil so we get ignored.

func (*Locate) Where 

func (l *Locate) Where() (where has.Inventory)

Where returns the Inventory the parent Thing is in. Returning nil is a valid reference and is usually treated as being nowhere. The current Inventory is set by calling SetWhere.

type Name 

type Name struct {
	Attribute
	// contains filtered or unexported fields
}

func NewName 

func NewName(n string) *Name

Name implements an attribute for naming Things. It is used when referring to or listing Things. For example if there is a sword it could have the name of 'a sword'. Then manipulating it you could see the following messages: 

You see a sword here.
You pick up a sword.
You examine a sword.
You start to wield a sword.

Messages such as the examples would typically be general messages with a placeholder for the name of the Thing. For example: 

You see %s here.
You pick up %s.
You examine %s.
You start to wield %s.

It is therefore important to take this into consideration when choosing names for Things.

func (*Name) Copy added in v0.0.4 

func (n *Name) Copy() has.Attribute

Copy returns a copy of the Name receiver.

func (*Name) Dump 

func (n *Name) Dump() []string

func (*Name) Found 

func (n *Name) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Name) Marshal added in v0.0.9 

func (n *Name) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Name) Name 

func (n *Name) Name(preset string) string

Name returns the name stored in the attribute. If the receiver is nil or the name is an empty string the specified preset will be returned instead. This allows for a generic preset name such as someone, something or somewhere to be returned for things without names.

func (*Name) TheName added in v0.0.12 

func (n *Name) TheName(preset string) string

TheName returns the name stored in the attribute, as per Name, but with the leading "A ", "An " or "Some " changed to "The ". The case of the 't' in 'the' is the same as the case of word replaced. For example: 

     A frog -> The frog
     a frog -> the frog
   An apple -> The apple
   an apple -> the apple
Some apples -> The apples
some apples -> the apples

func (*Name) Unmarshal 

func (*Name) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Name attribute.

type Narrative 

type Narrative struct {
	Attribute
}

Narrative implements an attribute to mark non-removable content. It allows creators to cater to the more discerning adventurer by providing content that is not spoon fed to them. Narrative content is usually mentioned or discoverable from text descriptions. For example: 

You are in the corner of a common room in the Dragon's Breath tavern. There
is a fire burning away merrily in an ornate fireplace giving comfort to
weary travellers. Shadows flicker around the room, changing light to
darkness and back again. To the south the common room extends and east the
common room leads to the tavern entrance.

From such a description it would be reasonable for someone to want to example the fireplace although there would be no "You see a fireplace here." when listing the items at the location. Should someone try to examine the fireplace they are rewarded with: 

This is a very ornate fireplace carved from marble. Either side a dragon
curls downward until the head is below the fire looking upward, giving the
impression that they are breathing fire.

While anything that can normally be put into an inventory can be put into a narrative, nothing should be directly removable. However everything in a narrative still works as expected - readable things are still readable and containers can have things put in them as well as removed. As an example consider this brief description: 

You are standing next to a small fish pond. Paths lead off north, south and
west deeper into the gardens.

Examining the pond - in this case a simple inventory - reveals its content: 

This is a small fish pond. It contains a fish of gold.

Taking the fish from the pond and examining it reveals: 

This is a small fish made from solid gold.

A much more satisfying reward for being curious :)

NOTE: At the moment narrative content should not be removeable for the simple reason that descriptions are mostly static - for now(?). So removing something would therefore invalidate the descriptive text.

func NewNarrative 

func NewNarrative() *Narrative

NewNarrative returns a new Narrative attribute.

func (*Narrative) Copy added in v0.0.4 

func (n *Narrative) Copy() has.Attribute

Copy returns a copy of the Narrative receiver.

func (*Narrative) Dump 

func (n *Narrative) Dump() (buff []string)

func (*Narrative) Found 

func (n *Narrative) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Narrative) ImplementsNarrative 

func (*Narrative) ImplementsNarrative()

ImplementsNarrative is a marker method so that we can specifically identify a Narrative.

func (*Narrative) Marshal added in v0.0.9 

func (n *Narrative) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Narrative) Unmarshal 

func (*Narrative) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Narrative attribute.

type OnAction added in v0.0.6 

type OnAction struct {
	Attribute
	// contains filtered or unexported fields
}

OnAction implements an attribute to provide action messages for a Thing.

func NewOnAction added in v0.0.6 

func NewOnAction(actions []string) *OnAction

NewOnAction returns a new OnAction attribute initialised with the specified messages.

func (*OnAction) ActionText added in v0.0.6 

func (oa *OnAction) ActionText() string

ActionText returns a random action message for a Thing. The message is chosen from the list of messages available.

func (*OnAction) Copy added in v0.0.6 

func (oa *OnAction) Copy() has.Attribute

Copy returns a copy of the OnAction receiver.

func (*OnAction) Dump added in v0.0.6 

func (oa *OnAction) Dump() (buf []string)

func (*OnAction) Found added in v0.0.6 

func (oa *OnAction) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*OnAction) Marshal added in v0.0.9 

func (oa *OnAction) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*OnAction) Unmarshal added in v0.0.6 

func (*OnAction) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new OnAction attribute.

type OnCleanup added in v0.0.6 

type OnCleanup struct {
	Attribute
	// contains filtered or unexported fields
}

OnCleanup implements an attribute to provide a clean up message for a Thing.

func NewOnCleanup added in v0.0.6 

func NewOnCleanup(text string) *OnCleanup

NewOnCleanup returns a new OnCleanup attribute initialised with the specified message.

func (*OnCleanup) CleanupText added in v0.0.6 

func (oc *OnCleanup) CleanupText() string

CleanupText returns the clean up message to be used for a Thing.

func (*OnCleanup) Copy added in v0.0.6 

func (oc *OnCleanup) Copy() has.Attribute

Copy returns a copy of the OnCleanup receiver.

func (*OnCleanup) Dump added in v0.0.6 

func (oc *OnCleanup) Dump() []string

func (*OnCleanup) Found added in v0.0.6 

func (oc *OnCleanup) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*OnCleanup) Marshal added in v0.0.9 

func (oc *OnCleanup) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*OnCleanup) Unmarshal added in v0.0.6 

func (*OnCleanup) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new OnCleanup attribute.

type OnReset added in v0.0.6 

type OnReset struct {
	Attribute
	// contains filtered or unexported fields
}

OnReset implements an attribute to provide a reset or respawn message for a Thing.

func NewOnReset added in v0.0.6 

func NewOnReset(text string) *OnReset

NewOnReset returns a new OnReset attribute initialised with the specified message.

func (*OnReset) Copy added in v0.0.6 

func (or *OnReset) Copy() has.Attribute

Copy returns a copy of the OnReset receiver.

func (*OnReset) Dump added in v0.0.6 

func (or *OnReset) Dump() []string

func (*OnReset) Found added in v0.0.6 

func (or *OnReset) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*OnReset) Marshal added in v0.0.9 

func (or *OnReset) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*OnReset) ResetText added in v0.0.6 

func (or *OnReset) ResetText() string

ResetText returns the reset or respawn message to be used for a Thing.

func (*OnReset) Unmarshal added in v0.0.6 

func (*OnReset) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new OnReset attribute.

type Player 

type Player struct {
	Attribute
	io.Writer
	has.PromptStyle
	// contains filtered or unexported fields
}

Player implements an attribute for associating a Thing with a Writer used to return data to the associated client.

func NewPlayer 

func NewPlayer(w io.Writer) *Player

NewPlayer returns a new Player attribute initialised with the specified Writer which is used to send data back to the associated client.

func (*Player) Account added in v0.0.9 

func (p *Player) Account() *account

Account returns the account information for a player. This can be used to Marshal, Unmarshal or set a player's account information.

func (*Player) Check added in v0.0.6 

func (p *Player) Check(actor has.Thing, cmd ...string) has.Veto

Check will always veto a player being junked.

func (*Player) Copy added in v0.0.4 

func (p *Player) Copy() has.Attribute

Copy returns a copy of the Player receiver.

NOTE: The copy will use the same io.Writer as the original.

func (*Player) Dump 

func (p *Player) Dump() []string

func (*Player) Found 

func (p *Player) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Player) Free added in v0.0.5 

func (p *Player) Free()

Free makes sure references are nil'ed when the Player attribute is freed.

func (*Player) Marshal added in v0.0.9 

func (*Player) Marshal() (string, []byte)

Marshal returns a tag and []byte that represents the receiver. In this case we return empty values as the Player attribute is not persisted.

func (*Player) SetPromptStyle 

func (p *Player) SetPromptStyle(new has.PromptStyle) (old has.PromptStyle)

SetPromptStyle is used to set the current prompt style and returns the previous prompt style. This is so the previous prompt style can be restored if required later on.

func (*Player) Unmarshal 

func (*Player) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Player attribute. At the moment Player attributes are created internally so return an untyped nil so we get ignored.

func (*Player) Write 

func (p *Player) Write(b []byte) (n int, err error)

Write writes the specified byte slice to the associated client.

type Reset added in v0.0.5 

type Reset struct {
	Attribute

	event.Cancel
	// contains filtered or unexported fields
}

Reset implements an Attribute for resetting or respawning Things in the game world. When a Thing is disposed of in the game world it may need to be reset and placed back into the game world at it's initial starting position after a delay period has elapsed. Otherwise the world quickly becomes empty with little for players to do. Some Thing's may respawn instead of resetting. When a Thing respawns another copy of the Thing is placed into the game world after a period of time when the Thing is taken. For both cases the delay period will be between Reset.after and Reset.after+Reset.jitter. If a Thing is being reset/respawned and is in its delay period the Reset.Cancel channel will be non-nil and the reset/respawn may be aborted by closing the channel. If Reset.spawn is true the Thing is respawnable otherwise it is resettable. Items that should just be removed when disposed of should not have a Reset attribute.

func NewReset added in v0.0.5 

func NewReset(after time.Duration, jitter time.Duration, spawn bool) *Reset

Reset implements an attribute for resetting or respawning Things and putting them back into the game world. The after and jitter Duration set the delay period to between after and after+jitter for when a Thing is reset or respawned. If spawn is true the Thing will respawn otherwise it will reset.

func (*Reset) Abort added in v0.0.8 

func (r *Reset) Abort()

Abort causes an outstanding reset event to be cancelled for the parent Thing.

func (*Reset) Copy added in v0.0.5 

func (r *Reset) Copy() has.Attribute

Copy returns a copy of the Reset receiver. The copy will not inherit any pending Reset events.

func (*Reset) Dump added in v0.0.5 

func (r *Reset) Dump() (buff []string)

func (*Reset) Found added in v0.0.5 

func (r *Reset) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Reset) Free added in v0.0.5 

func (r *Reset) Free()

Free makes sure references are nil'ed and channels closed when the Reset attribute is freed.

func (*Reset) Marshal added in v0.0.9 

func (r *Reset) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Reset) Reset added in v0.0.5 

func (r *Reset) Reset()

Reset schedules a reset of the parent Thing. If there is already a reset event pending it will be cancelled and a new one queued.

func (*Reset) Spawn added in v0.0.5 

func (r *Reset) Spawn() has.Thing

Spawn returns a non-spawnable copy of a Thing and schedules the original Thing to reset if Reset.spawn is true. Otherwise it returns nil.

func (*Reset) Unmarshal added in v0.0.5 

func (*Reset) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Reset attribute.

type Start 

type Start struct {
	Attribute
}

Start implements an attribute for tagging a Thing as a starting location.

func NewStart 

func NewStart() *Start

NewStart returns a new Start attribute. When a new Start attribute is created it is also registered automatically.

TODO: Implement starting locations that are only usable by specific players. For example only dwarves should start in the dwarven home, or thieves in the thieves guild.

func (*Start) Copy added in v0.0.4 

func (s *Start) Copy() has.Attribute

Copy returns a copy of the Start receiver.

func (*Start) Dump 

func (s *Start) Dump() []string

func (*Start) Found 

func (s *Start) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Start) Marshal added in v0.0.9 

func (*Start) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Start) Pick 

func (*Start) Pick() has.Inventory

Pick returns the Inventory of a randomly selected starting location.

func (*Start) Unmarshal 

func (*Start) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Start attribute.

type Thing 

type Thing struct {
	// contains filtered or unexported fields
}

Thing is a container for Attributes. Everything in WolfMUD is constructed by creating a Thing and then adding Attributes to it which implement specific functionality. Concurrent access to a Thing is safe.

func NewThing 

func NewThing(a ...has.Attribute) *Thing

NewThing returns a new Thing initialised with the specified Attributes. Attributes can also be dynamically modified using Add and Remove methods. If Debug.Things is true a message will be written to the log indicating a new Thing has been created. A finalizer will also be registered to write a message when the thing is garbage collected.

func (*Thing) Add 

func (t *Thing) Add(a ...has.Attribute)

Add is used to add the passed Attributes to a Thing. When an Attribute is added its parent is set to reference the Thing it was added to. This allows an Attribute to find and query the parent Thing about other Attributes the Thing may have.

func (*Thing) Attrs 

func (t *Thing) Attrs() []has.Attribute

Attrs returns all of the Attributes a Thing has as a slice of has.Attribute. This is commonly used to range over all of the Attributes of a Thing instead of using a finder for a specific type of Attribute.

func (*Thing) ClearOrigins added in v0.0.12 

func (t *Thing) ClearOrigins()

ClearOrigins sets the origin for the Thing to nil and recursivly sets the origins to nil for the content of a Thing's Inventory if it has one.

func (*Thing) Collectable added in v0.0.9 

func (t *Thing) Collectable() bool

Collectable returns true if a Thing can be kept by a player, otherwise returns false. This is a helper routine so that the definition of what is considered collectable can be easily changed.

func (*Thing) Copy added in v0.0.4 

func (t *Thing) Copy() has.Thing

Copy returns a copy of the Thing receiver. The copy will be made recursively copying all associated Attribute and Thing.

func (*Thing) Dump 

func (t *Thing) Dump() (buff []string)

func (*Thing) Free added in v0.0.5 

func (t *Thing) Free()

Free is used to clean-up/release references to all Attribute for a Thing. When a Thing is finished with calling Free helps the garbage collector to reclaim objects. It can also help to break cyclic references that could prevent garbage collection.

func (*Thing) Marshal added in v0.0.9 

func (t *Thing) Marshal() recordjar.Record

Marshal marshals a Thing to a recordjar record containing all of the Attribute details.

func (*Thing) NotUnique added in v0.0.9 

func (t *Thing) NotUnique()

NotUnique marks a Thing as no longer being unique and clears the Thing's UID. It also decrements ThingCount by one to account for the fact that calling Free will no longer decrement ThingCount for multiple references of this Thing. Calling NotUnique on a Thing more than once is safe.

You almost never, ever, want to call this function! The only time this should be used is when creating temporary stores - such as when loading zones or players.

func (*Thing) Remove 

func (t *Thing) Remove(a ...has.Attribute)

Remove is used to remove the passed Attributes from a Thing. There is no indication if an Attribute cannot actually be removed. When an Attribute is removed its parent is set to nil. When an Attribute is removed and is no longer required the Attribute's Free method should be called.

func (*Thing) SetOrigins added in v0.0.5 

func (t *Thing) SetOrigins()

SetOrigins updates the origin for the Thing to its containing Inventory and recursivly sets the origins for the content of a Thing's Inventory if it has one.

func (*Thing) String added in v0.0.6 

func (t *Thing) String() string

String causes a Thing to implement the Stringer interface so that a Thing can print information about itself. The format of the string is: 

<address> <type> UID: <unique ID>

0xc420108630 *attr.Thing UID: #UID-6M

func (*Thing) UID added in v0.0.5 

func (t *Thing) UID() string

UID returns the unique identifier for a specific Thing or an empty string if the unique ID is unavailable. The unique ID should be automatically assigned to any Thing created by calling NewThing or Copy.

func (*Thing) Unmarshal 

func (t *Thing) Unmarshal(recno int, record recordjar.Record)

Unmarshal unmarshals a Thing from a recordjar record containing all of the Attribute to be added. The recno is the record number in the recordjar for this record. It is passed so that we can give informative messages if errors are found. If the record number is not known -1 should be passed instead.

type Veto 

type Veto struct {
	// contains filtered or unexported fields
}

Veto implements a veto for a specific command. Veto need to be added to a Vetoes list using NewVetoes.

func NewVeto 

func NewVeto(cmd string, msg string) *Veto

NewVeto returns a new Veto attribute initialised for the specified command with the specified message text. The command is a normal command such as GET and DROP and will automatically be uppercased. The message text should indicate why the command was vetoed such as "You can't drop the sword. It seems to be cursed". Referring to specific items - such as the sword in the example - is valid as a Veto is for a specific known Thing.

func (*Veto) Command 

func (v *Veto) Command() string

Command returns the command associated with the Veto.

func (*Veto) Dump 

func (v *Veto) Dump() (buff []string)

func (*Veto) Message 

func (v *Veto) Message() string

Message returns the message associated with the Veto.

type Vetoes 

type Vetoes struct {
	Attribute
	// contains filtered or unexported fields
}

Vetoes implement an attribute for lists of Veto preventing commands for a Thing that would otherwise be valid. For example you could Veto the drop command if a very sticky item is picked up :)

func NewVetoes 

func NewVetoes(veto ...has.Veto) *Vetoes

NewVetoes returns a new Vetoes attribute initialised with the specified Vetos.

func (*Vetoes) Check 

func (v *Vetoes) Check(actor has.Thing, cmd ...string) has.Veto

Check checks if any of the passed commands, issued by the passed actor, are vetoed. The first matching Veto found is returned otherwise nil is returned.

func (*Vetoes) Copy added in v0.0.4 

func (v *Vetoes) Copy() has.Attribute

Copy returns a copy of the Vetoes receiver.

func (*Vetoes) Dump 

func (v *Vetoes) Dump() (buff []string)

func (*Vetoes) Found 

func (v *Vetoes) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Vetoes) Free added in v0.0.5 

func (v *Vetoes) Free()

Free makes sure references are nil'ed when the Vetoes attribute is freed.

func (*Vetoes) Marshal added in v0.0.9 

func (v *Vetoes) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Vetoes) Unmarshal 

func (*Vetoes) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Vetoes attribute.

type Writing 

type Writing struct {
	Attribute
	// contains filtered or unexported fields
}

Writing implements an attribute that allows for writing to be put onto any Thing so that it can be read.

TODO: Writing currently assumes the text is written onto a Thing. However it could also be carved, burnt, painted, etc. onto a Thing. It also assumes the text is in a common language known to all. If language were implemented we could write in common, elvish, dwarfish, ancient runes, secret code or anything else with the text only being readable by those who know the relevant language. See also the Writing Description method.

func NewWriting 

func NewWriting(w string) *Writing

NewWriting returns a new Writing attribute initialised with the specified writing/text.

func (*Writing) Copy added in v0.0.4 

func (w *Writing) Copy() has.Attribute

Copy returns a copy of the Writing receiver.

func (*Writing) Description 

func (w *Writing) Description() string

Description automatically adds the specified text to the description of a Thing that has a has.Writing attribute.

FIXME: This should return a message based on the type of writing: runes, painting, carving etc. See also TODO for the Writing type.

func (*Writing) Dump 

func (w *Writing) Dump() []string

func (*Writing) Found 

func (w *Writing) Found() bool

Found returns false if the receiver is nil otherwise true.

func (*Writing) Marshal added in v0.0.9 

func (w *Writing) Marshal() (tag string, data []byte)

Marshal returns a tag and []byte that represents the receiver.

func (*Writing) Unmarshal 

func (*Writing) Unmarshal(data []byte) has.Attribute

Unmarshal is used to turn the passed data into a new Writing attribute.

func (*Writing) Writing 

func (w *Writing) Writing() (writing string)

Writing returns the text that has been written.

Notes

Bugs

  • Aliases are expected be single words only, otherwise they probably won't work correctly and cause all sorts of weird problems and behaviour. See also TODO about prefixes.

  • Does not check that exit A links to B and B links back to A. For example a maze may have an exit going North from A to B but going South from B takes you to C instead of back to A as would be expected!

  • Inventory capacity is not implemented yet.

Source Files

  • action.go
  • alias.go
  • attribute.go
  • barrier.go
  • cleanup.go
  • description.go
  • doc.go
  • door.go
  • exits.go
  • gender.go
  • inventory.go
  • locate.go
  • name.go
  • narrative.go
  • onaction.go
  • oncleanup.go
  • onreset.go
  • player.go
  • reset.go
  • start.go
  • thing.go
  • vetoes.go
  • writing.go

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.