gourd

type ArgType ¶ added in v1.2.0

type ArgType int

const (
	TextArg    ArgType = iota // 0
	NumericArg                // 1
	EmojiArg                  // 2
)

type Argument ¶ added in v1.2.0

type Argument struct {
	Name         string
	Descriptor   string
	Type         ArgType
	IsOptional   bool
	UseRemainder bool
	IsQuoted     bool
	Default      string
}

type ArgumentError ¶ added in v1.2.0

type ArgumentError struct {
	Arguments []Argument
}

func (argError *ArgumentError) Error() string

type Command ¶

type Command struct {
	Name        string
	Description string
	Aliases     []string
	Inhibitor   interface{}
	Arguments   []Argument // Can be nil -> no arguments required
	Private     bool
	Run         func(ctx CommandContext)
}

type CommandContext ¶

type CommandContext struct {
	Prefix        string
	Args          []string
	CommandString string
	Message       *disgord.Message
	Client        *disgord.Client
	Gourd         *Gourd
	Command       *Command
}

func (ctx *CommandContext) Author() *disgord.User

func (ctx *CommandContext) AuthorMember() *disgord.Member

func (ctx *CommandContext) Guild() (*disgord.Guild, error)

func (ctx *CommandContext) IsAuthorOwner() bool

func (ctx *CommandContext) IsPrivate() bool

func (ctx *CommandContext) Reply(data ...interface{}) (*disgord.Message, error)

type ConsoleLogger ¶ added in v1.2.0

type ConsoleLogger struct{}

func (ConsoleLogger) Debug(m ...interface{})

func (ConsoleLogger) Err(m ...interface{})

func (ConsoleLogger) Info(m ...interface{})

type Gourd ¶

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

func New(token string, ownerId string, defaultPrefix string) *Gourd

func (bot *Gourd) AddKeyword(userId string, keyword string)

func (bot *Gourd) AddModule(mdl *Module) *Gourd

func (bot *Gourd) AddModules(modules ...*Module) *Gourd

func (bot *Gourd) Connect() error

func (bot *Gourd) HasKeyword(userId string, keyword string) bool

type Handler ¶

type Handler struct {
	Commands  []*Command
	Listeners []*ListenerHandler
	Modules   []*Module
}

func (handler *Handler) AddModule(mdl *Module) *Module

func (handler *Handler) GetCommandMap() map[string]*Command

func (handler *Handler) GetModuleMap() map[string]*Module

type KeywordInhibitor ¶

type KeywordInhibitor struct {
	Value    string
	Response interface{}
}

KeywordInhibitor. Allows command usage if the user has the given keyword. Value is the string keyword they should be assigned to. See <wiki link here> for keyword how-tos

type Listener ¶ added in v1.2.0

type Listener struct {
	Type        string
	Middlewares []MiddlewareHandler
	OnEvent     func(session disgord.Session, event struct{})
}

Listener is the Gourd implementation of event handlers. Type is a required field, and it is suggested to use disgord supplied events (ex: disgord.EvtMessageCreate). OnEvent is the handler function, and takes an interface that should be cast appropriately (ex: event.(*disgord.MessageCreate) ).

type ListenerHandler ¶ added in v1.2.0

type ListenerHandler interface {
	OnEvent(disgord.Session, interface{})
}

type Logger ¶ added in v1.2.0

type Logger interface {
	Debug(m ...interface{})
	Info(m ...interface{})
	Err(m ...interface{})
}

type Middleware ¶ added in v1.2.0

type Middleware struct{}

Middleware is the Gourd representation of Disgord Middlewares

type MiddlewareHandler ¶ added in v1.2.0

type MiddlewareHandler interface {
	// contains filtered or unexported methods
}

type Module ¶

type Module struct {
	Name        string
	Description string
	Commands    []*Command
	Listeners   []*ListenerHandler
}

func (module *Module) AddCommand(cmd *Command) *Module

func (module *Module) AddCommands(cmds ...*Command) *Module

func (module *Module) AddListener(l *ListenerHandler) *Module

func (module *Module) AddListeners(l ...*ListenerHandler) *Module

func (module *Module) NewCommand(aliases ...string) *Command

type NilInhibitor ¶

type NilInhibitor struct{}

NilInhibitor. Allows command usage no matter what. Does not have a value or a response

type OwnerInhibitor ¶

type OwnerInhibitor struct {
	Response interface{}
}

OwnerInhibitor. Allows command usage only if the user is the bot owner. Does not have a value; the owner ID is supplied in Gourd initialization.

type PermissionInhibitor ¶

type PermissionInhibitor struct {
	Value    uint64
	Response interface{}
}

PermissionInhibitor. Allows command usage if the user has the permission bit (value). Value is the disgord.PermissionBit. It is recommended to use disgord.PermissionBlahBlah. This inhibitor will not work in private messages as there are no permissions.

type RoleInhibitor ¶

type RoleInhibitor struct {
	Value    string
	Response interface{}
}

RoleInhibitor. Allows command usage if the user has the role (value). Value is the string ID of the role, **NOT the snowflake!**. This inhibitor will not work in private messages as there are no roles.