server/protocol.go

206 lines
4.5 KiB
Go
Raw Normal View History

2013-08-21 07:53:34 -07:00
package main
import (
"code.google.com/p/go.net/websocket"
2013-09-27 00:03:32 -07:00
"log"
2013-08-21 07:53:34 -07:00
)
// < the name of the game we want to join
2013-09-27 22:27:05 -07:00
type GameID struct {
Id string `json:"id"`
}
// > identify
type PlayerID struct {
Type string `json:"type"`
Hash string `json:"id"`
2013-09-27 22:27:05 -07:00
Failure
}
func NewPlayerID(id string) *PlayerID {
return &PlayerID{
Type: "idreq",
Hash: id,
2013-09-27 22:27:05 -07:00
}
}
// < [robot | spectator], name, client-type, game ID
type ClientID struct {
Type string `json:"type"`
Name string `json:"name"`
Useragent string `json:"useragent"`
}
func (c *ClientID) Valid() (bool, string) {
switch c.Type {
case "robot", "spectator":
return true, ""
}
return false, "usergent must be 'robot' or 'spectator'"
}
type ClientConfig struct {
ID string `json:"id"`
Stats StatsRequest `json:"stats"`
}
2013-09-27 22:27:05 -07:00
type BoardSize struct {
Width float32 `json:"width"`
Height float32 `json:"height"`
2013-09-27 22:27:05 -07:00
}
type GameParam struct {
BoardSize BoardSize `json:"boardsize"`
Type string `json:"type"`
}
// > [OK | FULL | NOT AUTH], board size, game params
func NewGameParam(w, h float32) *GameParam {
2013-09-27 22:27:05 -07:00
return &GameParam{
BoardSize: BoardSize{
Width: w,
Height: h,
},
Type: "gameparam",
}
}
type Handshake struct {
ID string `json:"id"`
Success bool `json:"success"`
Type string `json:"type"`
}
func NewHandshake(id string, success bool) *Handshake {
return &Handshake{
ID: id,
Success: success,
Type: "handshake",
}
}
type Failure struct {
Reason string `json:"reason"`
Type string `json:"type"`
}
func NewFailure(reason string) *Failure {
return &Failure{
Reason: reason,
Type: "failure",
}
}
func addPlayer(ws *websocket.Conn) {
var gid GameID
err := websocket.JSON.Receive(ws, &gid)
if err != nil {
log.Println("problem parsing the requested game id")
return
}
log.Printf("requested game id: %+v", gid)
game := games.get(gid.Id)
log.Printf("found game: %p", game)
if game == nil {
log.Println("game was nil")
force := *debug
if force {
log.Println("forcing game start")
game = NewGame(gid.Id, float32(*width), float32(*height))
go game.run()
games.add(game)
} else {
log.Printf("ERROR: game '%s' not found", gid.Id)
websocket.JSON.Send(ws, NewFailure("game 404"))
return
}
}
player_id := idg.Hash()
err = websocket.JSON.Send(ws, NewPlayerID(player_id))
2013-08-21 07:53:34 -07:00
if err != nil {
log.Printf("game %s: unable to send player_id to player %s", gid.Id, player_id)
websocket.JSON.Send(ws, NewFailure("send error"))
return
2013-08-21 07:53:34 -07:00
}
2013-09-27 22:27:05 -07:00
var clientid ClientID
2013-08-21 07:53:34 -07:00
err = websocket.JSON.Receive(ws, &clientid)
if err != nil {
log.Printf("unable to parse ClientID: gid: %s, player: %s", gid.Id, player_id)
websocket.JSON.Send(ws, NewFailure("parse error"))
return
2013-08-21 07:53:34 -07:00
}
if v, msg := clientid.Valid(); !v {
2013-09-27 00:03:32 -07:00
log.Printf("clientid is invalid: %+v", clientid)
2013-08-21 07:53:34 -07:00
websocket.JSON.Send(
ws,
2013-09-27 22:27:05 -07:00
NewFailure(msg),
2013-08-21 07:53:34 -07:00
)
return
2013-08-21 07:53:34 -07:00
}
log.Printf("%s: %s clientid: %+v", gid.Id, player_id, clientid)
2013-08-21 07:53:34 -07:00
gameParam := NewGameParam(game.width, game.height)
2013-08-21 07:53:34 -07:00
err = websocket.JSON.Send(ws, gameParam)
if err != nil {
log.Printf("%s %s game param parse error", gid.Id, player_id)
websocket.JSON.Send(ws, NewFailure("game param parse error"))
return
2013-08-21 07:53:34 -07:00
}
2013-09-27 00:03:32 -07:00
log.Printf("gameparam: %+v", gameParam)
2013-08-21 07:53:34 -07:00
switch clientid.Type {
case "robot":
var conf ClientConfig
2013-08-21 07:53:34 -07:00
for {
log.Printf("%s Waiting for client to send conf ...", player_id)
2013-08-21 07:53:34 -07:00
err = websocket.JSON.Receive(ws, &conf)
2013-09-27 00:03:32 -07:00
log.Printf("conf received: %+v", conf)
2013-08-21 07:53:34 -07:00
if err != nil {
log.Printf("%s %s config parse error", gid.Id, player_id)
websocket.JSON.Send(ws, NewFailure("config parse error"))
return
2013-08-21 07:53:34 -07:00
}
// TODO: verify conf's type
2013-09-03 23:26:40 -07:00
if conf.Stats.Valid() {
_ = websocket.JSON.Send(ws, NewHandshake(player_id, true))
2013-08-21 07:53:34 -07:00
break
} else {
_ = websocket.JSON.Send(ws, NewHandshake(player_id, false))
2013-08-21 07:53:34 -07:00
}
}
p := &player{
Robot: Robot{
Stats: DeriveStats(conf.Stats),
Id: player_id,
Name: clientid.Name,
Health: conf.Stats.Hp,
Scanners: make([]Scanner, 0)},
send: make(chan *Boardstate),
ws: ws,
}
2013-10-25 22:30:15 -07:00
p.reset(game)
game.register <- p
defer func() {
game.unregister <- p
}()
go p.sender()
p.recv()
log.Printf("game %s: player %v has been disconnected from this game\n", gid.Id, p.Robot.Id)
2013-08-21 07:53:34 -07:00
case "spectator":
s := &Spectator{
send: make(chan *Boardstate),
ws: ws,
}
game.sregister <- s
defer func() {
game.sunregister <- s
}()
s.sender()
log.Printf("game %s: spectator %+v has been disconnected from this game\n", s)
2013-08-21 07:53:34 -07:00
}
}