Esempio n. 1
0
func (tp *termPlayer) routine() {
	me := -1
	for {
		line := <-tp.stdin.c
		tp.stdin.finalizeWrite()
		fmt.Printf("The name of the game is: %v\n", line)

		hand_line := <-tp.stdin.c
		tp.stdin.finalizeWrite()
		hand := util.Hand(strings.Fields(hand_line))
		hand.Sort()

		for i := 0; i < 13; i++ {
			fmt.Printf("\n")
			before_line := <-tp.stdin.c
			fmt.Printf("Played before you this trick: %v", before_line)
			before := strings.Fields(before_line)
			if me == -1 {
				me = len(before)
			}

			fmt.Printf("Play a card from your hand: %v\n", hand)
			var card string
			fmt.Scanf("%s", &card)
			hand.Remove(card)
			tp.stdout.base.WriteString(fmt.Sprintf("%s\n", card))

			tp.stdin.finalizeWrite()
			after_line := <-tp.stdin.c
			tp.stdin.finalizeWrite()
			fmt.Printf("Played after you this trick: %v", after_line)
			after := strings.Fields(after_line)

			var all []string
			for _, c := range before {
				all = append(all, c)
			}
			all = append(all, card)
			for _, c := range after {
				all = append(all, c)
			}
			lead := all[0][1]
			max := -1
			index := -1
			for i := range all {
				if all[i][1] != lead {
					continue
				}
				if rank_map[all[i][0]] > max {
					max = rank_map[all[i][0]]
					index = i
				}
			}
			player := (me - len(before) + index) % 4
			fmt.Printf("Player %d won the trick with %s\n", player, all[index])
		}
	}
}
Esempio n. 2
0
func makeRavage(players []Player, hands [][]string) BarbuGame {
	var r Ravage
	r.StandardDoubling.Players = players[:]
	r.StandardTrickTaking.Players = players[:]
	for _, hand := range hands {
		r.StandardTrickTaking.Hands = append(r.StandardTrickTaking.Hands, util.Hand(hand))
	}
	return &r
}
Esempio n. 3
0
func (tp *netPlayer) routine() {
	me := -1
	for {
		line := <-tp.stdin.c
		tp.stdin.finalizeWrite()
		_, err := tp.conn.Write([]byte(line))
		if err != nil {
			panic(err)
		}

		hand_line := <-tp.stdin.c
		tp.stdin.finalizeWrite()
		hand := util.Hand(strings.Fields(hand_line))
		hand.Sort()
		_, err = tp.conn.Write([]byte(hand_line))
		if err != nil {
			panic(err)
		}

		for i := 0; i < 13; i++ {
			fmt.Printf("\n")
			before_line := <-tp.stdin.c
			_, err = tp.conn.Write([]byte(before_line))
			if err != nil {
				panic(err)
			}
			before := strings.Fields(before_line)
			if me == -1 {
				me = len(before)
			}

			card_bytes := make([]byte, 2)
			_, err = tp.conn.Read(card_bytes)
			if err != nil {
				panic(err)
			}
			card := string(card_bytes)
			hand.Remove(card)
			tp.stdout.base.WriteString(card)

			tp.stdin.finalizeWrite()
			after_line := <-tp.stdin.c
			tp.stdin.finalizeWrite()

			_, err = tp.conn.Write([]byte(after_line))
			if err != nil {
				panic(err)
			}
		}
	}
}
Esempio n. 4
0
func makeBarbu(players []Player, hands [][]string) BarbuGame {
	var lt Barbu
	lt.StandardDoubling.Players = players[:]
	lt.StandardTrickTaking.Players = players[:]
	for _, hand := range hands {
		lt.StandardTrickTaking.Hands = append(lt.StandardTrickTaking.Hands, util.Hand(hand))
	}
	lt.End_early = func(tricks []Trick) bool {
		for _, card := range tricks[len(tricks)-1].Cards {
			if card == "kh" {
				return true
			}
		}
		return false
	}
	return &lt
}
Esempio n. 5
0
func makeKillerQueens(players []Player, hands [][]string) BarbuGame {
	var kq KillerQueens
	kq.StandardDoubling.Players = players[:]
	kq.StandardTrickTaking.Players = players[:]
	for _, hand := range hands {
		kq.StandardTrickTaking.Hands = append(kq.StandardTrickTaking.Hands, util.Hand(hand))
	}
	kq.End_early = func(tricks []Trick) bool {
		count := 0
		for _, trick := range tricks {
			for _, card := range trick.Cards {
				if card[0] == 'q' {
					count++
				}
			}
		}
		return count == 4
	}
	return &kq
}
Esempio n. 6
0
func interactiveMode(conn net.Conn) {
	buf := bufio.NewReader(conn)
	stdin := bufio.NewReader(os.Stdin)
	var hand util.Hand
	for {
		// Read in what seat you are
		line, err := buf.ReadString('\n')
		if err != nil {
			if err == io.EOF {
				return
			}
			panic(err)
		}
		line = strings.TrimSpace(line)
		fmt.Printf("You are: %s\n", line)

		// Read in your hand
		line, err = buf.ReadString('\n')
		hand = util.Hand(strings.Fields(line))
		hand.Sort()
		fmt.Printf("Your hand is: %s\n", hand)

		// Read in the game
		line, err = buf.ReadString('\n')
		line = strings.TrimSpace(line)
		fmt.Printf("The game is: %s\n", line)
		// TODO: Need to support non-trick-taking games

		// Read in 'DOUBLING', then all of the doubling info
		line, err = buf.ReadString('\n')
		line = strings.TrimSpace(line)
		fmt.Printf("READ DOUBLING: %s\n", line)
		for i := 0; i < 4; i++ {
			fmt.Printf("Reading ... ")
			line, err = buf.ReadString('\n')
			fmt.Printf(" Read: '%s'\n", line)
			line = strings.TrimSpace(line)
			if line == "DOUBLE" {
				fmt.Printf("Time to double!\n")
				line, err = stdin.ReadString('\n')
				_, err = conn.Write([]byte(line))
			} else {
				fmt.Printf("DOUBLING INFO: %s\n", line)
			}
		}

		for {
			line, err = buf.ReadString('\n')
			line = strings.TrimSpace(line)
			if line != "TRICK" {
				break
			}

			fmt.Printf("\nYour hand: %v\n", hand)
			for i := 0; i < 4; i++ {
				line, err = buf.ReadString('\n')
				line = strings.TrimSpace(line)
				if line == "PLAY" {
					fmt.Printf("Your turn: ")
					line, err = stdin.ReadString('\n')
					_, err = conn.Write([]byte(line))
					hand.Remove(strings.TrimSpace(line))
				} else {
					fmt.Printf("TRICK INFO: %s\n", line)
				}
			}
		}
		fmt.Printf("END: %s\n", line)
	}
}
Esempio n. 7
0
func main() {
	flag.Parse()

	if !(*player >= 0 && *player <= 3) {
		fmt.Printf("player must be in [0, 3].\n")
		return
	}

	raddr, err := net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", *ip, 5200+*player))
	if err != nil {
		fmt.Printf("Unable to resolve tcp addr: %v\n", err)
		return
	}

	conn, err := net.DialTCP("tcp", nil, raddr)
	if err != nil {
		fmt.Printf("Unable to dial host: %v\n", err)
		return
	}
	read := bufio.NewReader(conn)

	for {
		line, _, err := read.ReadLine()
		if err != nil {
			panic(err)
		}
		fmt.Printf("Game is %s\n", string(line))

		line, _, err = read.ReadLine()
		if err != nil {
			panic(err)
		}
		hand := util.Hand(strings.Fields(string(line)))

		for i := 0; i < 13; i++ {
			hand.Sort()
			fmt.Printf("Hand is %v\n", hand)
			fmt.Printf("\n")

			line, _, err = read.ReadLine()
			if err != nil {
				panic(err)
			}
			fmt.Printf("Played before you this round: %s\n", string(line))

			var card string
			fmt.Scanf("%s", &card)
			hand.Remove(card)
			_, err = conn.Write([]byte(card))
			if err != nil {
				panic(err)
			}

			line, _, err = read.ReadLine()
			if err != nil {
				panic(err)
			}
			fmt.Printf("Played after you this round: %s\n", string(line))

			fmt.Printf("\n\n")
		}
	}
}