board

package
v0.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 6, 2022 License: BSD-3-Clause Imports: 2 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var BMM = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Star},
			{Type: mp1.Mushroom},
			{Type: mp1.Happening, StoppingEvent: bmmEruptVolcano},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Bowser},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Start},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Star},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, PassingEvent: bmmReachFork(
				mp1.NewChainSpace(1, 0), mp1.NewChainSpace(2, 2),
			)},
		},
		{
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Red},
			{Type: mp1.Star},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Happening, StoppingEvent: bmmEruptVolcano},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, PassingEvent: bmmReachFork(
				mp1.NewChainSpace(2, 0), mp1.NewChainSpace(3, 5),
			)},
		},
		{
			{Type: mp1.Mushroom},
			{Type: mp1.Red},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Star},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Happening, StoppingEvent: bmmEruptVolcano},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, PassingEvent: bmmReachFork(
				mp1.NewChainSpace(3, 0), mp1.NewChainSpace(0, 1),
			)},
		},
		{
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Bowser},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Star},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Happening, StoppingEvent: bmmEruptVolcano},
			{Type: mp1.Mushroom},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Star},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, PassingEvent: bmmFinalFork},
		},
		{
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Red},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, PassingEvent: bmmVisitBowser},
			{Type: mp1.Red},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Happening, StoppingEvent: bmmEruptVolcano},
		},
		{
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Boo},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
			{Type: mp1.Star},
			{Type: mp1.Invisible, StoppingEvent: bmmLandOnRegularSpace, HiddenBlock: true},
		},
	},
	Links: &map[int]*[]mp1.ChainSpace{
		4: {mp1.NewChainSpace(0, 0)},
		5: {mp1.NewChainSpace(0, 0)},
	},
	BowserCoins:      0,
	Data:             bmmBoardData{},
	EndCharacterTurn: bmmCharacterEndTurn{},
}

BMM holds the data for Bowser's Magma Mountain.

View Source 
var DKJA = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Blue},
			{Type: mp1.Boo},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Start},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: dkjaCanPassWhomp(0)},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: dkjaCanPassCoinBlockade(0)},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Red},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: dkjaCanPassWhomp(1)},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Boo},
			{Type: mp1.Invisible, PassingEvent: dkjaCanPassCoinBlockade(1)},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.MinigameSpace},
			{Type: mp1.Red},
			{Type: mp1.BogusItem},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: dkjaCanPassWhomp(2)},
		},
		{
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Happening, StoppingEvent: dkjaBoulder},
			{Type: mp1.Blue},
		},
	},
	Links: &map[int]*[]mp1.ChainSpace{
		2: {mp1.NewChainSpace(0, 18)},
		3: {mp1.NewChainSpace(0, 16)},
		6: {mp1.NewChainSpace(5, 9)},
		7: {mp1.NewChainSpace(0, 15)},
		9: {mp1.NewChainSpace(0, 13)},
	},
	BowserCoins: 10,
	Data: dkjaBoardData{
		WhompPos: [3]bool{false, false, false},
		WhompMainDestination: [3]mp1.ChainSpace{
			mp1.NewChainSpace(4, 0),
			mp1.NewChainSpace(5, 0),
			mp1.NewChainSpace(9, 0),
		},
		WhompOffshootDestination: [3]mp1.ChainSpace{
			mp1.NewChainSpace(1, 0),
			mp1.NewChainSpace(6, 0),
			mp1.NewChainSpace(0, 0),
		},
		CoinAcceptDestination: [2]mp1.ChainSpace{
			mp1.NewChainSpace(2, 0),
			mp1.NewChainSpace(7, 0),
		},
		CoinRejectDestination: [2]mp1.ChainSpace{
			mp1.NewChainSpace(3, 0),
			mp1.NewChainSpace(8, 0),
		},
	},
}

DKJA holds the data for Donkey Kong's Jungle Adventure.

