kunt

hangman.go (6093B)

---

 // Copyright 2013 TLH and dsp. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package games
 
 import (
 	"bytes"
 	"fmt"
 	"irc"
 	"strings"
 	"time"
 )
 
 // Just a function with a gamestate pointer as input
 type hgstateFn func(*hangmanState)
 
 // Specific state for hangman game
 type hangmanState struct {
 	gameState
 	lives    uint            // Lives remaining
 	tried    string          // Tried characters
 	goal     string          // Goal word
 	foundnow string          // Found now chars (_ if not found)
 	botname  string          // Name of irc bot for privmsg
 	channame string          // Name of invoking chan for privmsg
 	statchan *chan hgstateFn // Channel of next game state
 }
 
 // Creates a new hangman state with default values
 func newHangmanState(ic *irc.Context, gc *chan irc.Message, sc *chan hgstateFn) *hangmanState {
 	return &hangmanState{gameState{ic, gc, "hangman", "dsp"},
 		5, "", "", "", "unnamed", "", sc}
 }
 
 // For printf style functions, a short status of the game state
 func (s *hangmanState) String() string {
 	return fmt.Sprintf(">>[%s]<< lives: %d - tried: [%s]", s.foundnow, s.lives, s.tried)
 }
 
 // First hangman state. Awaits on the game chan for 2 special irc messages to set the nickname
 // of the bot and the channel on which to send msgs. Then it emits the next state (hangmanWaitGoal)
 // to the state channel.
 func hangmanInit(cs *hangmanState) {
 	for msg := range *cs.gchan {
 		if msg.Command == "SETNICK" {
 			cs.botname = msg.Args[0]
 		}
 		if msg.Command == "SETCHAN" {
 			cs.channame = msg.Args[0]
 		}
 		if cs.botname != "" && cs.channame != "" {
 			break
 		}
 	}
 	*cs.statchan <- hangmanWaitGoal
 }
 
 // Second hangman state. It waits on a private query for the goal and then emits the next state (hangmanMainLoop)
 // to the state channel.
 func hangmanWaitGoal(cs *hangmanState) {
 	cs.ictx.Privmsg(cs.channame, "Hangman is waiting for goal. When ready use hangman <letter|possibleword>.")
 	for msg := range *cs.gchan {
 		if len(msg.Args) < 2 {
 			continue
 		}
 		msg.Args[1] = strings.TrimSpace(msg.Args[1])
 		if msg.Args[0] == cs.botname {
 			if strings.HasPrefix(msg.Args[1], "setgoal ") {
 				cs.goal = msg.Args[1][8:]
 				who := msg.Nick
 				cs.ictx.Privmsg(who, "Goal is now set to: "+cs.goal)
 				runes := make([]rune, len(cs.goal))
 				for i := 0; i < len(runes); i++ {
 					runes[i] = '_'
 				}
 				cs.foundnow = string(runes)
 				break
 			} else {
 				who := msg.Nick
 				cs.ictx.Privmsg(who, "Now we are playing hangman. Use setgoal <WORD>")
 			}
 		} else {
 			if strings.HasPrefix(msg.Args[1], "hangman ") {
 				cs.ictx.Privmsg(msg.Args[0], "Still waiting for goal...")
 			}
 		}
 	}
 	*cs.statchan <- hangmanMainLoop
 }
 
 // Third hangman state. It waits for hangman prefixed messages on the game channel. If a word is provided
 // and it doesn't match the goal it reduces lives and continues. If it matches the game is won.
 // If a character is provided, it checks on the tried characters and if it is in it continues without losing.
 // If it is not in the tried characters , checks for it with checkLetter(this updates the tried characters)
 // and reprints the game state. At each loop if foundNow matches the goal the game is won.
 // Then it emits the final state (hangmanEnd) to the state channel.
 func hangmanMainLoop(cs *hangmanState) {
 	cs.ictx.Privmsg(cs.channame, cs.String())
 	for msg := range *cs.gchan {
 		if len(msg.Args) < 2 { //this was a bug when kunt was getting NICK xxxx Args[1] was  nil
 			continue
 		}
 		msg.Args[1] = strings.TrimSpace(msg.Args[1])
 		if msg.Args[0] != cs.botname {
 			if cs.lives < 1 {
 				cs.ictx.Privmsg(msg.Args[0], "You are hanged! Goal was ->"+cs.goal)
 				*cs.statchan <- hangmanEnd
 			}
 			if strings.HasPrefix(msg.Args[1], "hangman") {
 				in := msg.Args[1][8:]
 				if len(in) > 1 {
 					if in == cs.goal {
 						cs.ictx.Privmsg(msg.Args[0], "You won!")
 						*cs.statchan <- hangmanEnd
 					} else {
 						cs.ictx.Privmsg(msg.Args[0], "You lost a life punk...")
 						cs.lives--
 						cs.ictx.Privmsg(msg.Args[0], cs.String())
 						continue
 					}
 				} else {
 					if strings.Index(cs.tried, string(in[0])) != -1 {
 						cs.ictx.Privmsg(msg.Args[0], "I heard you the first time")
 						continue
 					}
 					hm := cs.checkLetter([]rune(in)[0])
 					cs.ictx.Privmsg(msg.Args[0], fmt.Sprintf("You got %d letters", hm))
 					if hm == 0 {
 						cs.lives--
 					}
 					cs.ictx.Privmsg(msg.Args[0], cs.String())
 					if cs.foundnow == cs.goal {
 						cs.ictx.Privmsg(msg.Args[0], "You won!")
 						*cs.statchan <- hangmanEnd
 					}
 				}
 			}
 		}
 	}
 }
 
 // Fourth hangman state. Final state mostly for cleanup code.
 func hangmanEnd(cs *hangmanState) {
 	*cs.statchan <- nil
 }
 
 // Main hangman dispatch, It sets a timeout and then runs as a new goroutine each
 // consecutive state it receives on the statechannel. Before ending it removes
 // the irc Intercept channel for this game.
 func cmdHangman(a *irc.Context, gc *chan irc.Message) {
 	timeout := time.After(4 * time.Minute)
 	a.AddIntercept(gc)
 	stchan := make(chan hgstateFn, 1)
 	hc := newHangmanState(a, gc, &stchan)
 	stchan <- hangmanInit
 	for {
 		select {
 		case <-timeout:
 			if hc.goal == "" {
 				a.Privmsg(hc.channame, "Time is up! No goal was given")
 			} else {
 				a.Privmsg(hc.channame, "Time is up! Goal was -> "+hc.goal)
 			}
 			a.DelIntercept(gc)
 			close(stchan)
 			return
 		case st := <-stchan:
 			if st != nil {
 				go st(hc)
 				continue
 			} else {
 				break
 			}
 		}
 		break
 	}
 	a.DelIntercept(gc)
 	close(stchan)
 }
 
 // Checks letter against the goal.
 // Returns the number of new letters discovered.
 // Returns -1 if repeated check is detected.
 func (g *hangmanState) checkLetter(c rune) int {
 	now := []rune(g.foundnow)
 	all := []rune(g.goal)
 	var buf bytes.Buffer
 	for _, v := range g.tried {
 		if c == v {
 			return -1
 		}
 	}
 	buf.WriteString(g.tried + " " + string(c))
 	g.tried = buf.String()
 	hm := 0
 	for i, v := range all {
 		if v == c {
 			if now[i] == v {
 				return -1
 			} /* again */
 			now[i] = v
 			hm++
 		}
 	}
 	g.foundnow = string(now)
 	return hm
 }