mainstub.go

package main

import (
	tg "fahrradwurstmond2.0/telnet_gui"
	"fmt"
	"log"
	"net"
	"sync"
	"time"
	"math/rand"
)

type globalState struct {
	lock    *sync.Mutex
	players map[string]*Player
}

func (gs *globalState) Lock() {
	gs.lock.Lock()
}

func (gs *globalState) Unlock() {
	gs.lock.Unlock()
}

var (
	gs *globalState
)

type FakeConn struct{}

func (conn *FakeConn) Write(p []byte) (int, error) {
	return len(p), nil
}

func (conn *FakeConn) Read(p []byte) (int, error) {
	return 0, nil
}
func (conn *FakeConn) Close() error {
	return nil
}

func (conn *FakeConn) LocalAddr() net.Addr {
	return nil
}

func (conn *FakeConn) RemoteAddr() net.Addr {
	return nil
}

func (conn *FakeConn) SetDeadline(t time.Time) error {
	return nil
}

func (conn *FakeConn) SetReadDeadline(t time.Time) error {
	return nil
}

func (conn *FakeConn) SetWriteDeadline(t time.Time) error {
	return nil
}

func fakeInputLoop(kill chan struct{}) {
	<-kill
}

func fakeWindowSizeLoop(kill chan struct{}) {
	<-kill
	<-kill
}

func main() {
	var err error
	rand.Seed(time.Now().UnixNano())
	InitBoard()
	gs = &globalState{}
	gs.lock = &sync.Mutex{}
	gs.players = make(map[string]*Player)
	gs.players["ceddral"] = &Player{
		conn:       &FakeConn{},
		connClosed: make(chan struct{}, 1),
		tnState:    NewTelnetState(),
		inputEvent: make(chan []byte, 50),
		inputKill:  make(chan struct{}, 0),
		windowSizeLoopKill:  make(chan struct{}, 0),
		name:       "ceddral",
		context:    nil,
		scr:        tg.NewScreen(&FakeConn{}, 80, 24, tg.ColorDefault, tg.ColorDefault),
	}
	gs.players["ceddral"].connClosed<-struct{}{}
	go fakeInputLoop(gs.players["ceddral"].inputKill)
	go gs.players["ceddral"].windowSizeLoop()
	gs.players["since"] = &Player{
		conn:       &FakeConn{},
		connClosed: make(chan struct{}, 1),
		tnState:    NewTelnetState(),
		inputEvent: make(chan []byte, 50),
		inputKill:  make(chan struct{}, 0),
		windowSizeLoopKill:  make(chan struct{}, 0),
		name:       "since",
		context:    nil,
		scr:        tg.NewScreen(&FakeConn{}, 80, 24, tg.ColorDefault, tg.ColorDefault),
	}
	gs.players["since"].connClosed<-struct{}{}
	go fakeInputLoop(gs.players["since"].inputKill)
	go gs.players["since"].windowSizeLoop()
	NewGame([]string{"since", "ceddral"}, []string{"base", "ext1"})

	if err != nil {
		panic(err)
	}
	stubPlayerConnectLoop(2323)
}

func stubPlayerConnectLoop(port int) {
	ln, err := net.Listen("tcp", ":"+fmt.Sprintf("%d", port))
	if err != nil {
		log.Fatal(err)
	}
	log.Println("Server started")
	for {
		conn, err := ln.Accept()
		if err != nil {
			log.Println(err)
			continue
		}
		go func() {
			gs.Lock()
			defer gs.Unlock()
			p := NewPlayer(conn)
			if p == nil {
				return
			}
			p.context.Register(p)
		}()
	}
}