View Source 
var ES = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Invisible},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Bowser},
			{Type: mp1.Invisible, PassingEvent: esWarpC},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{
				Type:          mp1.Invisible,
				PassingEvent:  esPassStarSpace(0),
				StoppingEvent: esLandOnChanceTime,
			},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: esSendToStart},
			{
				Type: mp1.Invisible,
				PassingEvent: esWarpSpace(
					esEntrance1,
					esEntrance7,
					esEntrance6,
				),
			},
		},
		{
			{Type: mp1.Red},
			{
				Type:          mp1.Invisible,
				PassingEvent:  esPassStarSpace(1),
				StoppingEvent: esLandOnChanceTime,
			},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{
				Type: mp1.Invisible,
				PassingEvent: esWarpSpace(
					esEntrance6,
					esEntrance4,
					esEntrance1,
				),
			},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: esSendToStart},
			{
				Type: mp1.Invisible,
				PassingEvent: esWarpSpace(
					esEntrance1,
					esEntrance6,
					esEntrance7,
				),
			},
		},
		{
			{Type: mp1.Invisible},
			{Type: mp1.Blue},
			{
				Type:          mp1.Invisible,
				PassingEvent:  esPassStarSpace(2),
				StoppingEvent: esLandOnChanceTime,
			},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{
				Type: mp1.Invisible,
				PassingEvent: esBranchWithWarp(
					esEntrance9,
					esEntrance9,
					esEntrance8,
				),
			},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{
				Type:          mp1.Invisible,
				PassingEvent:  esPassStarSpace(3),
				StoppingEvent: esLandOnChanceTime,
			},
			{Type: mp1.Blue},
			{
				Type: mp1.Invisible,
				PassingEvent: esWarpSpace(
					esEntrance5,
					esEntrance8,
					esEntrance5,
				),
			},
		},
		{
			{Type: mp1.Invisible},
			{Type: mp1.Red},
			{Type: mp1.Happening, StoppingEvent: esSendToStart},
			{
				Type:          mp1.Invisible,
				PassingEvent:  esPassStarSpace(4),
				StoppingEvent: esLandOnChanceTime,
			},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Invisible},
			{Type: mp1.Blue},
			{
				Type:          mp1.Invisible,
				PassingEvent:  esPassStarSpace(5),
				StoppingEvent: esLandOnChanceTime,
			},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{
				Type:          mp1.Invisible,
				PassingEvent:  esPassStarSpace(6),
				StoppingEvent: esLandOnChanceTime,
			},
			{Type: mp1.Happening, StoppingEvent: esSendToStart},
			{
				Type: mp1.Invisible,
				PassingEvent: esBranchWithWarp(
					esEntrance9,
					esEntrance9,
					esEntrance8,
				),
			},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{
				Type: mp1.Invisible,
				PassingEvent: esWarpSpace(
					esEntrance8,
					esEntrance1,
					esEntrance4,
				),
			},
		},
		{
			{Type: mp1.Invisible},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Invisible},
			{Type: mp1.Boo},
		},
		{
			{Type: mp1.Invisible},
			{Type: mp1.Invisible, PassingEvent: esVisitBowser},
		},
	},
	Links: &map[int]*[]mp1.ChainSpace{
		0:  {mp1.NewChainSpace(1, 0), mp1.NewChainSpace(2, 0)},
		1:  {mp1.NewChainSpace(3, 0), mp1.NewChainSpace(4, 0)},
		2:  {mp1.NewChainSpace(5, 0), mp1.NewChainSpace(6, 0)},
		8:  {mp1.NewChainSpace(0, 1)},
		10: {mp1.NewChainSpace(9, 3)},
		11: {mp1.NewChainSpace(0, 1)},
		12: {mp1.NewChainSpace(0, 1)},
	},
	Data: esBoardData{},
}

ES holds the data for Eternal Star.

View Source 
var LER = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Boo},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Start},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: lerRBRFork},
		},
		{
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Invisible, PassingEvent: lerVisitRobot},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.BogusItem},
			{Type: mp1.Red},
			{Type: mp1.Happening, StoppingEvent: lerSwapGates},
			{Type: mp1.Invisible, PassingEvent: lerRBFork},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Invisible, PassingEvent: lerBRFork1},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: lerGotoIsland(0)},
			{Type: mp1.Happening, StoppingEvent: lerGotoIsland(1)},
			{Type: mp1.Invisible, PassingEvent: lerBRFork2},
		},
		{
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: lerBRFork3},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Star},
			{Type: mp1.Bowser},
			{Type: mp1.Happening, StoppingEvent: lerSwapGates},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: lerVisitRobot},
			{Type: mp1.Happening, StoppingEvent: lerSwapGates},
		},
	},
	Links: &map[int]*[]mp1.ChainSpace{
		0:  {mp1.NewChainSpace(1, 0), mp1.NewChainSpace(2, 0)},
		2:  {mp1.NewChainSpace(1, 3)},
		4:  {mp1.NewChainSpace(0, 0)},
		7:  {mp1.NewChainSpace(0, 0)},
		8:  {mp1.NewChainSpace(0, 0)},
		10: {mp1.NewChainSpace(0, 0)},
		11: {mp1.NewChainSpace(9, 7)},
	},
	BowserCoins:      19,
	Data:             lerBoardData{},
	EndCharacterTurn: lerEndCharacterTurn{},
}

