README
¶
Termloop
Fork of termloop to make the whole game state easily json-serializable to better support client-server sharing of state.
Documentation
¶
Index ¶
- Constants
- func LoadLevelFromMap(jsonMap string, parsers map[string]EntityParser, l Level) error
- type Attr
- type BaseLevel
- type Canvas
- type Cell
- type Drawable
- type DrawableType
- type DynamicPhysical
- type Entity
- func (e *Entity) ApplyCanvas(c *Canvas)
- func (e *Entity) Draw(s *Screen)
- func (e *Entity) Fill(c *Cell)
- func (e *Entity) GetUUID() string
- func (e *Entity) Position() (int, int)
- func (e *Entity) SetCell(x, y int, c *Cell)
- func (e *Entity) SetPosition(x, y int)
- func (e *Entity) Size() (int, int)
- func (e *Entity) Tick(ev Event)
- type EntityParser
- type Event
- type EventType
- type FpsText
- type Game
- type Key
- type Level
- type Modifier
- type Physical
- type Rectangle
- func (r *Rectangle) Draw(s *Screen)
- func (r *Rectangle) GetColor() Attr
- func (r *Rectangle) GetUUID() string
- func (r *Rectangle) Position() (int, int)
- func (r *Rectangle) SetColor(color Attr)
- func (r *Rectangle) SetPosition(x, y int)
- func (r *Rectangle) SetSize(w, h int)
- func (r *Rectangle) Size() (int, int)
- func (r *Rectangle) Tick(ev Event)
- type Screen
- func (s *Screen) AddEntity(d Drawable)
- func (s *Screen) Draw()
- func (s *Screen) Level() Level
- func (s *Screen) RemoveEntity(d Drawable)
- func (s *Screen) RenderCell(x, y int, c *Cell)
- func (s *Screen) SetFps(f float64)
- func (s *Screen) SetLevel(l Level)
- func (s *Screen) Size() (int, int)
- func (s *Screen) Tick(ev Event)
- func (s *Screen) TimeDelta() float64
- type Text
- func (t *Text) Color() (Attr, Attr)
- func (t *Text) Draw(s *Screen)
- func (t *Text) GetText() string
- func (t *Text) GetUUID() string
- func (t *Text) Position() (int, int)
- func (t *Text) SetColor(fg, bg Attr)
- func (t *Text) SetPosition(x, y int)
- func (t *Text) SetText(text string)
- func (t *Text) Size() (int, int)
- func (t *Text) Tick(ev Event)
Constants ¶
const ModAltModifier = 0x01
Variables ¶
This section is empty.
Functions ¶
func LoadLevelFromMap ¶
func LoadLevelFromMap(jsonMap string, parsers map[string]EntityParser, l Level) error
LoadLevelFromMap can be used to populate a Level with entities, given a JSON string to read from (jsonMap).
The map 'parsers' is a map of entity names to EntityParser functions. This can be used to define parsers for objects that are not Termloop builtins.
The JSON string should take the format of an array of objects, like so: [ {"type": "Rectangle", "data": {"x: 12 ...}}, ... ] For Rectangles and Text, all attributes must be defined in the JSON. For an Entity, fg and bg can be left as empty strings if you do not wish to color the Entity with an image, but the keys must still be present or the parsing will break.
There is an example of how to use this method at _examples/levelmap.go.
LoadLevelFromMap returns an error, or nil if all is well.
Types ¶
type Attr ¶
type Attr uint16
const ( ColorDefault Attr = iota ColorBlack ColorRed ColorGreen ColorYellow ColorBlue ColorMagenta ColorCyan ColorWhite )
Cell colors. You can combine these with multiple attributes using a bitwise OR ('|'). Colors can't combine with other colors.
Cell attributes. These can be combined with OR.
func RgbTo256Color ¶
RgbTo256Color takes RGB values and returns the closest color for a 256-color terminal, as an Attr type.
type BaseLevel ¶
type BaseLevel struct {
Entities []Drawable `json:"Entities"`
Bg Cell `json:"Bg"`
Offsetx int `json:"Offsetx"`
Offsety int `json:"Offsety"`
UUID string `json:"UUID"`
}
BaseLevel type represents a Level with a background defined as a Cell, which is tiled. The background is drawn first, then all Entities.
func NewBaseLevel ¶
NewBaseLevel creates a new BaseLevel with background bg. Returns a pointer to the new BaseLevel.
func (*BaseLevel) DrawBackground ¶
DrawBackground draws the background Cell bg to each Cell of the Screen s.
func (*BaseLevel) RemoveEntity ¶
RemoveEntity removes Drawable d from the level's entities.
type Canvas ¶
type Canvas [][]Cell
A Canvas is a 2D array of Cells, used for drawing. The structure of a Canvas is an array of columns. This is so it can be addrssed canvas[x][y].
func BackgroundCanvasFromFile ¶
BackgroundCanvasFromFile takes a path to an image file, and creates a canvas of background-only Cells representing the image. This can be applied to an Entity with ApplyCanvas.
func CanvasFromString ¶
CanvasFromString returns a new Canvas, built from the characters in the string str. Newline characters in the string are interpreted as a new Canvas row.
func ForegroundCanvasFromFile ¶
ForegroundCanvasFromFile takes a path to an image file, and creates a canvas of foreground-only Cells representing the image. This can be applied to an Entity with ApplyCanvas.
type Cell ¶
type Cell struct {
Fg Attr `json:"Fg"` // Foreground colour
Bg Attr `json:"Bg"` // Background color
Ch rune `json:"Ch"` // The character to draw
}
Represents a character to be drawn on the screen.
type Drawable ¶
type Drawable interface {
GetUUID() string //All drawables must implement an id for syncing client/server state
Tick(Event) // Method for processing events, e.g. input
Draw(*Screen) // Method for drawing to the screen
}
Drawable represents something that can be drawn, and placed in a Level.
type DrawableType ¶
type DrawableType string
const ( DrawableType_Entity DrawableType = "DrawableType_Entity" DrawableType_Rectangle DrawableType = "DrawableType_Rectangle" DrawableType_Text DrawableType = "DrawableType_Text" DrawableType_Custom DrawableType = "DrawableType_Custom" )
type DynamicPhysical ¶
type DynamicPhysical interface {
Position() (int, int) // Return position, x and y
Size() (int, int) // Return width and height
Collide(Physical) // Handle collisions with another Physical
}
DynamicPhysical represents something that can process its own collisions. Implementing this is an optional addition to Drawable.
type Entity ¶
type Entity struct {
Canvas Canvas `json:"Canvas"`
X int `json:"X"`
Y int `json:"Y"`
Width int `json:"Width"`
Height int `json:"Height"`
UUID string `json:"UUID"`
}
Provides a general Drawable to be rendered.
func NewEntity ¶
NewEntity creates a new Entity, with position (x, y) and size (width, height). Returns a pointer to the new Entity.
func NewEntityFromCanvas ¶
NewEntityFromCanvas returns a pointer to a new Entity, with position (x, y) and Canvas c. Width and height are calculated using the Canvas.
func (*Entity) ApplyCanvas ¶
ApplyCanvas takes a pointer to a Canvas, c, and applies this canvas over the top of the Entity's canvas. Any new values in c will overwrite those in the entity.
func (*Entity) Draw ¶
Draw draws the entity to its current position on the screen. This is usually called every frame.
func (*Entity) SetCell ¶
SetCell updates the attribute of the Cell at x, y to match those of c. The coordinates are relative to the entity itself, not the Screen.
func (*Entity) SetPosition ¶
SetPosition sets the x and y coordinates of the Entity.
type EntityParser ¶
An EntityParser is a function which composes an object from data that has been parsed from a JSON file. Returns a Drawable
type Event ¶
type Event struct {
Type EventType `json:"EventType"` // The type of event
Key Key `json:"Key"` // The key pressed, if any
Ch rune `json:"Ch"` // The character of the key, if any
Mod Modifier `json:"Mod"` // A keyboard modifier, if any
Err error `json:"Err"` // Error, if any
MouseX int `json:"MouseX"` // Mouse X coordinate, if any
MouseY int `json:"MouseY"` // Mouse Y coordinate, if any
}
Provides an event, for input, errors or resizing. Resizing and errors are largely handled by Termloop itself - this would largely be used for input.
type FpsText ¶
type FpsText struct {
// contains filtered or unexported fields
}
FpsText provides a Text which updates with the current 'framerate' at specified intervals, to be used for testing performance. Please note that the framerate displayed is a measure of Termloop's processing speed - visible framerate is largely dependent on your terminal!
func NewFpsText ¶
NewFpsText creates a new FpsText at position (x, y) and with background and foreground colors fg and bg respectively. It will refresh every 'update' seconds. Returns a pointer to the new FpsText.
type Game ¶
type Game struct {
// contains filtered or unexported fields
}
Represents a top-level Termloop application.
func NewGame ¶
func NewGame() *Game
NewGame creates a new Game, along with a Screen and input handler. Returns a pointer to the new Game.
func (*Game) Log ¶
Log takes a log string and additional parameters, which can be substituted into the string using standard fmt.Printf rules. The formatted string is added to Game g's logs. If debug mode is on, the log will be printed to the terminal when Termloop exits.
func (*Game) SetDebugOn ¶
SetDebugOn sets debug mode's on status to be debugOn.
func (*Game) SetEndKey ¶
SetEndKey sets the Key used to end the game. Default is KeyCtrlC. If you don't want an end key, set it to KeyEsc, as this key isn't supported and will do nothing. (We recommend always having an end key for development/testing.)
func (*Game) Start ¶
func (g *Game) Start()
Start starts a Game running. This should be the last thing called in your main function. By default, the escape key exits.
func (*Game) StartServerMode ¶
func (g *Game) StartServerMode()
Start starts a Game running in server mode (NoDraw). This should be the last thing called in your main function. By default, the escape key exits.
type Key ¶
type Key uint16
const ( KeyF1 Key = 0xFFFF - iota KeyF2 KeyF3 KeyF4 KeyF5 KeyF6 KeyF7 KeyF8 KeyF9 KeyF10 KeyF11 KeyF12 KeyInsert KeyDelete KeyHome KeyEnd KeyPgup KeyPgdn KeyArrowUp KeyArrowDown KeyArrowLeft KeyArrowRight MouseLeft MouseMiddle MouseRight MouseRelease MouseWheelUp MouseWheelDown )
Key constants. See Event.Key.
const ( KeyCtrlTilde Key = 0x00 KeyCtrl2 Key = 0x00 KeyCtrlSpace Key = 0x00 KeyCtrlA Key = 0x01 KeyCtrlB Key = 0x02 KeyCtrlC Key = 0x03 KeyCtrlD Key = 0x04 KeyCtrlE Key = 0x05 KeyCtrlF Key = 0x06 KeyCtrlG Key = 0x07 KeyBackspace Key = 0x08 KeyCtrlH Key = 0x08 KeyTab Key = 0x09 KeyCtrlI Key = 0x09 KeyCtrlJ Key = 0x0A KeyCtrlK Key = 0x0B KeyCtrlL Key = 0x0C KeyEnter Key = 0x0D KeyCtrlM Key = 0x0D KeyCtrlN Key = 0x0E KeyCtrlO Key = 0x0F KeyCtrlP Key = 0x10 KeyCtrlQ Key = 0x11 KeyCtrlR Key = 0x12 KeyCtrlS Key = 0x13 KeyCtrlT Key = 0x14 KeyCtrlU Key = 0x15 KeyCtrlV Key = 0x16 KeyCtrlW Key = 0x17 KeyCtrlX Key = 0x18 KeyCtrlY Key = 0x19 KeyCtrlZ Key = 0x1A KeyEsc Key = 0x1B // No longer supported KeyCtrlLsqBracket Key = 0x1B KeyCtrl3 Key = 0x1B KeyCtrl4 Key = 0x1C KeyCtrlBackslash Key = 0x1C KeyCtrl5 Key = 0x1D KeyCtrlRsqBracket Key = 0x1D KeyCtrl6 Key = 0x1E KeyCtrl7 Key = 0x1F KeyCtrlSlash Key = 0x1F KeyCtrlUnderscore Key = 0x1F KeySpace Key = 0x20 KeyBackspace2 Key = 0x7F KeyCtrl8 Key = 0x7F )
type Level ¶
type Level interface {
DrawBackground(*Screen)
AddEntity(Drawable)
RemoveEntity(Drawable)
Draw(*Screen)
Tick(Event)
}
Level interface represents a Drawable with a separate background that is drawn first. It can also contain Drawables of its own.
type Physical ¶
type Physical interface {
Position() (int, int) // Return position, x and y
Size() (int, int) // Return width and height
}
Physical represents something that can collide with another Physical, but cannot process its own collisions. Optional addition to Drawable.
type Rectangle ¶
type Rectangle struct {
X int `json:"X"`
Y int `json:"Y"`
Width int `json:"Width"`
Height int `json:"Height"`
Bg Attr `json:"Bg"`
Fg Attr `json:"Fg"`
UUID string `json:"UUID"`
Ch rune `json:"Ch"`
}
A type representing a 2D rectangle, with position, size and color.
func NewRectangle ¶
NewRectangle creates a new Rectangle at position (x, y), with size (width, height) and color color. Returns a pointer to the new Rectangle.
func (*Rectangle) SetPosition ¶
SetPosition sets the coordinates of the Rectangle to be x and y.
type Screen ¶
type Screen struct {
Entities []Drawable
// contains filtered or unexported fields
}
A Screen represents the current state of the display. To draw on the screen, create Drawables and set their positions. Then, add them to the Screen's Level, or to the Screen directly (e.g. a HUD).
func NewScreen ¶
func NewScreen() *Screen
NewScreen creates a new Screen, with no entities or level. Returns a pointer to the new Screen.
func (*Screen) Draw ¶
func (s *Screen) Draw()
Draw is called every frame by the Game to render the current state of the screen.
func (*Screen) RemoveEntity ¶
RemoveEntity removes Drawable d from the screen's entities.
func (*Screen) RenderCell ¶
RenderCell updates the Cell at a given position on the Screen with the attributes in Cell c.
func (*Screen) SetFps ¶
Set the screen framerate. By default, termloop will draw the the screen as fast as possible, which may use a lot of system resources.
type Text ¶
type Text struct {
X int `json:"X"`
Y int `json:"Y"`
Fg Attr `json:"Fg"`
Bg Attr `json:"Bg"`
Text []rune `json:"Text"`
Canvas []Cell `json:"Canvas"`
UUID string `json:"UUID"`
}
Text represents a string that can be drawn to the screen.
func NewText ¶
NewText creates a new Text, at position (x, y). It sets the Text's background and foreground colors to fg and bg respectively, and sets the Text's text to be text. Returns a pointer to the new Text.
func (*Text) SetColor ¶
SetColor sets the (foreground, background) colors of the Text to fg, bg respectively.
func (*Text) SetPosition ¶
SetPosition sets the coordinates of the Text to be (x, y).
Source Files
Directories