input

type ControllerType ¶

type ControllerType int

ControllerType keeps track of which controller type is being used at any given moment. we need this so that we don't ground/recharge the paddle if it is not being used. if we did then joystick input would be wrong.

we default to the joystick type which should be fine. for non-joystick games, the paddle/keypad will be activated once the user starts using the corresponding controls.

if a paddle/keypad ROM requires paddle/keypad probing from the instant the machine starts (are there any examples of this?) then we will need to initialise the hand controller accordingly, using the setup system.

const (
	JoystickType ControllerType = iota
	PaddleType
	KeypadType
)

func (c ControllerType) String() string

type Event ¶

type Event string

Event represents the possible actions that can be performed by the user when interacting with the console

const (
	NoEvent Event = "NoEvent" // nil

	// the controller has been unplugged
	Unplug Event = "Unplug" // nil

	// joystick
	Fire  Event = "Fire"  // bool
	Up    Event = "Up"    // bool
	Down  Event = "Down"  // bool
	Left  Event = "Left"  // bool
	Right Event = "Right" // bool

	// panel
	PanelSelect Event = "PanelSelect" // bool
	PanelReset  Event = "PanelReset"  // bool

	PanelSetColor      Event = "PanelSetColor"      // bool
	PanelSetPlayer0Pro Event = "PanelSetPlayer0Pro" // bool
	PanelSetPlayer1Pro Event = "PanelSetPlayer1Pro" // bool

	PanelToggleColor      Event = "PanelToggleColor"      // nil
	PanelTogglePlayer0Pro Event = "PanelTogglePlayer0Pro" // nil
	PanelTogglePlayer1Pro Event = "PanelTogglePlayer1Pro" // nil

	// paddles
	PaddleFire Event = "PaddleFire" // bool
	PaddleSet  Event = "PaddleSet"  // float64

	// keypad (only need down event)
	KeypadDown Event = "KeypadDown" // rune
	KeypadUp   Event = "KeypadUp"   // nil

	PanelPowerOff Event = "PanelPowerOff" // nil
)

type EventData ¶

type EventData interface{}

EventData is the value associated with the event. The underlying type should be restricted to bool, float32, or int. string is also acceptable but for simplicity of playback parsers, "true" or "false" should not be used and numbers should be represented by float32 or int.

type EventRecorder ¶

type EventRecorder interface {
	RecordEvent(ID, Event, EventData) error
}

EventRecorder implementations mirror an incoming event.

Implementations should be able to handle being attached to more than one peripheral at once. The ID parameter of the EventRecord() function will help to differentiate between multiple devices.

type HandController ¶

type HandController struct {

	// the current controller type. use SwitchType() to set.
	ControllerType ControllerType

	// whether SwitchType() should respond to automatic switching. use
	// SetAuto() to set.
	AutoControllerType bool
	// contains filtered or unexported fields
}

HandController represents the "joystick" port on the VCS. The different devices (joysticks, paddles, etc.) send events to the Handle() function.

Note that handcontrollers need access to TIA memory as well as RIOT memory.

func NewHandController0(mem *inputMemory, control *VBlankBits) *HandController

func NewHandController1(mem *inputMemory, control *VBlankBits) *HandController

func (p *HandController) AttachEventRecorder(scribe EventRecorder)

func (p *HandController) AttachPlayback(playback Playback)

func (p *HandController) CheckInput() error

func (hc *HandController) Handle(event Event, value EventData) error

func (hc *HandController) Reset()

func (hc *HandController) SetAuto(auto bool)

func (hc *HandController) String() string

func (hc *HandController) SwitchType(newType ControllerType) error

type ID ¶

type ID int

ID differentiates the different ports attached to the console

const (
	HandControllerZeroID ID = iota
	HandControllerOneID
	PanelID
	NumIDs
)

type Input ¶

type Input struct {
	VBlankBits VBlankBits

	Panel           *Panel
	HandController0 *HandController
	HandController1 *HandController
	// contains filtered or unexported fields
}

Input implements the input/output part of the RIOT (the IO in RIOT)

func NewInput(riotMem bus.ChipBus, tiaMem bus.ChipBus) (*Input, error)

func (inp *Input) Step()

func (inp *Input) Update(data bus.ChipData) bool

type Panel ¶

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

Panel represents the console's front control panel

func NewPanel(mem *inputMemory) *Panel

func (p *Panel) AttachEventRecorder(scribe EventRecorder)

func (p *Panel) AttachPlayback(playback Playback)

func (p *Panel) CheckInput() error

func (pan *Panel) Handle(event Event, value EventData) error

func (pan *Panel) String() string

type Playback ¶

type Playback interface {
	// note the type restrictions on EventData in the type definition's
	// commentary
	CheckInput(id ID) (Event, EventData, error)
}

Playback implementations feed controller Events to the device on request with the CheckInput() function.

Intended for playback of controller events previously recorded to a file on disk but usable for many purposes I suspect. For example, AI control.

type Port ¶

type Port interface {
	String() string
	Handle(Event, EventData) error
	AttachPlayback(Playback)
	AttachEventRecorder(EventRecorder)
}

Port conceptualises the I/O ports as described in the Stella Programmer's Guide (page 13). Port B is the VCS's switches on its front panel, while Port A allows the various hand controllers to be attached.

See the HandController and Panel types for more information

type VBlankBits ¶

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

VBlankBits represents the bits in the VBLANK register that control paddle-grounding and joystick-latching. The VBLANK address is handled by the TIA but these bits in that register are needed by the input system.

VBlankBits is instantiated by NewInput() and then a reference given to the TIA (by NewVCS() in the hardware package)

func (c *VBlankBits) SetGroundPaddles(v bool)

func (c *VBlankBits) SetLatchFireButton(v bool)