c80

package module

v0.0.1 Latest Latest Go to latest Published: Jul 31, 2020 License: MIT Imports: 8 Imported by: 3

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/reiver/go-c80

Links

Open Source Insights

README ¶

go-c80

Package c80 provides a graphics library for the Go programming language.

Documention

Online documentation, which includes examples, can be found at: http://godoc.org/github.com/reiver/go-c80

Documentation ¶

Overview ¶

Package c80 provides an ‘engine’ for creating a fantasy console computer geared towards video games that is inspired by arcade game machines, home video game consoles, handheld game consoles, and (other) computers from the 1980s.

Example

import "github.com/reiver/go-c80"

// ...

c80.Colorize("tia")

// ...

c80.Draw(c80.Map(mapX,mapY, width,height))
c80.Draw(c80.Relocate(x,y, Sprite("32x32", id)))

Index ¶

func ColorIndex(c color.Color) uint8
func Colorize(a ...interface{}) error
func Draw(img image.Image) error
func Dye(index uint8) image.Image
func Frame() []uint8
func Image() draw.Image
func Map() image.Image
func Memory() []uint8
func Pixel(x, y int, index uint8) image.Image
func Rectangle(x, y int, width, height int, index uint8) image.Image
func Relocate(x, y int, img image.Image) image.Image
func Reveal()
func Serialize() string
func SetSprite(kind string, id uint8, img image.Image) error
func Sprite(kind string, id uint8) image.Image
type Terminator

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func ColorIndex ¶

func ColorIndex(c color.Color) uint8

ColorIndex returns the closest color in the color palette to the color ‘c’ as a color index.

The c80 machine uses a color palette of 256 colors.

Therefore, anything that is drawn to it would only be using color's from its color palette.

Note that the colors in the c80's color palette can be changed! If that happens then the index given by this previously may not be valid anymore. (You may have to call ColorIndex again, if you still want the closest color.)

func Colorize ¶

func Colorize(a ...interface{}) error

Colorize sets the color palette.

Example ¶

Here are some examples of Colorize being used:

err := c80.Colorize("tia")

Valid color palettes include:

• "gb"

• "greer"

• "gruvbox"

• "html3"

• "lospec500"

• "nes"

• "rkbv"

• "solarized"

• "tia"

func Draw ¶

func Draw(img image.Image) error

Draw draws the ‘img’.

Examples ¶

Here are some examples of Draw being used:

err := c80.Draw(c80.Dye(index))

And:

err := c80.Draw(c80.Pixel(index, x, y))

And:

err := c80.Draw(c80.Map(mx, my, width,height))

And:

err := c80.Draw(c80.Relocate(x,y, c80.Sprite("32x32", id)))

And:

err := c80.Draw(c80.Text("Hello world!"), x, y)

Example ¶

// Set the color palette to "vt".
err := c80.Colorize("vt")
if nil != err {
	fmt.Printf("ERROR: could not set the palette: %s", err)
	return
}

const bgIndex = 4 // 4 is blue  in the "vt" color palette.
const fgIndex = 7 // 7 is white in the "vt" color palette.

// Clear the whole frame with the backgroud color.
//
// That means that every pixel of the frame will have the same color.
err = c80.Draw(c80.Dye(bgIndex))
if nil != err {
	fmt.Printf("ERROR: could not clear the image with color at index=%d: %s", bgIndex, err)
	return
}

const left = 5
const top = 10

// Here we draw something that looks like a key.
//
//	▄▄▄▄▄█▀█
//	▀ ▀  ▀▀▀
{
	//                      0
	//                      1
	//                      2
	//                      3
	//                      4
	c80.Draw(c80.Pixel(left+5, top+0, fgIndex))
	c80.Draw(c80.Pixel(left+6, top+0, fgIndex))
	c80.Draw(c80.Pixel(left+7, top+0, fgIndex))

	c80.Draw(c80.Pixel(left+0, top+1, fgIndex))
	c80.Draw(c80.Pixel(left+1, top+1, fgIndex))
	c80.Draw(c80.Pixel(left+2, top+1, fgIndex))
	c80.Draw(c80.Pixel(left+3, top+1, fgIndex))
	c80.Draw(c80.Pixel(left+4, top+1, fgIndex))
	c80.Draw(c80.Pixel(left+5, top+1, fgIndex))
	//                      6
	c80.Draw(c80.Pixel(left+7, top+1, fgIndex))

	c80.Draw(c80.Pixel(left+0, top+2, fgIndex))
	//                      1
	c80.Draw(c80.Pixel(left+2, top+2, fgIndex))
	//                      3
	//                      4
	c80.Draw(c80.Pixel(left+5, top+2, fgIndex))
	c80.Draw(c80.Pixel(left+6, top+2, fgIndex))
	c80.Draw(c80.Pixel(left+7, top+2, fgIndex))
}