LER holds the data for Luigi's Engine Room.

View Source 
var MRC = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Invisible},
			{Type: mp1.Start},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Happening, StoppingEvent: mrcSwapCastleDir},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Chance},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Boo},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Happening, StoppingEvent: mrcSwapCastleDir},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: mrcSwapCastleDir},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: mrcSwapCastleDir},
			{Type: mp1.Blue},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: mrcSwapCastleDir},
			{Type: mp1.Blue},
			{Type: mp1.Chance},
			{Type: mp1.Bowser},
			{Type: mp1.Invisible, PassingEvent: mrcVisitCastle},
		},
	},
	Links: &map[int]*[]mp1.ChainSpace{
		0: {mp1.NewChainSpace(1, 0), mp1.NewChainSpace(2, 0)},
		1: {mp1.NewChainSpace(2, 2)},
		2: {mp1.NewChainSpace(3, 0), mp1.NewChainSpace(4, 0)},
		3: {mp1.NewChainSpace(4, 3)},
	},
	Data: mrcBoardData{},
}

MRC holds the data for Mario's Rainbow Castle.

View Source 
var PBC = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Chance},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(0)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(1)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(2)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(3)},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(4)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(5)},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Start},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(6)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(7)},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(8)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(9)},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(10)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(11)},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(12)},
			{Type: mp1.Happening, StoppingEvent: pbcVisitPiranha(13)},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: pbcVisitSeed},
		},
		{
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Chance},
			{Type: mp1.BogusItem},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: pbcVisitSeed},
		},
	},
	Links:       nil,
	BowserCoins: 20,
	Data:        pbcBoardData{},
}

PBC holds the data for Peach's Birthday Cake.

View Source 
var WBC = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Start},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: wbcCannonShot},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: wbcReverseCannons},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: wbcCannonShot},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Boo},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: wbcCannonShot},
		},
		{
			{Type: mp1.Red},
			{Type: mp1.Bowser},
			{Type: mp1.Red},
			{Type: mp1.Red},
			{Type: mp1.Red},
			{Type: mp1.Invisible, PassingEvent: wbcShyGuy},
			{Type: mp1.Red},
			{Type: mp1.Bowser},
			{Type: mp1.Red},
			{Type: mp1.Happening, StoppingEvent: wbcReverseCannons},
			{Type: mp1.Star},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Invisible, PassingEvent: wbcCannonShot},
		},
		{
			{Type: mp1.MinigameSpace},
			{Type: mp1.MinigameSpace},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Star},
			{Type: mp1.MinigameSpace},
			{Type: mp1.MinigameSpace},
			{Type: mp1.MinigameSpace},
			{Type: mp1.BogusItem},
			{Type: mp1.Invisible, PassingEvent: wbcLoadPlayerInBowserCannon},
		},
	},
	Links:       nil,
	BowserCoins: 20,
	Data:        wbcBoardData{},
}

WBC holds the data for Wario's Battle Canyon.

