actions

Documentation

Overview

Package actions contains all the tools for making your custom client actions.

Index

• Constants
• func HandleCustomClientAction(action string, data interface{}, user *core.User, conn *websocket.Conn, ...)
• func New(actionType string, dataType int, callback func(interface{}, *Client)) error
• func Pause()
• func Resume()
• func SetServerStarted(val bool)
• type Client
  • func (c *Client) Action() string
  • func (c *Client) ConnectionID() string
  • func (c *Client) Respond(response interface{}, err ClientError)
  • func (c *Client) User() *core.User
• type ClientError
  • func NewError(message string, id int) ClientError
  • func NoError() ClientError
• type CustomClientAction

Constants

const (
	ErrorMismatchedTypes    = iota + 1001 // Client didn't pass the right data type for the given action
	ErrorUnrecognizedAction               // The custom action has not been defined
)

Default `ClientError`s

const (
	DataTypeBool   = iota // Boolean data type
	DataTypeInt           // int, int32, and int64 data types
	DataTypeFloat         // float32 and float64 data types
	DataTypeString        // string data type
	DataTypeArray         // []interface{} data type
	DataTypeMap           // map[string]interface{} data type
	DataTypeNil           // nil data type
)

These are the accepted data types that a client can send with a CustomClientMessage. You must use one of these when making a new CustomClientAction, or it will not work. If a client tries to send a type of data that doesnt match the type specified for that action, the CustomClientAction will send an error back to the client and skip executing your callback function.

Functions

func HandleCustomClientAction

func HandleCustomClientAction(action string, data interface{}, user *core.User, conn *websocket.Conn, connID string)

HandleCustomClientAction handles your custom client actions.

WARNING: This is only meant for internal Gopher Game Server mechanics. Your CustomClientAction callbacks are called from this function. This could spawn errors and/or memory leaks.

func New

func New(actionType string, dataType int, callback func(interface{}, *Client)) error

New creates a new `CustomClientAction` with the corresponding parameters:

- actionType (string): The type of action

- (*)callback (func(interface{},Client)): The function that will be executed when a client calls this `actionType`

- dataType (int): The type of data this action accepts. Options are `DataTypeBool`, `DataTypeInt`, `DataTypeFloat`, `DataTypeString`, `DataTypeArray`, `DataTypeMap`, and `DataTypeNil`

(*)Callback function format:

func yourFunction(actionData interface{}, client *Client) {
    //...

    // optional client response
    client.Respond("example", nil);
}

- actionData: The data the client sent along with the action

- client: A `Client` object representing the client that sent the action

Note: This function can only be called BEFORE starting the server.

func Pause

func Pause()

Pause is only for internal Gopher Game Server mechanics.

func Resume

func Resume()

Resume is only for internal Gopher Game Server mechanics.

func SetServerStarted

func SetServerStarted(val bool)

SetServerStarted is for Gopher Game Server internal mechanics only.

Types

type Client

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

Client objects are created and sent along with your CustomClientAction callback function when a client sends an action.

func (*Client) Action

func (c *Client) Action() string

Action gets the type of action the Client sent.

func (*Client) ConnectionID

func (c *Client) ConnectionID() string

ConnectionID gets the connection ID of the Client. This is only used if you have MultiConnect enabled in ServerSettings and you need to, for instance, call *User functions with the Client's *User obtained with the client.User() function. If you do, use client.ConnectionID() when calling any *User functions from a Client.

func (*Client) Respond

func (c *Client) Respond(response interface{}, err ClientError)

Respond sends a CustomClientAction response to the client. If an error is provided, only the error mesage will be received by the Client (the response parameter will not be sent as well). It's perfectly fine to not send back any response if none is needed.

NOTE: A response can only be sent once to a Client. Any more calls to Respond() on the same Client will not send a response, nor do anything at all. If you want to send a stream of messages to the Client, first get their User object with *Client.User(), then you can send data messages directly to the User with the *User.DataMessage() function.

func (*Client) User

func (c *Client) User() *core.User

User gets the *User of the Client.

type ClientError

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

ClientError is used when an error is thrown in your CustomClientAction. Use `actions.NewError()` to make a ClientError object. When no error needs to be thrown, use `actions.NoError()` instead.

func NewError

func NewError(message string, id int) ClientError

NewError creates a new error with a provided message and ID.

func NoError

func NoError() ClientError

NoError is used when no error needs to be thrown in your `CustomClientAction`.

type CustomClientAction

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

CustomClientAction is an action that you can handle on the server from a connected client. For instance, a client can send to the server a CustomClientAction type "setPosition" that comes with parameters as an object {x: 2, y: 3}. You just need to make a callback function for the CustomClientAction type "setPosition", and as soon as the action is received by the server, the callback function will be executed concurrently in a Goroutine.