// Here we output a serialized version of the frame.
//
// This will output something like:
//
//	IMAGE:base64-encoded-png
//
// Where "base64-encoded-png" is replaced with the base64 encoding of a PNG version of the raster image.
fmt.Print(c80.Serialize())

Output:


IMAGE:iVBORw0KGgoAAAANSUhEUgAAAQAAAAEgCAIAAADUvDoHAAADTklEQVR4nOzasQ2CUBRAUTSM4Cis4wwOxRIO4SgMYUFCocYSEu451Q80r3iXQMI4PJ4DVF2PHgCOJADSBECaAEgTAGkCIE0ApAmANAGQNv6//brf1sM0L7vMA7v6DGDb+M00L98X4Rx+vAKtD/tpXtaD7efELn6Go8xHMGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIO0dAAD//1sjEleiMSMyAAAAAElFTkSuQmCC

func Dye ¶

func Dye(index uint8) image.Image

Example ¶

// Set the color palette to "vt".
err := c80.Colorize("vt")
if nil != err {
	fmt.Printf("ERROR: could not set the palette: %s", err)
	return
}

const bgIndex = 3 // 3 is yellow in the "vt" color palette.

// Clear the whole frame with the backgroud color.
//
// That means that every pixel of the frame will have the same color.
err = c80.Draw(c80.Dye(bgIndex))
if nil != err {
	fmt.Printf("ERROR: could not clear the image with color at index=%d: %s", bgIndex, err)
	return
}

// Show the raster image.
//
// This will output something like:
//
//	IMAGE:base64-encoded-png
//
// Where "base64-encoded-png" is replaced with the base64 encoding of a PNG version of the raster image.
serialized := c80.Serialize()
fmt.Print(serialized)

Output:

IMAGE:iVBORw0KGgoAAAANSUhEUgAAAQAAAAEgCAIAAADUvDoHAAADGklEQVR4nOzTQQ0AIRDAwMuF4N8VskDGPjqjoJ+ue/YHVf90AEwyAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSDECaAUgzAGkGIM0ApBmANAOQZgDSXgAAAP//4EQED7U/dIwAAAAASUVORK5CYII=

func Frame ¶

func Frame() []uint8

Frame returns a []uint8 that represents the memory that backs the (main) animation frame.

The bytes in this represents a series of 32-bit RGBA values, starting from the top-left corner, and going to the bottom-right corner.

func Image ¶

func Image() draw.Image

Image return a draw.Image for the (main) animation frame.

func Map ¶

func Map() image.Image

func Memory ¶

func Memory() []uint8

Memory returns the entire memory of the c80 machine.

Reading and writing to this give you access to everything.

func Pixel ¶

func Pixel(x, y int, index uint8) image.Image

Example ¶

// Make the entire raster image the color of color 0 in the (color) palette.
c80.Draw(c80.Dye(0))

// Draw something.
//
// What is draw is a sprite-art / pixel-art style ghost.
{
	left := 20
	top := 30

	//                      0
	c80.Draw(c80.Pixel(left+1, top+0, 6))
	c80.Draw(c80.Pixel(left+2, top+0, 6))
	c80.Draw(c80.Pixel(left+3, top+0, 6))
	c80.Draw(c80.Pixel(left+4, top+0, 6))
	//                      5
	//                      6
	//                      7

	//                      0
	//                      1
	c80.Draw(c80.Pixel(left+2, top+1, 6))
	c80.Draw(c80.Pixel(left+3, top+1, 6))
	c80.Draw(c80.Pixel(left+4, top+1, 6))
	c80.Draw(c80.Pixel(left+5, top+1, 6))
	//                      6
	//                      7

	c80.Draw(c80.Pixel(left+0, top+2, 6))
	//                      1
	c80.Draw(c80.Pixel(left+2, top+2, 6))
	c80.Draw(c80.Pixel(left+3, top+2, 15))
	c80.Draw(c80.Pixel(left+4, top+2, 6))
	c80.Draw(c80.Pixel(left+5, top+2, 15))
	//                      6
	c80.Draw(c80.Pixel(left+7, top+2, 6))

	c80.Draw(c80.Pixel(left+0, top+3, 6))
	//                      1
	c80.Draw(c80.Pixel(left+2, top+3, 6))
	c80.Draw(c80.Pixel(left+3, top+3, 6))
	c80.Draw(c80.Pixel(left+4, top+3, 6))
	c80.Draw(c80.Pixel(left+5, top+3, 6))
	//                      6
	c80.Draw(c80.Pixel(left+7, top+3, 6))

	//                      0
	c80.Draw(c80.Pixel(left+1, top+4, 6))
	c80.Draw(c80.Pixel(left+2, top+4, 6))
	c80.Draw(c80.Pixel(left+3, top+4, 6))
	c80.Draw(c80.Pixel(left+4, top+4, 15))
	c80.Draw(c80.Pixel(left+5, top+4, 6))
	c80.Draw(c80.Pixel(left+6, top+4, 6))
	//                      7

	//                      0
	//                      1
	c80.Draw(c80.Pixel(left+2, top+5, 6))
	c80.Draw(c80.Pixel(left+3, top+5, 6))
	c80.Draw(c80.Pixel(left+4, top+5, 6))
	c80.Draw(c80.Pixel(left+5, top+5, 6))
	//                      6
	//                      7

	c80.Draw(c80.Pixel(left+0, top+6, 6))
	//                      1
	c80.Draw(c80.Pixel(left+2, top+6, 6))
	c80.Draw(c80.Pixel(left+3, top+6, 6))
	c80.Draw(c80.Pixel(left+4, top+6, 6))
	//                      5
	//                      6
	//                      7

	//                      0
	c80.Draw(c80.Pixel(left+1, top+7, 6))
	c80.Draw(c80.Pixel(left+2, top+7, 6))
	c80.Draw(c80.Pixel(left+3, top+7, 6))
	//                      4
	//                      5
	//                      6
	//                      7
}