View Source 
var YTI = mp1.Board{
	Chains: &[]mp1.Chain{
		{
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: ytiSwapStarPosition},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Chance},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: ytiSwapStarPosition},
			{Type: mp1.Invisible, PassingEvent: ytiGainStar},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Start},
			{Type: mp1.Happening, StoppingEvent: ytiSwapStarPosition},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: ytiCheckThwomp(0)},
		},
		{
			{Type: mp1.Blue},
			{Type: mp1.Chance},
			{Type: mp1.Mushroom},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: ytiSwapStarPosition},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Blue},
			{Type: mp1.Happening, StoppingEvent: ytiSwapStarPosition},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Bowser},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: ytiGainStar},
			{Type: mp1.Happening, StoppingEvent: ytiSwapStarPosition},
			{Type: mp1.Blue},
			{Type: mp1.MinigameSpace},
			{Type: mp1.Boo},
			{Type: mp1.Blue},
			{Type: mp1.Blue},
			{Type: mp1.Red},
			{Type: mp1.Happening, StoppingEvent: ytiSwapStarPosition},
			{Type: mp1.Blue},
			{Type: mp1.Invisible, PassingEvent: ytiCheckThwomp(1)},
		},
	},
	Links: nil,
	Data: ytiBoardData{
		[2]int{1, 1},
		[2]mp1.ChainSpace{mp1.NewChainSpace(1, 6), mp1.NewChainSpace(0, 7)},
		[2]mp1.ChainSpace{mp1.NewChainSpace(0, 0), mp1.NewChainSpace(1, 0)},
		ytiLeftIslandStar,
	},
}

YTI holds the data for Yoshi's Tropical Island.

Functions

This section is empty.

Types

type BMMBowserRoulette 

type BMMBowserRoulette struct {
	Player int
	Moves  int
}

BMMBowserRoulette decides if bowser steals a star or 20 coins.

func (BMMBowserRoulette) ControllingPlayer 

func (b BMMBowserRoulette) ControllingPlayer() int

func (BMMBowserRoulette) Handle 

func (b BMMBowserRoulette) Handle(r mp1.Response, g *mp1.Game)

Handle executes based on r. If r is true, a star is taken from the player. If r is false, 20 coins is taken from the palyer.

func (BMMBowserRoulette) Question added in v0.0.3 

func (b BMMBowserRoulette) Question(g *mp1.Game) string

func (BMMBowserRoulette) Responses 

func (b BMMBowserRoulette) Responses() []mp1.Response

func (BMMBowserRoulette) Type added in v0.0.3 

func (b BMMBowserRoulette) Type() mp1.EventType

type BMMBowserRouletteResponse added in v0.0.3 

type BMMBowserRouletteResponse int
const (
	BMMBowserRoulette20Coins BMMBowserRouletteResponse = iota
	BMMBowserRouletteStar
)

func (BMMBowserRouletteResponse) String added in v0.0.3 

func (b BMMBowserRouletteResponse) String() string

type BMMBranchDecision 

type BMMBranchDecision struct {
	Player     int
	Moves      int
	BowserPath mp1.ChainSpace
	StarPath   mp1.ChainSpace
}

BMMBranchDecision decides which path the player takes.

func (BMMBranchDecision) ControllingPlayer 

func (b BMMBranchDecision) ControllingPlayer() int

func (BMMBranchDecision) Handle 

func (b BMMBranchDecision) Handle(r mp1.Response, g *mp1.Game)

Handle moves the player to the ChainSpace r.

func (BMMBranchDecision) Question added in v0.0.3 

func (b BMMBranchDecision) Question(g *mp1.Game) string

func (BMMBranchDecision) Responses 

func (b BMMBranchDecision) Responses() []mp1.Response

Responses returns a slice of the 2 paths the player can take.

func (BMMBranchDecision) Type added in v0.0.3 

func (b BMMBranchDecision) Type() mp1.EventType

type BMMBranchPay 

type BMMBranchPay struct {
	Player     int
	Moves      int
	BowserPath mp1.ChainSpace
	StarPath   mp1.ChainSpace
}

BMMBranchPay is a custom branch event for the player to decide if they want to pay 10 coins to take a chance at taking the star path.

func (BMMBranchPay) ControllingPlayer 

func (b BMMBranchPay) ControllingPlayer() int

func (BMMBranchPay) Handle 

func (b BMMBranchPay) Handle(r mp1.Response, g *mp1.Game)

Handle executes based on r. If r is true, the player pays 10 coins to let chance decide which path they take. Otherwise, they take the bowser path.

func (BMMBranchPay) Question added in v0.0.3 

func (b BMMBranchPay) Question(g *mp1.Game) string

func (BMMBranchPay) Responses 

func (b BMMBranchPay) Responses() []mp1.Response

func (BMMBranchPay) Type added in v0.0.3 

func (b BMMBranchPay) Type() mp1.EventType

type BMMBranchPayResponse added in v0.0.3 

type BMMBranchPayResponse int
const (
	BMMBranchPayPay    BMMBranchPayResponse = iota
	BMMBranchPayIgnore BMMBranchPayResponse = iota
)

