dame

Documentation

Index

• Variables
• func NewFreierModusScreen(herderLegacy herderlegacy.HerderLegacy, ...) herderlegacy.Screen
• func NewLehrerDameSpielScreen(herderLegacy herderlegacy.HerderLegacy, ...) herderlegacy.Screen
• type Brett
  • func MustParseBrett(zeilen ...string) Brett
  • func ParseBrett(zeilen ...string) (Brett, error)
  • func (b Brett) MinimaxBewertung(perspektive minimax.Spieler, aiRegeln minimax.Regeln) int
  • func (b Brett) MinimaxMöglicheZüge(perspektive minimax.Spieler, aiRegeln minimax.Regeln) []minimax.Zug
  • func (b Brett) String() string
• type Richtung
• type RichtungHorizontal
• type RichtungVertikal
• type Richtungen
• type SpielOptionen
• type ZugRegeln

Variables

var (
	InternationaleZugRegeln = ZugRegeln{
		SteinBewegenRichtungen:                RichtungenDiagonalVorne,
		SteinSchlagenRichtungenAnfang:         RichtungenDiagonalVorne,
		SteinSchlagenRichtungenWeiterschlagen: RichtungenDiagonal,

		DameBewegenRichtungen:                RichtungenDiagonal,
		DameSchlagenRichtungenAnfang:         RichtungenDiagonal,
		DameSchlagenRichtungenWeiterschlagen: RichtungenDiagonal,

		SchlagZwang: true,
	}
	AltdeutscheZugRegeln = ZugRegeln{
		SteinBewegenRichtungen:                RichtungenDiagonalVorne,
		SteinSchlagenRichtungenAnfang:         RichtungenSeiteDiagonalUndVorne,
		SteinSchlagenRichtungenWeiterschlagen: RichtungenSeiteDiagonalUndVorne,

		DameBewegenRichtungen:                RichtungenAlle,
		DameSchlagenRichtungenAnfang:         RichtungenAlle,
		DameSchlagenRichtungenWeiterschlagen: RichtungenAlle,

		SchlagZwang: true,
	}
)

var (
	RichtungVorneLinks = Richtung{
		Horizontal: RichtungHorizontalLinks,
		Vertikal:   RichtungVertikalVorne,
	}
	RichtungVorne = Richtung{
		Horizontal: RichtungHorizontalKeine,
		Vertikal:   RichtungVertikalVorne,
	}
	RichtungVorneRechts = Richtung{
		Horizontal: RichtungHorizontalRechts,
		Vertikal:   RichtungVertikalVorne,
	}
	RichtungLinks = Richtung{
		Horizontal: RichtungHorizontalLinks,
		Vertikal:   RichtungVertikalKeine,
	}
	RichtungRechts = Richtung{
		Horizontal: RichtungHorizontalRechts,
		Vertikal:   RichtungVertikalKeine,
	}
	RichtungHintenLinks = Richtung{
		Horizontal: RichtungHorizontalLinks,
		Vertikal:   RichtungVertikalHinten,
	}
	RichtungHinten = Richtung{
		Horizontal: RichtungHorizontalKeine,
		Vertikal:   RichtungVertikalHinten,
	}
	RichtungHintenRechts = Richtung{
		Horizontal: RichtungHorizontalRechts,
		Vertikal:   RichtungVertikalHinten,
	}
)

var (
	RichtungenDiagonalVorne = Richtungen{
		RichtungVorneLinks:  {},
		RichtungVorneRechts: {},
	}
	RichtungenDiagonal = Richtungen{
		RichtungVorneLinks:   {},
		RichtungVorneRechts:  {},
		RichtungHintenLinks:  {},
		RichtungHintenRechts: {},
	}
	RichtungenSeiteDiagonalUndVorne = Richtungen{
		RichtungVorneLinks:  {},
		RichtungVorne:       {},
		RichtungVorneRechts: {},
		RichtungLinks:       {},
		RichtungRechts:      {},
	}
	RichtungenAlle = Richtungen{
		RichtungVorneLinks:   {},
		RichtungVorne:        {},
		RichtungVorneRechts:  {},
		RichtungLinks:        {},
		RichtungRechts:       {},
		RichtungHintenLinks:  {},
		RichtungHinten:       {},
		RichtungHintenRechts: {},
	}
)

Functions

func NewFreierModusScreen

func NewFreierModusScreen(herderLegacy herderlegacy.HerderLegacy, dameBeendenCallback func() herderlegacy.Screen) herderlegacy.Screen

func NewLehrerDameSpielScreen

func NewLehrerDameSpielScreen(
	herderLegacy herderlegacy.HerderLegacy,
	nächsterScreen func(gewonnen bool) herderlegacy.Screen,
	optionen SpielOptionen,
) herderlegacy.Screen

Types

type Brett

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

func MustParseBrett

func MustParseBrett(zeilen ...string) Brett

func ParseBrett

func ParseBrett(zeilen ...string) (Brett, error)

func (Brett) MinimaxBewertung

func (b Brett) MinimaxBewertung(perspektive minimax.Spieler, aiRegeln minimax.Regeln) int

func (Brett) MinimaxMöglicheZüge

func (b Brett) MinimaxMöglicheZüge(perspektive minimax.Spieler, aiRegeln minimax.Regeln) []minimax.Zug

func (Brett) String

func (b Brett) String() string

type Richtung

type Richtung struct {
	Horizontal RichtungHorizontal
	Vertikal   RichtungVertikal
}

type RichtungHorizontal

type RichtungHorizontal byte

const (
	RichtungHorizontalLinks RichtungHorizontal = iota
	RichtungHorizontalKeine
	RichtungHorizontalRechts
)

type RichtungVertikal

type RichtungVertikal byte

const (
	RichtungVertikalVorne RichtungVertikal = iota
	RichtungVertikalKeine
	RichtungVertikalHinten
)

type Richtungen

type Richtungen map[Richtung]struct{}

type SpielOptionen

type SpielOptionen struct {
	StartBrett Brett
	AiTiefe    int
	ZugRegeln  ZugRegeln
}

type ZugRegeln

type ZugRegeln struct {
	SteinBewegenRichtungen                Richtungen
	SteinSchlagenRichtungenAnfang         Richtungen
	SteinSchlagenRichtungenWeiterschlagen Richtungen

	DameBewegenRichtungen                Richtungen
	DameSchlagenRichtungenAnfang         Richtungen
	DameSchlagenRichtungenWeiterschlagen Richtungen

	SchlagZwang bool
}