player.go

package main

import (
	tg "fahrradwurstmond2.0/telnet_gui"
	"log"
	"net"
	"os"
	"time"
	"fmt"
	"regexp"
	//"errors"
)

const (
	nameMaxLen = 16
	nameWhitelistChars = "a-zA-Z0-9_"
)

var (
	nameWhitelist = regexp.MustCompile("[^"+nameWhitelistChars+"]")
)

type Context interface {
	Register(*Player)
	Unregister(string)
	Resize(int, int, *Player)
	Redraw(*Player)
	Lock()
	Unlock()
}

type Player struct {
	tnState    *TelnetState
	conn       net.Conn
	connClosed chan struct{}
	inputEvent chan []byte
	inputKill  chan struct{}
	windowSizeLoopKill  chan struct{}
	name       string
	context    Context
	scr        *tg.Screen
}

func NewPlayer(conn net.Conn) (p *Player) {
	tcpConn := conn.(*net.TCPConn)
	tcpConn.SetKeepAlivePeriod(time.Second)
	tcpConn.SetKeepAlive(true)
	var err error
	p = &Player{
		conn:       conn,
		tnState:    NewTelnetState(),
		inputEvent: make(chan []byte, 50),
		inputKill:  make(chan struct{}),
	}
	go p.inputLoop()
	p.name, err = queryUsername(p.conn, p.tnState)
	if err != nil {
		log.Println(err)
	}
	reason := ""
	if len(p.name) == 0 {
		reason = "Must set username. `telnet -l <name>`\n"
	} else if len(p.name) > nameMaxLen {
		reason = fmt.Sprintf("Username must contain at most %d characters.\n", nameMaxLen)
	} else if len(nameWhitelist.ReplaceAllString(p.name, "")) != len(p.name) {
		reason = fmt.Sprintf("Username must consist only of %s\n", nameWhitelistChars)
	}
	if reason != "" {
		p.inputKill <- struct{}{}
		close(p.inputKill)
		close(p.inputEvent)
		conn.Write([]byte(reason))
		conn.Close()
		return nil
	}

	if pOld, ok := gs.players[p.name]; ok {
		// reconnect with replace
		pNew := p
		// check if old player is still responsive
		select {
		case <-pOld.connClosed:
			// continue
		default:
			// old player is responsive, disconnect imposter
			pNew.inputKill <- struct{}{}
			close(pNew.inputKill)
			close(pNew.inputEvent)
			conn.Write([]byte(fmt.Sprintf("Username %s already taken\n", pNew.name)))
			conn.Close()
			log.Printf("%s tried to connect twice", p.name)
			return nil
		}

		// kill old player components to be replaced
		pOld.inputKill <- struct{}{}
		pOld.conn.Close()

		// clean up new player input, was only needed to query username
		pNew.inputKill <- struct{}{}
		close(pNew.inputKill)
		close(pNew.inputEvent)

		// assemble reconnected player
		p = pOld
		// no inputLoop for pOld and pNew may be running during these modifications to p
		p.conn = pNew.conn
		p.scr.Chown(conn)
		go p.inputLoop()
		log.Printf("%s reconnected\n", p.name)
	} else {
		p.windowSizeLoopKill = make(chan struct{})
		p.connClosed = make(chan struct{}, 1)
		// TODO new players need to be sent to the meta lobby context
		p.context = glgl
		p.scr = tg.NewScreenEmpty(conn, tg.ColorDefault, tg.ColorDefault)
		go p.windowSizeLoop()
		gs.players[p.name] = p
		log.Printf("%s connected\n", p.name)
	}
	err = p.scr.Redraw()
	if err != nil {
		log.Println(err)
	}
	return p
}

func (p *Player) Close() {
	// do not wait for inputLoop termination (inputKill <- struct{}{})
	// as Close is and must be only called from within inputLoop
	close(p.inputKill)
	p.conn.Close()
	p.windowSizeLoopKill <- struct{}{}
	p.windowSizeLoopKill <- struct{}{}
	close(p.connClosed)
	close(p.inputEvent)
	close(p.windowSizeLoopKill)
	delete(gs.players, p.name)
	log.Printf("%s disconnected\n", p.name)
}

func StopTimer(t *time.Timer) {
	if !t.Stop() {
		select {
		case <-t.C:
		default:
		}
	}
}

func (p *Player) inputLoop() {
	key := make([]byte, 0, 3)
	p.conn.SetReadDeadline(time.Now().Add(time.Second))
	for {
		select {
		// kill loop without closing connection in case of reconnect
		case <-p.inputKill:
			return
		default:
		}

		if 0 == len(key) {
			p.conn.SetReadDeadline(time.Now().Add(time.Second))
		}
		b, err := readByteTelnet(p.conn, p.tnState)
		if err != nil {
			if os.IsTimeout(err) { //errors.Is(err, os.ErrDeadlineExceeded) {
				if 0 < len(key) {
					goto out
				}
				continue
			}
			p.connClosed <- struct{}{}
			gs.Lock()
			p.context.Unregister(p.name)
			gs.Unlock()
			// await termination, to unblock a reconnect
			<-p.inputKill
			return
		}
		key = append(key, b)
		if b == 27 { // ESC
			p.conn.SetReadDeadline(time.Now().Add(connectionConfig.ANSIEscapeTimeout * time.Millisecond))
			continue
		}
		if 1 < len(key) {
			continue
		}
	out:
		if toKey(key) != keyNull {
			select {
			case p.inputEvent <- key:
			default:
				// discard inputs if they come too fast
			}
		}
		key = make([]byte, 0, 3)
	}
}

func (p *Player) windowSizeLoop() {
	p.tnState.Lock()
	defer func() {
		p.tnState.Unlock()
		<-p.windowSizeLoopKill
	}()
	for {
		select {
		case <-p.windowSizeLoopKill:
			return
		default:
		}
		timeoutChan := cond_set_timeout(p.tnState.lock, p.tnState.cond, time.Second)
		pthread_cond_timedwait_because_fuck_you(p.tnState.cond, timeoutChan)
		w := p.tnState.windowWidth
		h := p.tnState.windowHeight
		if p.scr.W == w && p.scr.H == h {
			continue
		}
		gs.Lock()
		p.context.Lock()
		p.scr.Resize(w, h)
		p.context.Resize(w, h, p)
		p.context.Redraw(p)
		p.context.Unlock()
		gs.Unlock()
	}
}