func (BMMBranchPayResponse) String added in v0.0.3 

func (b BMMBranchPayResponse) String() string

type DKJAWhompEvent 

type DKJAWhompEvent struct {
	Player int
	Moves  int
	Whomp  int
}

DKJAWhompEvent let's the player decide to go and pay the whomp 10 coins or ignore the whomp.

func (DKJAWhompEvent) ControllingPlayer 

func (d DKJAWhompEvent) ControllingPlayer() int

func (DKJAWhompEvent) Handle 

func (d DKJAWhompEvent) Handle(r mp1.Response, g *mp1.Game)

Handle moves the player to the appropriate space and takes coins away based on r. If r is true, then the player loses 10 coins and moves past the whomp. If r is false, then the player moves away from the whomp.

func (DKJAWhompEvent) Question added in v0.0.3 

func (d DKJAWhompEvent) Question(g *mp1.Game) string

func (DKJAWhompEvent) Responses 

func (d DKJAWhompEvent) Responses() []mp1.Response

func (DKJAWhompEvent) Type added in v0.0.3 

func (d DKJAWhompEvent) Type() mp1.EventType

type DKJAWhompResponse added in v0.0.3 

type DKJAWhompResponse int
const (
	DKJAWhompPay DKJAWhompResponse = iota
	DKJAWhompIgnore
)

func (DKJAWhompResponse) String added in v0.0.3 

func (d DKJAWhompResponse) String() string

type ESBattleBabyBowser 

type ESBattleBabyBowser struct {
	Player int
	Moves  int
	Index  int
}

ESBattleBabyBowser decides if the player wins the minigame.

func (ESBattleBabyBowser) ControllingPlayer 

func (e ESBattleBabyBowser) ControllingPlayer() int

func (ESBattleBabyBowser) Handle 

func (e ESBattleBabyBowser) Handle(r mp1.Response, g *mp1.Game)

Handle gives the player a star and sets the baby bowser's StarTaken flag to true if r is true. If r is false, a star is taken from the plaeyr.

func (ESBattleBabyBowser) Question added in v0.0.3 

func (e ESBattleBabyBowser) Question(g *mp1.Game) string

func (ESBattleBabyBowser) Responses 

func (e ESBattleBabyBowser) Responses() []mp1.Response

func (ESBattleBabyBowser) Type added in v0.0.3 

func (e ESBattleBabyBowser) Type() mp1.EventType

type ESBattleBabyBowserResponse added in v0.0.3 

type ESBattleBabyBowserResponse int
const (
	ESBattleBabyBowserWin ESBattleBabyBowserResponse = iota
	ESBattleBabyBowserLose
)

func (ESBattleBabyBowserResponse) String added in v0.0.3 

func (e ESBattleBabyBowserResponse) String() string

type ESBranchEvent 

type ESBranchEvent struct {
	Player int
	Moves  int
	Warp1  mp1.ChainSpace
	Warp2  mp1.ChainSpace
	Warp3  mp1.ChainSpace
}

ESBranchEvent let's the player decide if they want to take the warp.

func (ESBranchEvent) ControllingPlayer 

func (e ESBranchEvent) ControllingPlayer() int

func (ESBranchEvent) Handle 

func (e ESBranchEvent) Handle(r mp1.Response, g *mp1.Game)

Handle executes based on r. If r is true, the player's new position is set based on the current gate (setting the next event to set the gate if the gate is unknown). If r is false, the player continues down their current chain.

func (ESBranchEvent) Question added in v0.0.3 

func (e ESBranchEvent) Question(g *mp1.Game) string

func (ESBranchEvent) Responses 

func (e ESBranchEvent) Responses() []mp1.Response

func (ESBranchEvent) Type added in v0.0.3 

func (e ESBranchEvent) Type() mp1.EventType

type ESBranchResponse added in v0.0.3 

type ESBranchResponse int
const (
	ESBranchGotoWarp ESBranchResponse = iota
	ESBranchContinue
)

func (ESBranchResponse) String added in v0.0.3 

func (e ESBranchResponse) String() string

type ESChangeGates 

type ESChangeGates struct {
	Player  int
	Moves   int
	Current int
}

ESChangeGates decides which Gate the board will change to.

func (ESChangeGates) ControllingPlayer 