// Show the raster image.
//
// This will output something like:
//
//	IMAGE:base64-encoded-png
//
// Where "base64-encoded-png" is replaced with the base64 encoding of a PNG version of the raster image.
serialized := c80.Serialize()
fmt.Print(serialized)

Output:

IMAGE:iVBORw0KGgoAAAANSUhEUgAAAQAAAAEgCAIAAADUvDoHAAADbUlEQVR4nOzdwUnEUBRAUSNTg9iD2IhYrtiI2INYhYuBkP0Phsc9ZxFmM5DFu/z/mMXctm17gKrHq18AriQA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpt8Xvv3z87J+/35+X3wf+1eoJcBz6YwwwwlIA+8R/vT3tTxkwyDk7wOvn7/6EQbbFf4g5HgL3AGwCDLIagD2Y0c7ZAe5MP+OcdgUy/Ux0whUI5vJLMGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGl/AQAA//8xpiDee8Kb6AAAAABJRU5ErkJggg==

func Rectangle ¶

func Rectangle(x, y int, width, height int, index uint8) image.Image

Example ¶

// Make the entire raster image the color of color 0 in the (color) palette.
c80.Draw(c80.Dye(0))

// Draw something.
//
// What is draw is a sprite-art / pixel-art style ghost.
{
	var left int = 78
	var top int = 50

	var width int = 100
	var height int = 50

	var index uint8 = 4

	c80.Draw(c80.Rectangle(left, top, width, height, index))
}

// Show the raster image.
//
// This will output something like:
//
//	IMAGE:base64-encoded-png
//
// Where "base64-encoded-png" is replaced with the base64 encoding of a PNG version of the raster image.
serialized := c80.Serialize()
fmt.Print(serialized)

Output:

IMAGE:iVBORw0KGgoAAAANSUhEUgAAAQAAAAEgCAIAAADUvDoHAAADMElEQVR4nOzVUQ0CURAEQZacOcwgBjPIAxdvc+kqBfPTmWtmHlD13B4AmwRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0q7tAef83t/tCbcxn9f2hEM8AGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkzM9sbYI0HIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmAtH8AAAD//6fMBUpntzDXAAAAAElFTkSuQmCC

func Relocate ¶

func Relocate(x, y int, img image.Image) image.Image

func Reveal ¶

func Reveal()

func Serialize ¶

func Serialize() string

func SetSprite ¶

func SetSprite(kind string, id uint8, img image.Image) error

SetSprite sets the value of a sprite to the built-in image.Image.

There are 3 kinds of sprites:

• 8x8 • 32x32 • tile

For each fo these, the id runs from 0 to 255.

func Sprite ¶

func Sprite(kind string, id uint8) image.Image

Sprite returns a sprite as a Go built-in image.Image.

There are 3 kinds of sprites:

• 8x8 • 32x32 • tile

For each fo these, the id runs from 0 to 255.

Example ¶

// Set the color palette to "vt".
err := c80.Colorize("vt")
if nil != err {
	fmt.Printf("ERROR: could not set the palette: %s", err)
	return
}

// Get the closest colors in the current palette to these colors.
var blue uint8 = c80.ColorIndex(color.RGBA{0, 0, 255, 0})
var white uint8 = c80.ColorIndex(color.RGBA{255, 255, 255, 255})
var trnsprnt uint8 = c80.ColorIndex(color.RGBA{0, 0, 0, 0})

