示例#1
0
func Main() {
	porterIPString := flag.String("porterIP", "127.0.0.1", "Porter Server IP")
	porterPortString := flag.String("porterPort", ":5269", "Porter Server Port")
	portstring := flag.String("port", ":8888", "Server port")
	tcpportstring := flag.String("tcpport", ":11199", "TCP socket port")
	logpath := flag.String("logpath", "/dev/stderr", "Logging location")
	flag.Parse()

	port = PortMgmt.NewPortInfo(*portstring)
	tcpPort = PortMgmt.NewPortInfo(*tcpportstring)
	porterPort = PortMgmt.NewPortInfo(*porterPortString)
	porterIP = PortMgmt.IPString(*porterIPString)

	logger.SetupLoggerHelper(*logpath)

	if !verifyEnvironment() {
		logger.Fatalf("Please set $ROOTIQUE to your project root")
	}
	setupGamehub()

	go gamehub.handleConnections()

	go socketListen(tcpPort.Port)
	logger.Debugf("Socket listening on port %s", tcpPort)

	http.HandleFunc("/ws", serveWs)

	logger.Debugf("Http server listening on port %s", port)
	err := http.ListenAndServe(port.Port, nil)
	if err != nil {
		logger.Fatalf("ListenAndServe: %s", err.Error())
	}
}
示例#2
0
文件: proxy.go 项目: Tactique/proxy
func (pc *clientConnection) wsReadPump() {
	defer func() {
		pc.conn.Close()
	}()
	for {
		msg, err := pc.conn.Read()
		if err != nil {
			if err == io.EOF || err == io.ErrUnexpectedEOF {
				// the client ID here is redundant...
				kc := killClient{pc.info.id}
				killcconn := CommandMarshal("killClient", kc)
				pc.currentHandler.handleWebsocket([]byte(killcconn), pc)
			} else {
				logger.Errorf("Error while reading from websocket: %s", err)
			}
			break
		}
		logger.Debugf("Received %s from websocket", msg)
		select {
		case newHandler := <-pc.handlers:
			pc.currentHandler = newHandler
		default:
		}
		pc.currentHandler.handleWebsocket(msg, pc)
	}
}
示例#3
0
func generateResponse(payload interface{}, status int) []byte {
	response, err := json.Marshal(api.ResponseType{Status: status, Payload: payload})
	if err != nil {
		logger.Warnf("Could not generate response: %s", err.Error())
		backupResponse, err := json.Marshal(api.ResponseType{
			Status:  api.STATUS_UNSERIALIZEABLE_RESPONSE,
			Payload: "problem"})
		if err != nil {
			return []byte("Really bad")
		}
		logger.Infof("Generating response with status %d", status)
		logger.Debugf("Full message %s", string(response))
		return backupResponse
	}
	logger.Infof("Generating response with status %d", status)
	logger.Debugf("Full message %s", string(response))
	return response
}
示例#4
0
文件: proxy.go 项目: Tactique/proxy
func (pc *clientConnection) wsWritePump() {
	for msg := range pc.toClient {
		logger.Debugf("Writing %s to websocket", msg)
		err := pc.conn.Write(msg)
		if err != nil {
			logger.Errorf("Error while writing to websocket: %s", err)
			break
		}
	}
}
示例#5
0
func handleConnection(netConn net.Conn) error {
	conn := connection.NewSocketConn(netConn)
	handler := request_handler.NewRequestHandler()
	for {
		logger.Infof("Handling a connection")
		request, err := conn.Read()
		if err != nil {
			logger.Warnf("Error reading request (%s)", err.Error())
			conn.Close()
			return err
		}
		logger.Debugf("Got request %s", string(request))
		response := handler.HandleRequest(request)
		logger.Debugf("Sent response %s", string(response))
		err = conn.Write(response)
		if err != nil {
			logger.Warnf("Error writing response (%s)", err.Error())
			conn.Close()
			return err
		}
	}
}
示例#6
0
文件: proxy.go 项目: Tactique/proxy
func (p *proxy) serverReadPump() {
	defer func() {
		p.server.conn.Close()
	}()
	for {
		msg, err := p.server.conn.Read()
		if err != nil {
			logger.Errorf("Error while reading from socket: %s", err)
			break
		}
		logger.Debugf("Received %s from socket", msg)
		p.broadcast(msg)
	}
}
示例#7
0
func ValidMove(moves int, movementType *Movement, tiles []Terrain, locations []Location) error {
	if len(locations) < 2 {
		message := "Need at least two tiles, a start and an end"
		logger.Infof(message+" (got %d)", len(locations))
		return errors.New(message)
	}
	err := assertAllTilesTouch(locations)
	if err != nil {
		return err
	}
	for _, tile := range tiles {
		moves -= int(movementType.costs[tile])
	}
	logger.Debugf("Had this many moves left %d", moves)
	if moves >= 0 {
		return nil
	} else {
		message := fmt.Sprintf("Too much distance to cover, need %d less", moves)
		logger.Infof(message)
		return errors.New(message)
	}
}
示例#8
0
func calculateDamage(attack *attack, armor *armor) int {
	damage := attack.power / armor.strength
	logger.Debugf("Calculated damage to be %d", damage)
	return damage
}