func (e ESChangeGates) ControllingPlayer() int

func (ESChangeGates) Handle 

func (e ESChangeGates) Handle(r mp1.Response, g *mp1.Game)

Handle switches the current gate configuration to r, moves the player to the starting space, and moves the player their remaining spaces.

func (ESChangeGates) Question added in v0.0.3 

func (e ESChangeGates) Question(g *mp1.Game) string

func (ESChangeGates) Responses 

func (e ESChangeGates) Responses() []mp1.Response

Responses returns the gates that can be switched to.

func (ESChangeGates) Type added in v0.0.3 

func (e ESChangeGates) Type() mp1.EventType

type ESVisitBabyBowser 

type ESVisitBabyBowser struct {
	Player int
	Moves  int
	Index  int
}

ESVisitBabyBowser let's the player decide if they want to play baby bowser's minigame to win a star.

func (ESVisitBabyBowser) ControllingPlayer 

func (e ESVisitBabyBowser) ControllingPlayer() int

func (ESVisitBabyBowser) Handle 

func (e ESVisitBabyBowser) Handle(r mp1.Response, g *mp1.Game)

Handle sets the next event to the baby bowser minigame if r is true. If r is false, then nothing happens.

func (ESVisitBabyBowser) Question added in v0.0.3 

func (e ESVisitBabyBowser) Question(g *mp1.Game) string

func (ESVisitBabyBowser) Responses 

func (e ESVisitBabyBowser) Responses() []mp1.Response

func (ESVisitBabyBowser) Type added in v0.0.3 

func (e ESVisitBabyBowser) Type() mp1.EventType

type ESVisitBabyBowserResponse added in v0.0.3 

type ESVisitBabyBowserResponse int
const (
	ESVisitBabyBowserPlay ESVisitBabyBowserResponse = iota
	ESVisitBabyBowserIgnore
)

func (ESVisitBabyBowserResponse) String added in v0.0.3 

func (e ESVisitBabyBowserResponse) String() string

type ESWarpCDest 

type ESWarpCDest struct {
	Player int
	Moves  int
}

ESWarpCDest decides which Warp C destination the player goes to.

func (ESWarpCDest) ControllingPlayer 

func (e ESWarpCDest) ControllingPlayer() int

func (ESWarpCDest) Handle 

func (e ESWarpCDest) Handle(r mp1.Response, g *mp1.Game)

Handle moves the player to the ChainSpace r and sets various flags if needed.

func (ESWarpCDest) Question added in v0.0.3 

func (e ESWarpCDest) Question(g *mp1.Game) string

func (ESWarpCDest) Responses 

func (e ESWarpCDest) Responses() []mp1.Response

Resopnses returns a slice of the 2 possible spaces the player can warp to.

func (ESWarpCDest) Type added in v0.0.3 

func (e ESWarpCDest) Type() mp1.EventType

type ESWarpDest 

type ESWarpDest struct {
	Player   int
	Moves    int
	Gate2or3 bool
	Island1  mp1.ChainSpace
	Island2  mp1.ChainSpace
	Island3  mp1.ChainSpace
}

ESWarpDest decides which gate the board is playing under currently.

func (ESWarpDest) ControllingPlayer 

func (e ESWarpDest) ControllingPlayer() int

func (ESWarpDest) Handle 

func (e ESWarpDest) Handle(r mp1.Response, g *mp1.Game)

Handle moves the player to the ChainSpace in r and set's the current gate the board is under in r.

func (ESWarpDest) Question added in v0.0.3 

func (e ESWarpDest) Question(g *mp1.Game) string

func (ESWarpDest) Responses 

func (e ESWarpDest) Responses() []mp1.Response

Responses returns the list of possible ChainSpaces that the player can warp to.

func (ESWarpDest) Type added in v0.0.3 

func (e ESWarpDest) Type() mp1.EventType

type Gate added in v0.0.3 

type Gate int

func (Gate) String added in v0.0.3 

func (g Gate) String() string

type LERRobot 

type LERRobot struct {
	Player int
	Moves  int
}

LERRobot let's the player decide to either pay and raise/lower gates or ignore the robot.

func (LERRobot) ControllingPlayer 

func (l LERRobot) ControllingPlayer() int

func (LERRobot) Handle 

func (l LERRobot) Handle(r mp1.Response, g *mp1.Game)