// Clear.
err = c80.Draw(c80.Dye(blue))
if nil != err {
	fmt.Printf("ERROR: could not clear the frame: %s", err)
	return
}

// The id of the sprite.
//
// We could have picked any number from 0 to 255.
// In this example, we simple just chose this one.
const id = 200

// Here we define what the sprite will look like.
//
// This is an 8×8 grid.
//
// This sprite art — which nowadays many call: pixel-art — is of a key,
// that looks something like:
//
//	     ▄▄▄
//	█▀█▀▀█▄█
{
	var buffer [8 * 8]uint8 = [8 * 8]uint8{
		trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt,
		trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt,
		trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt,
		trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt,
		trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt,
		trnsprnt, trnsprnt, trnsprnt, trnsprnt, trnsprnt, white, white, white,
		white, white, white, white, white, white, trnsprnt, white,
		white, trnsprnt, white, trnsprnt, trnsprnt, white, white, white,
	}

	sprite := c80.Sprite("8x8", id).(sprite8x8.Paletted)

	p := sprite.Pix

	copy(p, buffer[:])

}

// We are going to draw that sprite twice.
//
// This is the 1st time we draw the sprite.
//
// We don't relocate the position of the sprite this time.
// So the sprite will just appear in the top-left corner.
c80.Draw(c80.Sprite("8x8", id))

// This is the (x,y) coordinate of where we will draw the sprite
// the 2nd time.
//
// This (x,y) location corresponds to the sprite's (new) top-left corner.
const x, y = 123, 139

// This is the 2nd time we draw the (same) sprite.
//
// Except this time we have relocated it to (x,y)=(123,139) (rather than
// (x,y)=(0,0) like the 1st time we drew it).
//
// Here (x,y)=(123,139) corresponds to the sprite's top-left corner.
c80.Draw(c80.Relocate(x, y, c80.Sprite("8x8", id)))

// Here we draw a sprite at (x,y)=(200,180)
c80.Draw(c80.Relocate(200, 180, c80.Sprite("8x8", 247)))

// Show the raster image.
//
// This will output something like:
//
//	IMAGE:base64-encoded-png
//
// Where "base64-encoded-png" is replaced with the base64 encoding of a PNG version of the raster image.
serialized := c80.Serialize()
fmt.Print(serialized)

Output:

IMAGE:iVBORw0KGgoAAAANSUhEUgAAAQAAAAEgCAIAAADUvDoHAAADvUlEQVR4nOzdTW7bMBgAUX2Cb9Tc/wTplaKisSu0ibeyhM57K1orIuDoh1nwtizbAlXr2ROAMwmANAGQJgDSbl9+b38+iWdOmA282G37tgk0s3y/CP+ldb/ZzzwGVj8d4/8AlPkIJk0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEgTAGkCIE0ApAmANAGQJgDSBECaAEi7nT2Bum17DGZOnkmTAF5tX/G7mScXeQ2vQCe43+xnHgOr/0SzLP78dHkCkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDRHJHGgbXmcfDZXPYfFE4Cj7Kv/y/hSBMCB1s8DANeZ9aqHYDojjKPc7/o/39/vP9/efpw9oycEwCHuq3+/8X98HoV5wS8BH8Ec5ffbzzb/jK/3HuQJwFFm1s9TkD/2wdkzekIAHOLvDdArb4YKgDTboKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkCYA0gRAmgBIEwBpAiBNAKQJgDQBkPYrAAD//99QOU2R1Sq/AAAAAElFTkSuQmCC

Types ¶

type Terminator ¶

type Terminator interface {
	image.Image

	Clear()
	Height() int
	LineFeed()
	Publish(s string)
	Runes() []rune
	String() string
	Width() int
}

var (
	Terminal Terminator
)

Directories ¶

Path	Synopsis
machine Package c80machine provides a type that represents a fantasy virtual machine inspired by arcade game machines, home video game consoles, handheld game consoles, and (other) computers from the 1980s.	Package c80machine provides a type that represents a fantasy virtual machine inspired by arcade game machines, home video game consoles, handheld game consoles, and (other) computers from the 1980s.

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

go-c80

Documention

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func ColorIndex ¶

func Colorize ¶

Example ¶

func Draw ¶

Examples ¶

func Dye ¶

func Frame ¶

func Image ¶

func Map ¶

func Memory ¶

func Pixel ¶

func Rectangle ¶

func Relocate ¶

func Reveal ¶

func Serialize ¶

func SetSprite ¶

func Sprite ¶

Types ¶

type Terminator ¶

Source Files ¶

Directories ¶