Handle pays the robot 20 coins and switches the gates only if r is true.

func (LERRobot) Question added in v0.0.3 

func (l LERRobot) Question(g *mp1.Game) string

func (LERRobot) Responses 

func (l LERRobot) Responses() []mp1.Response

func (LERRobot) Type added in v0.0.3 

func (l LERRobot) Type() mp1.EventType

type LERRobotResponse added in v0.0.3 

type LERRobotResponse int
const (
	LERRobotPay LERRobotResponse = iota
	LERRobotIgnore
)

func (LERRobotResponse) String added in v0.0.3 

func (l LERRobotResponse) String() string

type PBCPiranhaDecision 

type PBCPiranhaDecision struct {
	Player  int
	Piranha int
}

piranha.

func (PBCPiranhaDecision) ControllingPlayer 

func (p PBCPiranhaDecision) ControllingPlayer() int

func (PBCPiranhaDecision) Handle 

func (p PBCPiranhaDecision) Handle(r mp1.Response, g *mp1.Game)

Handle performs the decision r. If r is true, then the player pays 30 coins and gains a piranha at their current space. If r is false, nothing happens.

func (PBCPiranhaDecision) Question added in v0.0.3 

func (p PBCPiranhaDecision) Question(g *mp1.Game) string

func (PBCPiranhaDecision) Responses 

func (p PBCPiranhaDecision) Responses() []mp1.Response

func (PBCPiranhaDecision) Type added in v0.0.3 

func (p PBCPiranhaDecision) Type() mp1.EventType

type PBCPiranhaDecisionResponse added in v0.0.3 

type PBCPiranhaDecisionResponse int

PBCPiranhaDecision decides if the player wants to pay 30 coins for a 

const (
	PBCPiranhaDecisionPay PBCPiranhaDecisionResponse = iota
	PBCPiranhaDecisionIgnore
)

func (PBCPiranhaDecisionResponse) String added in v0.0.3 

func (p PBCPiranhaDecisionResponse) String() string

type PBCSeedCheck 

type PBCSeedCheck struct {
	Player int
	Moves  int
}

PBCSeedCheck decides if the player got a toad seed or a bowser seed.

func (PBCSeedCheck) ControllingPlayer 

func (p PBCSeedCheck) ControllingPlayer() int

func (PBCSeedCheck) Handle 

func (p PBCSeedCheck) Handle(r mp1.Response, g *mp1.Game)

Handle moves the player based on r. If r is true, the player moves to the bowser path. If r is false, the player moves to the toad path.

func (PBCSeedCheck) Question added in v0.0.3 

func (p PBCSeedCheck) Question(g *mp1.Game) string

func (PBCSeedCheck) Responses 

func (p PBCSeedCheck) Responses() []mp1.Response

func (PBCSeedCheck) Type added in v0.0.3 

func (p PBCSeedCheck) Type() mp1.EventType

type PBCSeedCheckResponse added in v0.0.3 

type PBCSeedCheckResponse int
const (
	PBCSeedCheckBowser PBCSeedCheckResponse = iota
	PBCSeedCheckToad
)

func (PBCSeedCheckResponse) String added in v0.0.3 

func (p PBCSeedCheckResponse) String() string

type WBCBowserCannon 

type WBCBowserCannon struct {
	Player int
	Moves  int
}

WBCBowserCannon set's the player's new position after visiting Bowser.

func (WBCBowserCannon) ControllingPlayer 

func (w WBCBowserCannon) ControllingPlayer() int

func (WBCBowserCannon) Handle 

func (w WBCBowserCannon) Handle(r mp1.Response, g *mp1.Game)

Handle sets the player's chain to r, and sets the next event to selecting the player's new space.

func (WBCBowserCannon) Question added in v0.0.3 

func (w WBCBowserCannon) Question(g *mp1.Game) string

func (WBCBowserCannon) Responses 

func (w WBCBowserCannon) Responses() []mp1.Response

Responses returns a slice of ints from [0, 4].

func (WBCBowserCannon) Type added in v0.0.3 

func (w WBCBowserCannon) Type() mp1.EventType

type WBCCannon 

type WBCCannon struct {
	Player int
	Moves  int
	Chain  int
}

WBCCannon sets the player's new mp1.ChainSpace.

func (WBCCannon) ControllingPlayer 

func (w WBCCannon) ControllingPlayer() int

func (WBCCannon) Handle 

func (w WBCCannon) Handle(r mp1.Response, g *mp1.Game)

Handle sets the player's new mp1.ChainSpace position.

func (WBCCannon) Question added in v0.0.3 

func (w WBCCannon) Question(g *mp1.Game) string

func (WBCCannon) Responses 

func (w WBCCannon) Responses() []mp1.Response

Responses returns a slice of possible positions the player can land on.

func (WBCCannon) Type added in v0.0.3 

func (w WBCCannon) Type() mp1.EventType

type WBCShyGuyAction 

type WBCShyGuyAction int

WBCShyGuyAction is an enumeration of possible shyguy actions. 

const (
	//WBCNothing represents ignoring the Shy Guy.
	WBCNothing WBCShyGuyAction = iota
	//WBCFlyToBowser takes the player to Bowser.
	WBCFlyToBowser
	//WBCBringPlayer represents the action of moving a player to Shy Guy.
	WBCBringPlayer
)

type WBCShyGuyEvent 

type WBCShyGuyEvent struct {
	Player int
	Moves  int
}

WBCShyGuyEvent let's the player decide on what to do when passing by shyguy.

func (WBCShyGuyEvent) ControllingPlayer 

func (w WBCShyGuyEvent) ControllingPlayer() int

func (WBCShyGuyEvent) Handle 

func (w WBCShyGuyEvent) Handle(r mp1.Response, g *mp1.Game)

Handle executes the response r.

func (WBCShyGuyEvent) Question added in v0.0.3 

func (w WBCShyGuyEvent) Question(g *mp1.Game) string

func (WBCShyGuyEvent) Responses 

func (w WBCShyGuyEvent) Responses() []mp1.Response

Responses returns the available responses a player can take.

func (WBCShyGuyEvent) Type added in v0.0.3 

func (w WBCShyGuyEvent) Type() mp1.EventType

type WBCShyGuyResponse 

type WBCShyGuyResponse struct {
	Action WBCShyGuyAction
	Player int
}

WBCShyGuyResponse is a possible response to the shyguy action.

func (WBCShyGuyResponse) String added in v0.0.3 

func (w WBCShyGuyResponse) String() string

type YTIPayThwompEvent 

type YTIPayThwompEvent struct {
	mp1.PayRangeEvent
	Moves  int
	Thwomp int
}

YTIPayThwompEvent let's the player pay some amount of coins to the thwomp.

func (YTIPayThwompEvent) Handle 

func (y YTIPayThwompEvent) Handle(r mp1.Response, g *mp1.Game)

Handle pays the thwomp r coins, sets the thwomp's new asking price to r+1 movess the player to the Thwomp's accept space, and the player moves their remaining spaces.

func (YTIPayThwompEvent) Question added in v0.0.3 

func (y YTIPayThwompEvent) Question(g *mp1.Game) string

type YTIThwompBranchEvent 

type YTIThwompBranchEvent struct {
	Player int
	Moves  int
	Thwomp int
}

YTIThwompBranchEvent let's the player decide to go and pay the thwomp an amount of coins or ignore the thwomp.

func (YTIThwompBranchEvent) ControllingPlayer 

func (y YTIThwompBranchEvent) ControllingPlayer() int

func (YTIThwompBranchEvent) Handle 

func (y YTIThwompBranchEvent) Handle(r mp1.Response, g *mp1.Game)

Handle calculates the next action based on r. If r is true, then the game's next event is set to pay the thwomp. If r is false, then the player moves to the Thwomp's rejection space and move their remaining spaces.

func (YTIThwompBranchEvent) Question added in v0.0.3 

func (y YTIThwompBranchEvent) Question(g *mp1.Game) string

func (YTIThwompBranchEvent) Responses 

func (y YTIThwompBranchEvent) Responses() []mp1.Response

func (YTIThwompBranchEvent) Type added in v0.0.3 

func (y YTIThwompBranchEvent) Type() mp1.EventType

type YTIThwompBranchResponse added in v0.0.3 

type YTIThwompBranchResponse int
const (
	YTIThwompBranchPay YTIThwompBranchResponse = iota
	YTIThwompBranchIgnore
)

func (YTIThwompBranchResponse) String added in v0.0.3 

func (y YTIThwompBranchResponse) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.